Web Ontology Language (OWL): Overview

W3C Working Draft February 3, 2003

This version:

http://www.ksl.stanford.edu/people/dlm/webont/OWLOverview.htm

Latest version:

http://www.ksl.stanford.edu/people/dlm/webont/OWLOverview.htm

Editors:

Deborah L. McGuinness (Knowledge Systems Laboratory, Stanford University) dlm@ksl.stanford.edu

Frank van Harmelen (Vrije Universiteit, Amsterdam) Frank.van.Harmelen@cs.vu.nl

Copyright ©2003 W3C^® (MIT, ERCIM , Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.

---

Abstract

OWL (the Web Ontology Language) is intended to be used by applications that need to process the content of information instead of just presenting the human-readable content. OWL facilitates greater machine readability of web content than that supported by XML, RDF, and RDF Schema by providing additional vocabulary along with a formal semantics. The OWL language provides three increasingly expressive sublanguages: OWL Lite, OWL DL, and OWL Full.

This document is written for readers who would like a first impression of the capabilities of OWL. It provides an introduction to OWL by informally describing the features of each of the sublanguages of OWL. Some knowledge of RDF Schema is useful for understanding this document, but not essential. After this document, interested readers may turn to the OWL Guide for a more detailed descriptions and extensive examples on the features of OWL. The normative formal definition of OWL can be found in the OWL Abstract Syntax and Semantics.

Status of this document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C Recommendations and other technical reports is available at http://www.w3.org/TR/.

This Overview is a non-normative document, which means that it does not provide a definitive specification of OWL. The examples and other explanatory material in the Overview are provided to help you understand OWL, but they may not always provide definitive or complete answers. The normative formal definition of OWL can be found in the OWL Abstract Syntax and Semantics.

This document is a working document for the use by W3C Members and other interested parties. It may be updated, replaced or made obsolete by other documents at any time.

This document has been produced by the Web Ontology Working Group, as part of the W3C Semantic Web Activity. The goals of the Web Ontology working group are discussed in the Web Ontology Working Group charter.

Comments on this document should be sent to the W3C mailing list public-webont-comments@w3.org (with public archive).

There are no patent disclosures related to this work at the time of this writing.

Table of contents

1. Introduction
   1. Why OWL?
   2. The three sublanguages of OWL
   3. The structure of this document
2. Language Synopsis
   1. OWL Lite Synopsis
   2. OWL DL and OWL Full Synopsis
3. Language Description of OWL Lite
   1. OWL Lite RDF Schema Features
   2. OWL Lite Equality and Inequality
   3. OWL Lite Property Characteristics
   4. OWL Lite Property Type Restrictions
   5. OWL Lite Restricted Cardinality
   6. OWL Lite Header Information
   7. OWL Lite Class Intersection
4. Incremental Language Description of OWL DL and OWL Full
5. Summary

1. Introduction

This document describes OWL (the Web Ontology Language). OWL is intended to be used by applications that need to process the document content, as opposed to presenting the content to humans. OWL can be used to explicitly represent the meaning of terms in vocabularies and the relationships between those terms. This representation of terms and their interrelationships is considered an ontology. OWL has more facilities for expressing meaning and semantics than XML, RDF, and RDF-S, and thus OWL goes beyond these languages in its ability to represent machine readable content on the web. OWL is a revision of the DAML+OIL web ontology language incorporating lessons learned from the design and application of DAML+OIL.

The goal of this document is to provide a simple introduction to OWL by providing a language feature listing with very brief feature descriptions. For a more complete description of OWL, see the OWL Reference, the OWL Guide for an extended example, and the OWL Abstract Syntax and Semantics document for the normative formal description of OWL. A glossary of the terminology used in this and the other documents can be found in the OWL Guide.

1.1 Why OWL?

The Semantic Web is a vision for the future of the Web in which information is given explicit meaning, making it easier for machines to automatically process and integrate information available on the Web. The Semantic Web will build on XML's ability to define customized tagging schemes and RDF's flexible approach to representing data. The next element required for the Semantic Web is a Web Ontology Language (OWL) which can formally describe the meaning of the terminology used in web documents and term interrelationships. If machines are expected to perform useful reasoning tasks on these documents, the language must go beyond the basic semantics of RDF Schema. The OWL Requirements Document provides more details on ontologies, motivates the need for a Web Ontology Language in terms of six use cases, and formulates design goals, requirements and objectives for OWL providing further support for OWL.

OWL is part of a "stack" of Semantic Web related W3C recommendations, in the following way:

XML

provides a surface syntax for structured documents, but imposes no semantic constraints on the meaning of these documents.

XML Schema

is a language for restricting the structure of XML documents.

RDF

is a datamodel for objects ("resources") and relations between them, provides a simple semantics for this datamodel, and these datamodels can be represented in an XML syntax.

RDF Schema

is a vocabulary for describing properties and classes of RDF resources, with a semantics for generalization-hierarchies of such properties and classes.

OWL

adds more vocabulary for describing properties and classes: among others, relations between classes (e.g. disjointness), cardinality (e.g. "exactly one"), equality, richer typing of properties, characteristics of properties (e.g. symmetry), and enumerated classes.

1.2 The three sublanguages of OWL

OWL provides three increasingly expressive sublanguages designed for use by specific communities of implementers and users.

• OWL Lite supports those users primarily needing a classification hierarchy and simple constraint features. For example, while it supports cardinality constraints, it only permits cardinality values of 0 or 1. It should be simpler to provide tool support for OWL Lite than its more expressive relatives, and provides a quick migration path for thesauri and other taxonomies.

• OWL DL supports those users who want the maximum expressiveness while their reasoning systems maintain computational completeness (all conclusions are guaranteed to be computed) and decidability (all computations will finish in finite time). OWL DL includes all OWL language constructs, but they can be used only under certain restrictions (for example, while a class may be a subclass of many classes, a class cannot be an instance of another class). OWL DL is so named due to its correspondence with description logics, a field of research that has studied the logics that form the formal foundation of OWL.

• OWL Full is meant for users who want maximum expressiveness and the syntactic freedom of RDF with no computational guarantees. For example, in OWL Full a class can be treated simultaneously as a collection of individuals and as an individual in its own right. OWL Full allows an ontology to augment the meaning of the pre-defined (RDF or OWL) vocabulary. It is unlikely that any reasoning software will be able to support every feature of OWL Full.

Each of these sublanguages is an extension of its simpler predecessor, both in what can be legally expressed and in what can be validly concluded. The following set of relations hold. Their inverses do not.

• Every legal OWL Lite ontology is a legal OWL DL ontology.
• Every legal OWL DL ontology is a legal OWL Full ontology.
• Every valid OWL Lite conclusion is a valid OWL DL conclusion.
• Every valid OWL DL conclusion is a valid OWL Full conclusion.

Ontology developers adopting OWL should consider which sublanguage best suits their needs. The choice between OWL Lite and OWL DL depends on the extent to which users require the more expressive restriction constructs provided by the full language. The choice between OWL DL and OWL Full mainly depends on the extent to which users require the meta-modeling facilities of RDF Schema (e.g. defining classes of classes, attaching properties to classes). When using OWL Full as compared to OWL DL, reasoning support is less predictable since complete OWL Full implementations do not currently exist.

1.3 The structure of this document

This document first describes the language features from OWL Lite, followed by a description from the language features that are added in OWL DL and OWL Full (OWL DL and OWL Full contain the same language features, but OWL Full is more liberal about how these features can be combined)

2. Language Synopsis

In this document, italicized terms are terms in OWL. Prefixes of rdf: or rdfs: are used when terms are already present in RDF or RDF Schema. Otherwise terms are introduced by OWL. Thus, the term rdfs:subPropertyOf indicates that subPropertyOf is already in the rdfs vocabulary (technically : the rdfs namespace). Also, the term Class is more precisely stated as owl:Class and is a term introduced by OWL.

2.1 OWL Lite Synopsis

The list of OWL Lite language constructs are given below.

RDF Schema Features: Class rdf:Property rdfs:subClassOf rdfs:subPropertyOf rdfs:domain rdfs:range Individual	(In)Equality: sameClassAs samePropertyAs sameIndividualAs differentIndividualFrom allDifferent	Property Characteristics: inverseOf TransitiveProperty SymmetricProperty FunctionalProperty InverseFunctionalProperty
Property Type Restrictions: allValuesFrom someValuesFrom Class Intersection: intersectionOf	Restricted Cardinality: minCardinality (only 0 or 1) maxCardinality (only 0 or 1) cardinality (only 0 or 1)	Header Information: imports versionInfo priorVersion backwardCompatibleWith incompatibleWith

2.2 OWL DL and Full Synopsis

The list of OWL DL and OWL Full language constructs that are in addition to those of OWL Lite are given below.

Class Axioms: oneOf disjointWith sameClassAs (applied to class expressions) rdfs:subClassOf (applied to class expressions)	Boolean Combinations of Class Expressions: unionOf intersectionOf complementOf
Arbitrary Cardinality: minCardinality maxCardinality cardinality	Filler Information: hasValue

3. Language Description of OWL Lite

3.1 OWL Lite RDF Schema Features

The following OWL Lite features related to RDF Schema are included.

• Class: A class defines a group of individuals that belong together because they share some properties. For example, Deborah and Frank are both members of the class Person. Classes can be organized in a specialization hierarchy using SubClassOf. There is a built-in most general class named Thing that is the class of all individuals and the superclass of all classes.
• rdfs:subClassOf: Class hierarchies may be created by making one or more statements that a class is a subclass of one or more other classes. For example, the class Person could be stated to be a subclass of the class Mammal. From this a reasoner can deduce that if X is a Person, then X is a Mammal.
• rdfs:Property: A property is a relationship between individuals. Examples of properties include: hasChild, hasRelative, hasSibling, and hasAge. The first three relate an instance of a class Person to another instance of the class Person (and are thus ObjectProperties), and the last one (hasAge) relates an instance of the class Person to an instance of the datatype Integer (and is thus a Datatype property).
• rdfs:subPropertyOf: Property hierarchies may be created by making one or more statements that a property is a subproperty of one or more other properties. For example, hasSibling may be stated to be a subproperty of hasRelative. From this a reasoner can deduce that if X is related to Y by the hasSibling property, then X is also related to Y by the hasRelative property.
• rdfs:domain: The domain of a property is the set of individuals to which the property can be applied: if a property P relates individual X to individual Y, and p has as domain the class Z, then X must be an instance of Z. For example, the property hasChild may be stated to have the domain of Mammal. From this a reasoner can deduce that if Frank hasChild Anna, then Frank must be a Mammal. Note that rdfs:domain is called a global restriction since the restriction is stated on the property and not just on the property when it is associated with a particular class. See the discussion below on local restrictions for more information.
• rdfs:range: The range of a property is the set of individuals that the property may have as its value: if a property P relates individual X to individual Y, and P has as range the class Z, then Y must be an instance of Z. For example, the property hasChild may be stated to have the range of Mammal. From this a reasoner can deduce that if Louise is related to Deborah by the hasChild property, i.e., Deborah is the child of Louise, then Deborah is a Mammal. Range is also a global restriction as is domain above. Again, see the discussion below on local restrictions (e.g. AllValuesFrom) for more information.
• Individual: Individuals are instances of classes, and properties may be used to relate one individual to another. For example, an individual named Deborah may be described as an instance of the class Person and the property hasEmployer may be used to relate the individual Deborah to the individual StanfordUniversity.

3.2 OWL Lite Equality and Inequality

• sameClassAs: Two classes may be stated to be identical (i.e., they may be stated to be different names for the same set of individuals). Equality can be used to create synonymous classes. For example, Car can be stated to be sameClassAs Automobile. From this a reasoner can deduce that any individual that is an instance of Car is also an instance of Automobile and vice versa.
• samePropertyAs: Two properties may be stated to be identical. Equality may be used to create synonymous properties. For example, hasLeader may be stated to be the samePropertyAs hasHead. From this a reasoner can deduce that if X is related to Y by the property hasLeader, X is also related to Y by the property hasHead and vice versa. A reasoner can also deduce that hasLeader is a subproperty of hasHead and hasHead is a subProperty of hasLeader.
• sameIndividualAs: Two individuals may be stated to be the same. This construct may be used to create a number of different names that refer to the same individual. For example, the individual Deborah may be stated to be the same individual as DeborahMcGuinness.
• differentIndividualFrom: An individual may be stated to be different from other individuals. For example, the individual Frank may be sta ted to be different from the individuals Deborah and Jim. Thus, if the individuals Frank and Deborah are both values for a property that is stated to be functional (thus the property has at most one value), then there is a contradiction. Explicitly stating that individuals are different can be important in when using languages such as OWL (and RDF) that do not assume that individuals have one and only one name. For example, with no additional information, a reasoner will not deduce that Frank and Deborah refer to distinct individuals.
• allDifferent: A number of individuals may be stated to be mutually distinct in one allDifferent statement. For example, Frank, Deborah, and Jim could be stated to be mutually distinct using the allDifferent construct. Unlike the differentIndividualFrom statement above, this would also enforce that Jim and Deborah are distinct (not just that Frank is distinct from Deborah and Frank is distinct from Jim). The allDifferent construct is particularly useful when there are sets of distinct objects and when modelers are interested in enforcing the unique names assumption within those sets of objects.

3.3 OWL Lite Property Characteristics

• inverseOf: One property may be stated to be the inverse of another property. If the property P1 is stated to be the inverse of the property P2, then if X is related to Y by the P2 property, then Y is related to X by the P1 property. For example, if hasChild is the inverse of hasParent and Deborah hasParent Louise, then a reasoner can deduce that Louise hasChild Deborah.
• TransitiveProperty: Properties may be stated to be transitive. If a property is transitive, then if the pair (x,y) is an instance of the transitive property P, and the pair (y,z) is an instance of P, then the pair (x,z) is also an instance of P. For example, if ancestor is stated to be transitive, and if Sara is an ancestor of Louise (i.e., (Sara,Louise) is an instance of the property ancestor) and Louise is an ancestor of Deborah (i.e., (Louise,Deborah) is an instance of the property ancestor), then a reasoner can deduce that Sara is an ancestor of Deborah (i.e., (Sara,Deborah) is an instance of the property ancestor).
  OWL Lite (and OWL DL) impose the side condition that transitive properties (and their superproperties) cannot have a maxCardinality 1 restriction. Without this side-condition, OWL Lite and OWL DL would become undecidable languages. See the property axiom section of the OWL Abstract Syntax and Semantics document for more information.
• SymmetricProperty: Properties may be stated to be symmetric. If a property is symmetric, then if the pair (x,y) is an instance of the symmetric property P, then the pair (y,x) is also an instance of P. For example, friend may be stated to be a symmetric property. Then a reasoner that is given that Frank is a friend of Deborah can deduce that Deborah is a friend of Frank. Note that properties that are to be made symmetric may not have arbitrary domains and ranges.
• FunctionalProperty : Properties may be stated to have a unique value. If a property is a FunctionalProperty, then it has no more than one value for each individual (it may have no values for an individual). This characteristic has been referred to as having a unique property. FunctionalProperty is shorthand for stating that the property's minimum cardinality is zero and its maximum cardinality is 1. For example, hasPrimaryEmployer may be stated to be a FunctionalProperty. From this a reasoner may deduce that no individual may have more than one primary employer. This does not imply that every Person must have at least one primary employer however.
• InverseFunctionalProperty: Properties may be stated to be inverse functional. If a property is inverse functional then the inverse of the property is functional. Thus the inverse of the property has at most one value for each individual. This characteristic has also been referred to as an unambiguous property. For example, hasUSSocialSecurityNumber (a unique identifier for United States residents) may be stated to be inverse functional (or unambiguous). The inverse of this property (which may be referred to as isTheSocialSecurityNumberFor) has at most one value for any individual in the class of social security numbers. Thus any one person's social security number is the only value for their isTheSocialSecurityNumberfor property. From this a reasoner can deduce that no two different individual instances of Person have the identical US Social Security Number. Also, a reasoner can deduce that if two instances of Person have the same social security number, then those two instances refer to the same individual.

3.4 OWL Lite Property Type Restriction

• allValuesFrom: The restriction allValuesFrom is stated on a property with respect to a class. It means that this property on this particular class has a local range restriction associated with it. Thus if an instance of the class is related by the property to a second individual, then the second individual can be inferred to be an instance of the local range restriction class. For example, the class Person may have a property called hasOffspring restricted to have allValuesFrom the class Person. This means that if an individual person Louise is related by the property hasOffspring to the individual Deborah, then from this a reasoner can deduce that Deborah is an instance of the class Person. This restriction allows the property hasOffspring to be used with other classes, such as the class Cat, and have an appropriate value restriction associated with the use of the property on that class. In this case, hasOffspring would have the local range restriction of Cat when associated with the class Cat and would have the local range restriction Person when associated with the class Person. Note that a reasoner can not deduce from an allValuesFrom restriction alone that there actually is at least one value for the property.
• someValuesFrom: The restriction someValuesFrom is stated on a property with respect to a class. A particular class may have a restriction on a property that at least one value for that property is of a certain type. For example, the class SemanticWebPaper may have a someValuesFrom restriction on the hasKeyword property that states that some value for the hasKeyword property should be an instance of the class SemanticWebTopic. This allows for the option of having multiple keywords and as long as one or more is an instance of the class SemanticWebTopic, then the paper would be consistent with the someValuesFrom restriction. Unlike allValuesFrom, someValuesFrom does not restrict all the values of the property to be instances of the same class. If myPaper is an instance of the SemanticWebPaper class, then myPaper is related by the hasKeyword property to at least one instance of the SemanticWebTopic class. Note that a reasoner can not deduce (as it could with allValuesFrom restrictions) that all values of hasKeyword are instances of the SemanticWebTopic class

3.5 OWL Lite Restricted Cardinality

OWL Lite includes a limited form of cardinality restrictions. OWL (and OWL Lite) cardinality restrictions are referred to as local restrictions, since they are stated on properties with respect to a particular class. That is, the restrictions constrain the cardinality of that property on instances of that class. OWL Lite cardinality restrictions are limited because they only allow statements concerning cardinalities of value 0 or 1 (they do not allow arbitrary values for cardinality, as is the case in OWL DL and OWL Full).

• minCardinality: Cardinality is stated on a property with respect to a particular class. If a minCardinality of 1 is stated on a property with respect to a class, then any instance of that class will be related to at least one individual by that property. This restriction is another way of saying that the property is required to have a value for all instances of the class. For example, the class Person would not have any minimum cardinality restrictions stated on a hasOffspring property since not all persons have offspring. The class Parent, however would have a minimum cardinality of 1 on the hasOffspring property. If a reasoner knows that Louise is a Person, then nothing can be deduced about a minimum cardinality for her hasOffspring property. Once it is discovered that Louise is an instance of Parent, then a reasoner can deduce that Louise is related to at least one individual by the hasOffspring property. From this information alone, a reasoner can not deduce any maximum number of offspring for individual instances of the class parent. In OWL Lite the only minimum cardinalities allowed are 0 or 1. A minimum cardinality of zero on a property just states (in the absence of any more specific information) that the property is optional with respect to a class. For example, the property has Offspring may have a minimum cardinality of zero on the class Person (while it is stated to have the more specific information of minimum cardinality of one on the class Parent).
• maxCardinality: Cardinality is stated on a property with respect to a particular class. If a maxCardinality of 1 is stated on a property with respect to a class, then any instance of that class will be related to at most one individual by that property. A maxCardinality 1 restriction is sometimes called a functional or unique property. For example, the property hasRegisteredVotingState on the class UnitedStatesCitizens may have a maximum cardinality of one (because people are only allowed to vote in only one state). From this a reasoner can deduce that individual instances of the class USCitizens may not be related to two or more distinct individuals through the hasRegisteredVotingState property. From a maximum cardinality one restriction alone, a reasoner can not deduce a minimum cardinality of 1. It may be useful to state that certain classes have no values for a particular property. For example, instances of the class UnmarriedPerson should not be related to any individuals by the property hasSpouse. This situation is represented by a maximum cardinality of zero on the hasSpouse property on the class UnmarriedPerson.
• cardinality: Cardinality is provided as a convenience when it is useful to state that a property on a class has both minCardinality 0 and maxCardinality 0 or both minCardinality 1 and maxCardinality 1. For example, the class Person has exactly one value for the property hasBirthMother. From this a reasoner can deduce that no two distinct individual instances of the class Mother may be values for the hasBirthMother property of the same person.

3.6 OWL Lite Header Information

3.7 OWL Lite Class Intersection

• intersectionOf: OWL Lite allows intersections of named classes. For example, the class EmployedPerson can be described as the intersectionOf Person and EmployedThings (which could be defined as things that have a minimum cardinality of 1 on the hasEmployer property). From this a reasoner may deduce that any particular EmployedPerson has at least one employer. OWL Lite requires intersectionOf to take named classes thus it would not be allowed in OWL Lite to describe EmployedPerson as the intersection of Person and the unnamed the class of things that have at least one employer and is simultaneously an instance of the class Person. The ability to use unnamed classes is introduced in OWL DL and OWL Full.

4. Incremental Language Description of OWL DL and OWL FULL

• oneOf: (enumerated classes): Classes can be described by enumeration of the individuals that make up the class. The members of the class are exactly the set of enumerated individuals; no more, no less. For example, the class of daysOfTheWeek can be described by simply enumerating the individuals Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday. From this a reasoner can deduce the maximum cardinality (7) of any property that has daysOfTheWeek as its allValuesFrom restriction.
• hasValue: (property values): A property can be required to have a certain individual as a value (also sometimes referred to as property values). For example, instances of the class of dutchCitizens can be characterized as those people that have theNetherlands as a value of their nationality. (TheNetherlands itself is an instance of the class of Nationalities).
• disjointWith: OWL Full allows the statement that classes are disjoint. For example, Man and Woman can be stated to be disjoint classes. From this disjointWith statement, a reasoner can deduce an inconsistency when an individual is stated to be an instance of both and similarly a reasoner can deduce that if A is an instance of Man, then A is not an instance of Woman.
• unionOf, complementOf, intersectionOf (Boolean combinations): OWL allows arbitrary Boolean combinations of classes(named and unnamed): unionOf, complementOf, and intersectionOf. For example, using unionOf, we can state that a class contains things that are either USCitizens or DutchCitizens. Using complementOf, we could state that children are not SeniorCitizens. (i.e. the class Children is a subclass of the complement of SeniorCitizens). Citizenship of the European Union could be described as the union of the citizenship of all member states. These connectors do not require the use of named classes as is required with the use of intersectionOf in OWL Lite.
• minCardinality, maxCardinality, cardinality (full cardinality): While in OWL Lite, cardinalities are restricted to at least, at most or exactly 1 or 0, full OWL allows cardinality statements for arbitrary non-negative integers. For example the class of DINKs ("Dual Income, No Kids") would restrict the cardinality of the property hasIncome to a minimum cardinality of two (while the property hasChild would have be restricted to cardinality 0).
• complex classes : In many constructs, OWL Lite restricts the syntax to single class names (e.g. in subClassOf or equivalentClass statements). OWL Full extends this restriction to allow arbitrarily complex class descriptions, consisting of enumerated classes, property restrictions, and Boolean combinations. OWL also includes a special "bottom" class with the name Nothing that is the class that has no instances. Also, OWL full allows classes to be used as instances (and OWL DL and OWL Lite do not). For more on this topic, see the "Design for Use" section of the Guide document.

5. Summary