owl OWL 1.1 Web Ontology Language
Primer

Editors' Draft of 3 March 2008

Latest version:
TODAY
This version:
TODAY
Editors:
Bijan Parsia, Peter F. Patel-Schneider

Copyright © 2008 by the Editors.

Abstract

The W3C OWL 1.1 Web Ontology Language is designed to represent information about individuals, classes of individuals, and properties of individuals in a Semantic Web setting. OWL provides a rich language for structuring and categorizing individuals with both complete and incomplete information. This short primer provides an approachable introduction to OWL 1.1, including orientation for those coming from other disciplines, an example showing how OWL 1.1 can be used to represent first simple information and then more complex information, how OWL 1.1 manages ontologies, and finally the distinctions between the various sublanguages of OWL 1.1.

Status of this Document

This document has been superceeded by the OWL WG document at http://www.w3.org/2007/OWL/wiki/Primer.

Table of Contents

1 Introduction

The W3C OWL 1.1 Web Ontology Language (OWL) is a Semantic Web language designed to represent ontologies - information about how individuals are grouped and fit together in a particular domain. OWL can represent rich and complex information about classes of individuals and their properties. OWL is a logical language, where every construct has a well-defined meaning that fit together to support exact and useful representation of many different kinds of information. OWL groups information into ontologies in the form of documents that can be stored and transmitted in the World Wide Web in the same way that data and other kinds of information are and that can be completely and effectively processed by tools that extract the information implicit in an ontology.

This short primer contains, first, orientations to OWL for various communities, including XML, RDF, databases, and object-oriented programming. The bulk of the primer consists of an example that illustrates the different kinds of information that can be represented in OWL. The primer then describes how OWL packages information into ontologies and how extra information is associated with parts of an ontology. There are links from the short descriptions of the OWL constructs here to other documents that provide more information on OWL. Finally, the primer describes the various sublanguages of OWL, and what is gained and lost by using them.

2 Orientation

OWL is superficially similar to many other technologies, which is not too surprising given the prevalence of XML as a concrete syntax and of the class-object paradigm. People familiar with other technologies are sometimes misled by the similarities and thus very surprised by the differences. In section 2.1, we provide a brief orientation to OWL from a number of prominent technological perspectives. At various points in the tutorial sections of this Primer, we shall highlight aspects of OWL that might be surprising to people coming from these perspectives.

In section 2.2, we briefly discuss some major ways of using OWL in applications.

2.1 Technologies

Resource Description Framework (RDF) and Schema (RDFS): Of the technologies discussed in this section, RDF(S) is the closest to OWL. They both have roots in logic based knowledge representation; in many ways, RDF(S) can be seen as a subset of OWL; and, perhaps most prominently, the primary exchange syntax for OWL has been RDF/XML. However, there are differences of style, emphasis, and common practice that can make relying on RDF(S) intuitions misleading when working with OWL. For example, while OWL statements and expressions can be encoded as RDF facts (triples), viewing most OWL statements and expressions as collections is not typically a fruitful way of writing or understanding them . Similarly, it is fairly common and effective to work with RDF as a graph data structure or database where the primary focus is on the explicit statements in the graph.

Even when we consider parts of RDFS which support implicit knowledge, such as determining subclass relationships, the relation between the explicit and implicit statements is very direct. Thus, it is easy to conceptualize inference in terms of graph structure manipulation. In contrast, determining implicit knowledge in OWL, including determining subclass relationships and typing and checking consistency of an ontology, requires techniques that are much more akin to theorem proving.

XML: OWL and the XML family of technologies share some common parts: OWL can be expressed in XML languages (such as RDF/XML or the XML syntax for OWL [?]) and thus be manipulated by XML tools. OWL reuses datatypes and datatype derivation facets from XML Schema (and can use certain forms of XML Schema type definitions). Finally, OWL and XML can both be used for conceptual modeling as well as data definition, though they ways they go about it are fairly distinct and OWL is oriented toward more abstract, higher level conceptual modeling than is XML.

OWL is designed to support the discovery of relationships between classes through automated reasoning. OWL also builds in far fewer presumptions about the entities it is describing both generally and in terms of their physical realization in computational systems.

Both OWL and XML Schema support strong abstraction facilities. However XML Schema, is much more concerned with the data organization issues relating to its core mission of validating XML documents.

Databases: Databases (either relational or object-oriented) also store and organize information. However, databases are oriented to environments where all information that an application needs is available, where considerations of data integrity in situations of simultaneous access and update are important, or where very large amounts of data needs to be worked with. OWL is more oriented towards flexible and expressive description of data (or information), and only considers information to be complete if the completeness can be determined from other information.

It is this embracing of incompleteness that most distinguishes OWL from databases, driving the different capabilities of OWL and databases. Users who treat OWL information as complete where completeness cannot be assured are very often surprised and confused. (Similarly those who use database technology in situations where information is incomplete can be similarly surprised and confused.) Applications that incorrectly make assumption about completeness can come up with patently incorrect results.

Ontologies in OWL are much more powerful and flexible than database schemas. Database schemas generally only shape the kinds of information that is associated with objects (or tuples) that belong to a class (or table). Classes in OWL ontologies can do this, but also can provide recognition conditions so that explicit typing is not required in OWL. Of course this flexibility means that determining typing in OWL can require complex inferences.

A final major difference between databases and OWL is that the information stored in a database is derived from the database schema and integrity constraints - if the schema doesn't sanction the storage of certain kinds of information, then that information cannot be stored, and, similarly, if the information violates an integrity constraint it also cannot be stored. OWL, on the other hand, allows arbitrary information to be associated with just about any object - if there is nothing in the ontology forbidding the associated then it is allowable. OWL is thus much more flexible in its information storage.

Object-oriented Programming: Object-oriented programming (OOP) also has object-centered modeling characteristics, and thus has much in common with OWL. However, OOP generally is performed in complete-information contexts, and where the information that can possibly be known about an object is circumscribed by the information in the type of the object. As with databases, the differing stances on completeness and object information is a major difference between OWL and OOP. Similarly OOP classes are much less expressive than OWL classes.

Furthermore, OWL is a strictly declarative and logical language. OWL therefore has none of the operational aspects of OOP, like methods, and similarly reasoning in OWL is strictly logical, with nothing comparing to inheritance, particularly inheritance with exceptions or overriding.

2.2 Applications

OWL is used in a number of different ways and for a number of different domains -- far too many to enumerate here. But it's worth examining a few examples to get a feel for the sorts of problem OWL has worked well for.

Using all of the expressive power of OWL, effectively, requires a fair bit of skill.

Teminology development and management

Terminologies, controlled vocabularies, taxonomies and the like are used for a range of information retrieval (IR) tasks such as query broadening or supporting faceted access. Predefined terminologies may also be used at data entry either to categlog the entry (for IR support) or to guide the user in a variety of ways. For example, in clinical support systems certain forms or parts of forms may only be displayed when the clinician is to perform specific sorts of procedure, these procedures can be identified by a combinantion of terms from a controlled vocabulary.

Developming and maintaining large terminology is time and skill intensive, even if the structure of the terminology is relatively simple. OWL can support the process in a number of ways:

OWL has been used to support very large terminologies consisting of hundred of thousands of terms in complex hierarchies. [[Galen? NCI? SNOMED?]] Much work has been done using OWL in the Health Care and Life Sciences (HCLS) domain where there is a wealth of experience in developing large scale terminologies.

For terminology development, OWL reasoners are traditionally used at development time only, that is, off line from the application. In such cases, the reasoner acts like a "terminology complier"...assembling a complete taxonomy from definitions of terms. The taxonomy is then deployed in the application. For retrieval tasks of relatively stable collections, this has been an acceptable way to cope with the difficulty of reasoning with large ontologies. However, as computing power has increased and OWL reasoners have grown more optimized, there is increasing on line, deployment time use of OWL reasoners in terminological applications. In particular, what is sometimes known as "post coordination" -- that is, the ability of a person at the data entry point to extend the terminology to better fit their situation -- has become more common. Such dynamic terminology extension in critical systems can benefit by the methodological rigor supported by OWL reasoners. Instead of merely coining a term and plopping it somewhere in the taxonomy, end users are encouraged to refine existing terms by specializing their definitions. To take a simple example, a doctor wish to record that a patient has an almond allergy is directed to enter that an almond is a kind of nut. The system then can recognize that the almond allergy is a form of nut allergy and the requisite advice or entry forms presented as usual.

Conceptual Modeling

As we saw with terminological management, a key benefit of OWL is the support it gives to modeling subject domains, that is, to conceptual modeling. OWL is a capable language for conceptual modeling, for example, it can easily encode most entity-relationship diagrams and many UML diagrams. Once encoded, OWL reasoners can find implicit relations, conflicts, and missing pieces. Since OWL can describe and work with incomplete information it is well suited for high level conceptual work wherein you are not merely abstracting from the physical or logical layers of an information system, but you are still unsure about various aspects of the conceptual structure. OWL allows you to defer various modeling decisions while still making effective use of what you do know.

OWL supports a variety of styles of modeling, e.g., top down or bottom up, iterative or upfront, or refinement oriented vs generalizing. When modeling, a reasoner (and other tools) can provide continual feedback to the model. Indeed, often the absence of any reaction from a reasoner gives valuable information to the modeler (i.e., their model is much less well described than they had thought).

OWL based conceptual models can be used for information integration as well. For example, supposed you are faced with the task of integration two database applications that have radically different schema but, at least to a first glance, similar conceptual models. By first casting both models into OWL, then aligning parts of the model with each other, one can find hidden relations as well as inconsistencies between the model (or in your understanding of their relations). By exploring things at the conceptual level, you are not distracted by the in principle irrelevant low level implementation details. Since the models have a clear semantics, they can be systematically checked. Instead of tediously verifying correspondences by hand, you can spend your time tweaking the modeling or the alignment.

OWL based conceptual models have been used directly to federate disparate information systems. There are several techniques ranging from treating the conceptual models as high level schemas for an RDF based data store to exploiting the conceptual models to build distributed queries against the data's home systems.

3 Basic Notions

OWL allows us to express information about the world, then to draw certain consequences based on this information. There are OWL tools - reasoners - that can automatically compute these consequences. In OWL, we presume that the world is primarily made up of individual entities (typically known as individuals or objects). Individuals are related to each other and to data values via properties. Using OWL, we can group individuals that share certain characteristics into classes.

OWL is part of the Semantic Web, so names in OWL are international resource identifiers (IRIs). As IRIs are long, we will use a compact way of writing them in OWL, consisting of a prefix and a reference separated by a colon. There are various syntaxes for OWL available, which serve various purposes: When OWL information is transferred around in the Web, it is written in an XML dialect. The Manchester syntax [OWL 1.1 Manchester Syntax] is an OWL syntax that is designed to be easier for non-logicians to read. The Functional-Style syntax [OWL 1.1 Specification] is designed to be easier for specification purposes and for reasoning tools to use. The OWL XML syntax is an XML syntax for OWL defined by an XML schema [OWL 1.1 Specification]. The RDF/XML syntax for OWL is just RDF/XML, with a particular translation for the OWL constructs [OWL 1.1 RDF Mapping] There are tools that can translate between the different syntaxes for OWL.

This primer uses four different syntaxes, by default the Manchester syntax is the only one shown; the buttons below can be used to show or hide all four syntaxes. Currently many examples are missing the RDF/XML syntax. Currently the syntax examples are almost all correct (according to Protege 4, but it has one syntax bug).

3.1 Simple Information about Individuals

Suppose we want to represent information about a particular family. (We do not intend this example to be representative of the sorts of domains OWL should be used for, or as a canonical example of good modeling with OWL, or a correct representation of the rather complex, shifting, and politically explosive domain of families. Instead, we intend it to be a rather simple exhibition of various features of OWL.) We first need to determine what individuals there are in a family, and how they are related to each other and what data values are associated with them. We can then proceed by writing down all this information in OWL. [[@@Uli would like some note indicating that we'll gather up all this stuff into the appendix]]

So if we have a family with parents John and Mary and children Susan and Bill we could write all this down, along with ages as follows.

Individual: f:John
Facts: f:hasWife f:Mary,
f:hasSon f:Bill,
f:hasDaughter f:Susan,
f:hasAge 33
Individual: f:Mary
Facts: f:hasSon f:Bill,
f:hasDaughter f:Susan,
f:hasAge 31
Individual: f:Bill
Facts: f:hasAge 13
Individual: f:Susan
Facts: f:hasAge 8

We could also write down information about the sex of people by providing them with a gender, which is either male or female.

Individual: f:John Facts: f:hasGender f:male
Individual: f:Mary Facts: f:hasGender f:female
Individual: f:Bill Facts: f:hasGender f:male
Individual: f:Susan Facts: f:hasGender f:female

However, all we have done so far is written down the basic facts about a particular family. In a sense, we have used just the "RDF" portion of OWL that is tagging individuals as instances of named classes and relating them to other individuals by properties. While this is already quite useful, OWL also lets you describe how families work in general.

3.2 Information about Properties

So let's switch gears and think how families work in general. (This is the process of knowledge representation. Like all processes representing information about the world, certain simplifying assumptions must be made, and since this is a primer we are going to be simplifying a lot.) Well, the individuals in families are all people, so we should have a class of people, with name Person. Below you will find information about several properties. wife is a relationship between Persons, i.e., both the domain and range of wife is Person, as are both son and daughter. age is a relationship from a Person to an integer.

Class: f:Person
ObjectProperty: f:hasWife Domain: f:Person Range: f:Person
ObjectProperty: f:hasSon Domain: f:Person Range: f:Person
ObjectProperty: f:hasDaughter Domain: f:Person Range: f:Person
DataProperty: f:hasAge Domain: f:Person Range: integer

From this information we (or a reasoner) can conclude that John belongs to Person, because, for example, the domain of wife is Person and John has a wife. We can also directly state that an individual belongs to a class.

Individual: f:John Types: f:Person

There is more that can be said even about just this little part of familial relationships. For example, the inverse of the wife property is husband. As well, son and daughter are specializations of the child relationship. Further, no individual can be both a son and a daughter, so these properties are disjoint. Individuals have at most one age, so age is a functional data property. Individuals participate in at most one wife relationship and no individual is its own wife, so wife is functional, and inverse functional, and irreflexive. (It is also possible to specify that a property is reflexive, but this is not commonly done because the property is then reflexive for all individuals.) As well, wife is asymmetric. Note that we have added more information about several properties. It is perfectly acceptable in OWL to have information about a property (or class, or individual) occur in several places.

ObjectProperty: f:hasHusband Inverses: f:hasWife
ObjectProperty: f:hasChild Domain: f:Person range f:Person
ObjectProperty: f:hasSon SubPropertyOf: f:hasChild
ObjectProperty: f:hasDaughter SubPropertyOf: f:hasChild
DisjointObjectProperties: f:hasSon f:hasDaughter
DataProperty: f:hasAge Characteristics: Functional
ObjectProperty: f:hasWife Characteristics: Functional, InverseFunctional, Irreflexive, Asymmetric

What we have said about families and about our particular family has a number of consequences. For example, because husband is the inverse of wife, Mary's husband is John. Complete OWL reasoning tools can efficiently determine whether a particular consequence follows from the information available.

3.3 Information About Classes

So far we have written down quite a bit of information about familial properties, but we have only used a single class name: Person. OWL has a rich language for defining classes both in terms of other classes, but also in terms of the relations its instances may or must have to other individuals. So we might have classes for men, women, and parents, each of which is a specialization of Person.

Class: f:Man SubClassOf: f:Person
Class: f:Woman SubClassOf: f:Person
Class: f:Parent SubClassOf: f:Person

We can do much more in OWL with classes than just provide generalizations for them. OWL can provide partial or complete information about what is required to belong to a class. (The constructs used to provide information about classes are called descriptions in OWL.) For example, saying that people have exactly one age and exactly one gender that is either male or female provides (partial) information about people. Not only saying that every individual that belongs to Man also belongs to Person, but also saying that every Person that has gender male belongs to man, and similarly for Woman, provides complete information about what it takes to belong to these two classes. We can also say that every Person that has at least one child that is a Person belongs to Parent.

ObjectProperty: f:hasGender
Class: f:Person SubClassOf: f:hasAge exactly 1 and f:hasGender exactly 1 and f:hasGender only {f:female , f:male}
Class: f:Man EquivalentTo: f:Person and f:hasGender value f:male
Class: f:Woman EquivalentTo: f:Person and f:hasGender value f:female
Class: f:Parent EquivalentTo: f:Person and f:hasChild min 1 f:Person

Complete definitions enable many consequences in OWL. For example, from the above John belongs to Man and Parent. Some of the consequences can surprise users, so some OWL tools provide (rudimentary) facilities for showing how a consequence was determined.

In OWL, descriptions can be used just about anywhere a class name can be used. So, for example, we could provide more information about the wife, son, and daughter properties by given them more specific domains and ranges.

ObjectProperty: f:hasWife Domain: f:Man Range: f:Woman
ObjectProperty: f:hasSon Domain: f:Parent Range: (Person and f:hasGender f:male)
ObjectProperty: f:hasDaughter Domain: f:Parent Range: (Person and f:hasGender f:female)

In this case, we could just as well have used Man and Woman for the ranges of son and daughter. This would provide exactly the same information to OWL, and OWL reasoners can determine this.

It may seem that there is a circularity in defining Parent as people with at least one child and also making it be the domain of child. In OWL, however, there is no problem. The two bits of information are simply different ways of saying the same thing.

3.4 Data Ranges

OWL can also represent information about certain groupings of data values, called data ranges. For example, we might have Teenager as those people whose age is at least 13 but less than 20, Adult as those people whose age is at least 21, and Child as those people whose age is in the complement of adult ages.

Class: Teenager EquivalentClass: Person and hasAge some integer[>= 13 , < 20]
Class: Adult EquivalentClass: Person and hasAge some integer[>= 21]
Class: Child EquivalentClass: Person and not ( hasAge some integer[>= 21] )

From this, Bill belongs to Teenager, but not Adult. Both John and Mary belong to Adult, but not to Teenage. Mary belongs to neither Adult nor to Teenage.

OWL uses primitive datatypes taken from XML Schema datatypes [XML Schema Datatypes], e.g., xsd:integer, to construct data ranges. Other useful datatypes include xsd:string and xsd:decimal.

4 Advanced Notions

So far we have seen OWL used as little more than a data structuring language. OWL is considerably more expressive than data structuring languages, in several useful ways. Some of this added expressive power illustrates the differences between OWL and other formalisms and why we have to understand how OWL is different.

4.1 Incomplete Information about Data Values

In the example so far, we knew quite a bit of information. We knew, for example, that John's (only) age was 47. OWL is designed to deal with incomplete information, so it is quite common in OWL not to know, for example, the ages of all individuals belonging to Person, as just below.

Individual: f:Jeff
Facts: f:hasWife f:Emily,
f:hasChild f:Ellen,
f:hasChild f:Jack,
f:hasAge 77

It is a consequence of the above that Jeff belongs to Adult and not to Teenager. However, it cannot be determined whether Emily or Jack belong to Adult or Teenager, even though they both must have an age.

It is also possible to provide partial information about values, as in saying that Ellen's age is between 15 and 21, inclusive, that Emily's age is either 39 or 49, or even that Jack's age is not 53.

Individual: f:Emily Types: f:hasAge some {39 , 49}
Individual: f:Ellen Types: f:hasAge some integer[ ≥ 15, ≤ 21 ]
Individual: f:Jack Facts: not f:hasAge "53"^^integer

From this it is possible to determine that Emily belongs to Adult, even though we don't know her exact age, but we cannot determine that Ellen belongs to either Adult or Teenager. On the other hand, we could have a class YoungChild that was neither Adult nor Teenager. Ellen would then not belong to this class.

Class: f:YoungChild EquivalentTo: f:Person and not ( f:Teenager or f:Adult )

4.2 Other Incomplete Information

There are many sources of incompleteness in OWL, some of which may be surprising to some readers. For example, although it may seem to be the case that Jeff has exactly two children, this is not the case, nor is it the case that Jeff has only one child that belongs to Man. Formally, the following is not a consequence of the above information.

Individual: f:Jeff f:Person and f:hasChild exactly 2
Individual: f:Jeff f:Person and f:hasChild max 1 f:Man

These do not follow because there is nothing saying that Jack and Ellen are the only children of Jeff, and OWL does not make any assumptions that something that has not been said is not true. It is possible to state that Jeff has no other children, and this can be done in a number of ways. One way that is often used for this purpose is to directly say that Jeff has exactly 2 children, which should certainly be adequate to infer that Jeff has exactly 2 children.

4.3 Same and Different Individuals

However, even this is not adequate to infer that Jeff has only one child that belongs to Man. We have not stated that Jack and Ellen are different people, and there is nothing said so far that implies that they are not the same. Again OWL does not make the assumption that different names are names for different individuals. (This "unique names assumption" would be particularly dangerous in the Semantic Web, where names may be coined by different organizations at different times unknowingly referring to the same individual.) If Jack and Ellen are the same, then there could be another child of John, and this child could belong to Man.

One might think that Jack and Ellen are different because they have different genders, and people have exactly one gender. Unfortunately, we have not stated that male and female are different. We could just state that male and female are different, and have this imply that Jack and Ellen are different, but let's add in a reasonable collection of information about which names are different. Note that we don't really have to do this for John's family as their different ages imply that they are all different. Similarly the wifes and their husbands were already known to be different, because we already stated that wife is irreflexive.

DifferentIndividuals: f:John f:Mary f:Bill f:Susan
DifferentIndividuals: f:Jeff f:Emily f:Jack f:Ellen f:Susan
Individual: f:male DifferentFrom: f: female

It is also possible to state that two names refer to (denote) the same individual. For example, we can say that John and Jack are the same individual.

Individual: f:John SameAs: f:Jack

4.4 Disjointness of Classes

From the above we can conclude that Man and Woman are disjoint, i.e., that they can never have individuals belonging to both of them, because every Person has exactly one gender and individuals that belong to Man have a different gender (male) from those that belong to Woman (female). However, we can also use OWL to state that classes are disjoint. This is most often done for classes that lack complete conditions for belonging to the class. (These classes are called primitive classes.) So, for example, for ReligiousMarriage and CivilMarriage, we have to directly state their disjointness, and here we also say that Marriage is the union of the two.

Class: f:ReligiousMarriage DisjointWith: f:CivilMarriage
Class: f:Marriage EquivalentTo: f:ReligiousMarriage or f:CivilMarriage

As it is common to have this situation of a class that is the union of a number of disjoint classes, OWL provides a shorthand method for saying this all at once.

Class f:Marriage DisjointUnionOf: f:ReligiousMarriage f:CivilMarriage

4.5 More Information About Properties

[[@@Uli comment: Section seems very advanced and she was surprised not to see stuff on universial/existential quantifiers]]

In OWL we can have transitive properties, i.e., properties like ancestor, which also is a generalization of the inverse of the child property, and is also irreflexive.

ObjectProperty: f:hasAncestor Characteristics: Transitive, Irreflexive
ObjectProperty: f:hasChild SubPropertyOf: inverseOf f:hasAncestor

From the above information, we can now conclude that Bill has Jeff as an ancestor, and that Bill is not his own ancestor.

Individual: f:Bill Facts: f:hasAncestor f:Jeff
not f:hasAncestor f:Bill

There are yet other kinds of information that we can provide about properties. We can have a spouse property as a symmetric and irreflexive generalization of wife.

ObjectProperty: f:hasSpouse Characteristics: Symmetric, Irreflexive
ObjectProperty: f:hasWife SubPropertyOf: f:hasSpouse

Although we haven't directly so stated, we can conclude that spouse is also a generalization of husband, because spouse is a symmetric generalization of the inverse of husband.

We could enrich our example to include a loves property as a generalization of the wife property. (Thus turning our simplied view of familial relationships into an idealistic one as well.)

ObjectProperty: f:loves Domain: f:Person
ObjectProperty: f:hasWife SubPropertyOf: f:loves

Because loves is not symmetric, we cannot conclude that loves is a generalization of husband. We have also not specified whether loves is reflexive or not, so some people may love themselves. We could have Narcissist, those people who love themselves, and add some more information about loves relationships>

Class: f:Narcissist EquivalentTo: f:Person and f:loves Self
Individual: f:Jeff Facts: f:loves f:Jeff
Individual: f:Bill Types: not f:Narcissist

From this we can conclude that Jeff belongs to Narcissist and that, of course, Bill does not.

In OWL we can also say some things about how properties combine, using chains of object properties. For example, we can say that sons and daughters are the same for both spouses, i.e., the sons and daughters of an individual include those of their spouse.

SubObjectProperty: f:hasSpouse o f:hasSon f:hasSon
SubObjectProperty: f:hasSpouse o f:hasDaughter f:hasDaughter

We can now conclude that Emily has the same sons and daughters as Jeff:

f:Emily f:hasChild f:Jack
f:Emily f:hasChild f:Ellen

4.6 Conflicting Information

It is also possible to provide conflicting information to OWL. For example, we could say that John has no children who belong to Woman, which conflicts with John having Susan as a daughter.

Individual: f:John f:hasChild max 0 f:Woman

In the presence of conflicting information, determining consequences in OWL breaks down, so it is generally not a good idea to have conflicting information. There is no notion that OWL tools have to reject conflicting information. However, most OWL tools will at least provide some mechanisms to identify conflicting information and allow users to resolve the conflict.

5 Ontology Management

5.1 OWL Ontologies, Documents, and Namespaces

The information we have stated so far falls into two categories. We have stated general information about classes and properties related to familial relationships and particular information about two linked families. In OWL general information about a topic is almost always gathered into an ontology that is then used by various applications. We can also provide a name for OWL ontologies, which is generally the place where the ontology document is placed in the web. Particular information about a topic can also be placed in an ontology, if it is used by different applications.

Ontology: <http://ex.com/owl/families>

We place OWL ontologies into OWL documents, which are then placed into local filesystems or on the World Wide Web. Aside from containing an OWL ontology, OWL documents also contain information about transforming the short names used in OWL ontologies (e.g., f:Person) into IRIs, by providing the expansion for prefixes. The IRI is then the concatention of the prefix expansion and the reference.

In our example ontology we have used two prefixes, f and xsd. The latter prefix has been used in compact names for XML Schema datatypes, whose IRIs are fixed by the XML Schema recommendation. We thus must the standard expansion for xsd, which is http://www.w3.org/2001/XMLSchema#. The expansion we pick for our the other prefix will affect the names of the classes, properties, and individuals in our ontology, as well as the name of the ontology itself. If we are going to put the ontology on the web, we should pick an expansion that is in some part of the web that we control, both so that we are not using someone else's names by accident. (Here we use a made-up name that no one controls.)

Namespace: f = <http://ex.com/owl/families#>
Namespace: g = <http://ex2.com/owl2/families#>
Namespace: rdf = <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
Namespace: rdfs = <http://www.w3.org/2000/01/rdf-schema#>
Namespace: xsd = <http://www.w3.org/2001/XMLSchema#>
Namespace: dc = ??

5.2 Imports

It is also common in OWL to reuse general information in other ontologies. Instead of requiring the copying of this information, OWL allows the importation of the contents of entire ontologies in other ontologies, using imports statements, as follows:

Import: http://ex2.com/owl2/families

As the Semantic Web and ontology construction is distributed it is common for ontologies to use different names for the same concept, property, or individual. Several constructs in OWL can be used to state that different names refer to the same concept, property, or individual, so, for example, we could tie the names used in our ontology to the names used in an imported ontology as follows:

SameIndividual: f:male g:masculine
SameIndividual: f:female g:feminine
EquivalentClasses: f:Adult g:Grownup
EquivalentObjectProperties: f:hasChild g:child
EquivalentDataProperties: f:hasAge g:age

5.3 Annotations

In many cases we want to associate information with parts of our OWL ontology. OWL uses annotations for this purpose. An OWL annotation simply associates property-value pairs with parts of an ontology, or the entire ontology itself. This information is not really part of the logical meaning of an ontology.

So, for example, we could add author information to one of the facts in our ontology and to one of the classes.

Individual f:John Facts: Annotations: dc:author Individual(f:peter) dc:creationDate "2008-01-10"^^xsd:date rdfs:comment "A simple fact about John" f:hasWife f:Mary

Class: f:Person Annotations: dc:author Individual(f:peter) dc:creationDate "2008-01-10"^^xsd:date rdfs:label "Person":en rdfs:label "Persona":it rdfs:comment "The class of people"

5.3 Declarations

To help with managing ontologies, OWL has the notion of declarations. The basic idea is that each class, property, or individual is supposed to be declared in an ontology, and then it can be used in that ontology and ontologies that import that ontology.

In the Manchester syntax, declarations are implicit. Constructs that provide information about a class, property, or individual implicitly declare that class, property, or individual if needed. The other syntaxes have explicit declarations.

6 Remaining Constructs

There are a few other kinds of things that can be said in OWL, but that do not fit into this example, including the following:

Details on these constructs can be found in the OWL 1.1 Structural Specification and Functional Syntax document [OWL 1.1 Specification].

7 Using OWL

8 OWL Tools

9 OWL Species

As we have seen, reasoning in OWL can be complicated. The full story of reasoning in OWL is beyond the scope of this primer, but there are some implications of reasoning that deserve treatement here.

7.1 OWL Full

If we did not place further restrictions on what we can say in OWL, e.g., classes, properties, and even bits of syntax can be used as individuals as in the Semantic Web language RDF, reasoning becomes formally undecidable. Nevertheless, there is some utility in being able to do this, so there is a mode of using OWL, called OWL Full that allows all this. The price, of course, is that reasoning tools are hard to write and are necessarily incomplete.

7.2 OWL DL

There are a set of reasonable restrictions, however, that make reasoning in OWL decidable, and for which, moreover, there exist effective reasoning tools. This mode of using OWL is called OWL DL.

To allow effective reasoning tools, OWL DL limits the kinds of things that can be said about certain properties. Properties are said to be composite if they or their inverses are transitive or have a property chain as a subproperty. Properties that are composite or have a composite property as a specialization of themselves or their inverses are not allowed to be functional, inverse functional, irreflexive, asymmetric, or disjoint with any other property; nor are they allowed to participated in cardinality or self conditions. As well, there is a complex condition on how object property chains are constructed to prevent loops related to object property chains. OWL DL tools should recognize whether these conditions are violated in an ontology.

OWL DL allows the same name to be used for any or all of a class, a property, and an individual. However, the different aspects of this name are not tied to one another, so that if, for example, we said, perhaps by accident that Person and Man were the same individual, they would not also be equivalent classes.

SameIndividual: f:Person f:Man

The above would not allow the conclusion of:

EquivalentClasses: f:Person f:Man

OWL Full is formally stronger than OWL DL in this area (and in a few other areas) so in OWL Full this conclusion could be drawn.

7.3 OWL Fragments

Reasoning in OWL DL is still difficult, and can take a very long time in the worst case. Certain fragments of OWL DL have been identified that guarantee better worst-case performance for reasoning. The document on OWL Fragments [OWL 1.1 Fragments] identifies and chacterizes several of these fragments that have been shown to be useful in practice. Staying within one of these fragments limits what we can say, but this tradeoff can often be desirable when writing large ontologies, particularly for important applications.

10 What to Do Next

This short primer can only scratch the surface of OWL. There are many longer and more involved tutorials on OWL and how to use OWL tools that can be found by searching on the Web. Reading one of these primers and using a tool to build an OWL ontology is probably the best way to learn more about OWL.

This short primer is also not a normative definition of OWL. The normative definition of the OWL syntax as well as informative definitions of each OWL construct can be found in the OWL 1.1 Structural Specification and Functional Syntax document [OWL 1.1 Specification].

For those interested in more formal documents, the formal meaning of OWL can be found in the OWL 1.1 Semantics document [OWL 1.1 Specification], and the mapping between OWL syntax and RDF triples can be found in the OWL 1.1 Mapping to RDF Graphs document [OWL 1.1 RDF Mapping].

Appendix: The Complete Example

Here we include the complete example OWL ontology. The ontology here is ordered in a commonly-used ordering, with ontology information first, followed by information aabout properties, then classes, then individuals. Extra annotations have been added (not YET) to help explain the ontology.

Namespace: f =<http://ex.com/owl/families#> Namespace: g = <http://ex2.com/owl/families.owl#> Namespace: rdfs = <http://www.w3.org/2000/01/rdf-schema#> Namespace: rdf = <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
Ontology: <http://ex.com/owl/families>
Import: http://ex2.com/owl2/families.owl
ObjectProperty: hasWife Domain: Person, Man Range: Person, Woman Characteristics: Functional, InverseFunctional, Irreflexive, Asymmetric SubPropertyOf: hasSpouse, loves
ObjectProperty: hasHusband Inverses: hasWife
ObjectProperty: hasSon Domain: Person, Parent Range: Person, Person that hasGender value male SubPropertyOf: hasChild DisjointWith: hasDaughter
SubObjectProperty: f:hasSpouse o f:hasSon f:hasSon
ObjectProperty: hasDaughter Domain: Person, Parent Range: Person, Person that hasGender value female SubPropertyOf: hasChild
SubObjectProperty: f:hasSpouse o f:hasDaughter f:hasDaughter
ObjectProperty: hasGender
ObjectProperty: hasChild Domain: Person Range: Person SubPropertyOf: inverseOf hasAncestor
ObjectProperty: hasAncestor Characteristics: Transitive, Irreflexive
ObjectProperty: hasSpouse Characteristics: Symmetric, Irreflexive
ObjectProperty: loves Domain: Person
DataProperty: hasAge Domain: Person Range: integer Characteristics: Functional
Class: Person SubClassOf: hasAge exactly 1 and hasGender exactly 1 and hasGender only {female , male}
Class: Man EquivalentTo: Person that hasGender value male
Class: Woman EquivalentTo: Person that hasGender value female
Class: Parent EquivalentTo: Person that hasChild min 1 Class: Teenager EquivalentTo: Person that hasAge some integer[>= 13 , < 20]
Class: Adult EquivalentTo: Person that hasAge some integer[>= 21]
Class: Child EquivalentTo: Person and not (hasAge some integer[>= 21])
Class: YoungChild EquivalentTo: Person and not (Teenager or Adult)
Class: Marriage EquivalentTo: CivilMarriage or ReligiousMarriage
Class: ReligiousMarriage DisjointWith: CivilMarriage
Class: CivilMarriage
Class: Narcissist EquivalentTo: Person that loves Self
Individual: male DifferentFrom: female
Individual: female
Individual: John Types: Person Facts: hasWife Mary, hasSon Bill, hasDaughter Susan, hasAge 33, hasGender male SameAs: Jack
Individual: Mary Facts: hasSon Bill, hasDaughter Susan, hasAge 31, hasGender female
Individual: Bill Types: not (Narcissist) Facts: hasAge 13, hasGender male
Individual: Susan Facts: hasAge 8, hasGender female
Individual: Jeff Types: hasChild exactly 2 Facts: hasWife Emily, hasChild Ellen, hasChild Jack, hasAge 77, loves Jeff
Individual: Emily Types: hasAge some {39 , 49}
Individual: Ellen Types: hasAge some integer[>= 15 , <= 21]
Individual: Jack Facts: not hasAge "53"^^integer
DifferentIndividuals: f:John f:Mary f:Bill f:Susan
DifferentIndividuals: f:Jeff f:Emily f:Jack f:Ellen f:Susan

SameIndividual: f:male g:masculine SameIndividual: f:female g:feminine EquivalentClasses: f:Adult g:Grownup EquivalentObjectProperties: f:hasChild g:child EquivalentDataProperties: f:hasAge g:age

References

[OWL 1.1 Fragments]
OWL 1.1 Web Ontology Language: Tractable Fragments. Bernardo Cuenca Grau, 2007. http://www.w3.org/2007/OWL/wiki/Tractable_Fragments
[OWL 1.1 Manchester Syntax]
OWL 1.1 Web Ontology Language: Manchester Syntax. Matthew Horridge and Peter F. Patel-Schneider and others, 2008. http://www.webont.org/owl/documents/manchester.html
[OWL 1.1 RDF Mapping]
OWL 1.1 Web Ontology Language: Mapping to RDF Graphs. Bernardo Cuenca Grau and Boris Motik. W3C Working Draft 8 January 2008. http://www.w3.org/TR/2008/WD-owl11-mapping-to-rdf-20080108/, current version available at http://www.w3.org/TR/owl11-mapping-to-rdf/.
[OWL 1.1 Semantics]
OWL 1.1 Web Ontology Language: Model-Theoretic Semantics. Bernardo Cuenca Grau and Boris Motik. W3C Working Draft 8 January 2008. http://www.w3.org/TR/2008/WD-owl11-semantics-20080108/, current version available at http://www.w3.org/TR/owl11-semantics/.
[OWL 1.1 Specification]
OWL 1.1 Web Ontology Language: Structural Specification and Functional-Style Syntax. Boris Motik, Peter F. Patel-Schneider, and Ian Horrocks. W3C Working Draft 8 January 2008. http://www.w3.org/TR/2008/WD-owl11-syntax-20080108/, current version available at http://www.w3.org/TR/owl11-syntax/.
[OWL 1.1 XML Syntax]
OWL 1.1 Web Ontology Language: XML Serialization. Bernardo Cuenca Grau, Boris Motik, and Peter F. Patel-Schneider, 2008. http://www.w3.org/2007/OWL/wiki/XML_Serialization
[XML Schema Datatypes]
XML Schema Part 2: Datatypes Second Edition. Paul V. Biron and Ashok Malhotra, eds. W3C Recommendation 28 October 2004.