Web Ontology Language (OWL)
Abstract Syntax and Semantics

W3C Working Draft 3 February 2003

This version:

http://www.w3.org/TR/2003/WD-owl-semantics-20030203/

Latest version:

http://www.w3.org/TR/owl-semantics/

Previous version:

http://www.w3.org/TR/2002/WD-owl-semantics-20021108/

Editors:

Peter F. Patel-Schneider, Bell Labs Research, Lucent Technologies
Patrick Hayes, IHMC, University of West Florida
Ian Horrocks, Department of Computer Science, University of Manchester

The normative form of this document is a compound HTML document.

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

---

Abstract

Status of this document

1. Introduction

This document contains several interrelated specifications of the several styles of OWL, the Web Ontology Language being produced by the W3C Web Ontology Working Group (WebOnt). First, Section 2 contains a high-level, abstract syntax for both OWL Lite, a subset of OWL, and OWL DL, a fuller style of using OWL but one that still places some limitations on how OWL ontologies are constructed. Eliminating these limitations results in the full OWL language, called OWL Full, which has the same syntax as RDF. The normative exchange syntax for OWL is RDF/XML [RDF Syntax]; the OWL Reference document [OWL Reference] shows how the RDF syntax is used in OWL. A mapping from the OWL abstract syntax to RDF graphs [RDF Concepts] is, however, provided in Section 4.

This document contains two formal semantics for OWL. One of these semantics, defined in Section 3, is a direct, standard model-theoretic semantics for OWL ontologies written in the abstract syntax. The other, defined in Section 5, is a vocabulary extension of the RDF model-theoretic semantics [RDF MT] that provides semantics for OWL ontologies in the form of RDF graphs. Two versions of this second semantics are provided, one that corresponds more closely to the direct semantics (and is thus a semantics for OWL DL) and one that can be used in cases where classes need to be treated as individuals or other situations that cannot be handled in the abstract syntax (and is thus a semantics for OWL Full). These two versions are actually very close, only differing in how they divide up the domain of discourse.

Appendix A contains a proof that the direct and RDFS-compatible semantics have the same consequences on OWL ontologies that correspond to abstract OWL ontologies that separate OWL individuals, OWL classes, OWL properties, and the RDF, RDFS, and OWL structural vocabulary. For such OWL ontologies the direct model theory is authoritative and the RDFS-compatible model theory is secondary. Appendix A also contains the sketch of a proof that the entailments in the RDFS-compatible semantics for OWL Full include all the entailments in the RDFS-compatible semantics for OWL DL. Finally a few examples of the various concepts defined in the document are presented in Appendix B.

This document is designed to be read by those interested in the technical details of OWL. It is not particularly intended for the casual reader, who should probably first read the OWL Guide [OWL Guide]. Developers of parsers and other syntactic tools for OWL will be particularly interested in Sections 2 and 4. Developers of reasoners and other semantic tools for OWL will be particulary interested in Sections 3 and 5.

1.1. Differences from DAML+OIL

The language described in this document is very close to the DAML+OIL web ontology language [DAML+OIL]. The only substantive changes between OWL and DAML+OIL are

• the removal of qualified number restrictions;
• the ability to directly state that properties can be symmetric;
• a new construct for stating that several individuals are distinct; and
• the absence in the abstract syntax of some abnormal DAML+OIL constructs, particularly restrictions with extra components.

There are also a number of minor differences between OWL and DAML+OIL, including a number of changes to the names of the various constructs, as mentioned in Appendix A of the OWL Reference Description [OWL Reference].

Acknowledgments

The Joint US/EU ad hoc Agent Markup Language Committee developed DAML+OIL, which is the direct precursor to OWL. Many of the ideas in DAM+OIL and thus in OWL are also present in the Ontology Inference Layer (OIL). Many of the other members of the W3C Web Ontology Working Group have had substantial input into this document.

Index of Vocabulary (Informative)

The following table provides pointers to information about each element of the OWL vocabulary, as well as some elements of the RDF and RDFS vocabularies. The first column points to the vocabulary element's major definition in the abstract syntax of Section 2. The second column points to the vocabulary element's major definition in the OWL Lite abstract syntax. The third column points to the vocabularly element's major definition in the direct semantics of Section 3. The fourth column points to the major piece of the translation from the abstract syntax to triples for the vocabulary element Section 4. The fifth column points to the vocabularly element's major definition in the RDFS-compatible semantics of Section 5.

References

Normative References

[RDF Concepts]

Resource Description Framework (RDF): Concepts and Abstract Syntax. Graham Klyne and Jeremy J. Carroll, eds. W3C Working Draft 23 January 2003. Latest version is available at http://www.w3.org/TR/rdf-concepts/.

[RDF MT]

RDF Semantics. Patrick Hayes, ed. W3C Working Draft 23 January 2003. Latest version is available at http://www.w3.org/TR/rdf-mt/.

[RDF Syntax]

RDF/XML Syntax Specification (Revised) Dave Beckett, ed. W3C Working Draft 23 January 2003. Latest version is available at http://www.w3.org/TR/rdf-syntax-grammar/.

[XML]

Extensible Markup Language (XML) 1.0 (Second Edition). Tim Bray, Jean Paoli, C. M. Sperberg-McQueen, and Eve Maler, eds. W3C Recommendation 6 October 2000. Latest version is available at http://www.w3.org/TR/REC-xml.

[XML Schema Datatypes]

XML Schema Part 2: Datatypes.. Paul V. Biron and Ashok Malhotra, eds. W3C Recommendation 02 May 2000. Latest version is available at http://www.w3.org/TR/xmlschema-2/.

Other References

[DAML+OIL]

DAML+OIL (March 2001) Reference Description. Dan Connolly, Frank van Harmelen, Ian Horrocks, Deborah L. McGuinness, Peter F. Patel-Schneider, and Lynn Andrea Stein. W3C Note 18 December 2001. Latest version is available at http://www.w3.org/TR/daml+oil-reference.

[OWL Features]

Feature Synopsis for OWL Lite and OWL. Deborah L. McGuinness and Frank van Harmelen. W3C Working Draft 29 July 2002. Latest version is available at http://www.w3.org/TR/owl-features/.

[OWL Issues]

Web Ontology Issue Status. Michael K. Smith, ed. 18 December 2002.

[OWL Guide]

OWL Web Ontology Language (OWL) Guide Version 1.0. Michael K. Smith, Deborah McGuinness, Raphael Volz, and Chris Welty. W3C Working Draft 4 November 2002. Latest version is available at http://www.w3.org/TR/owl-guide/.

[OWL Reference]

OWL Web Ontology Language 1.0 Reference. Mike Dean, Dan Connolly, Frank van Harmelen, James Hendler, Ian Horrocks, Deborah L. McGuinness, Peter F. Patel-Schneider, and Lynn Andrea Stein. W3C Working Draft 12 November 2002. Latest version is available at http://www.w3.org/TR/owl-ref/.

[RDFMS]

Resource Description Framework (RDF) Model and Syntax Specification. Ora Lassila and Ralph R. Swick, eds. W3C Recommendation 22 February 1999. Latest version is available at http://www.w3.org/TR/REC-rdf-syntax/.

[RDF Schema]

RDF Vocabulary Description Language 1.0: RDF Schema. Dan Brickley and R. V. Guha, eds. W3C Working Draft 23 January 2003. Latest version is available at http://www.w3.org/TR/rdf-schema/.

[RDF Tests]

RDF Test Cases. Jan Grant and Dave Beckett, eds. W3C Working Draft 23 January 2003. Latest version is available at http://www.w3.org/TR/rdf-testcases/.

2. Abstract Syntax

The description of OWL in this Section abstracts from concrete syntax and thus facilitates access to and evaluation of the language. A high-level syntax is used to make the language features easier to see. This particular syntax has a frame-like style, where a collection of information about a class or property is given in one large syntactic construct, instead of being divided into a number of atomic chunks (as in most Description Logics) or even being divided into even more triples (as when writing OWL as RDF graphs [RDF Concepts]). The syntax used here is rather informal, even for an abstract syntax - in general the arguments of a construct should be considered to be unordered wherever the order would not affect the meaning of the construct.

The abstract syntax is specified here by means of a version of Extended BNF, very similar to the EBNF notation used for XML [XML]. Terminals are quoted; non-terminals are not quoted. Alternatives are either separated by vertical bars (|) or are given in different productions. Components that can occur at most once are enclosed in square brackets ([…]); components that can occur any number of times (including zero) are enclosed in braces ({…}). Whitespace is ignored in the productions here.

The meaning of each construct in the abstract syntax is described when it is introduced. The formal meaning of these constructs is given in Section 3 via a model-theoretic semantics.

While it is widely appreciated that all of the features in expressive languages such as OWL are important to some users, it is also understood that such languages may be daunting to some groups who are trying to support a tool suite for the entire language. In order to provide a simpler target for implementation, a smaller language has been defined, called OWL Lite [OWL Features]. This smaller language also attempts to describe a useful language that provides more than RDF Schema [RDF Schema] with the goal of adding functionality that is important in order to support web applications. The abstract syntax is expressed both for this smaller language, called the OWL Lite abstract syntax here, and also for a fuller style of OWL, called the OWL DL abstract syntax here.

The abstract syntax here is less general than the exchange syntax for OWL. In particular, it does not permit the construction of self-referential syntactic constructs. It is also intended for use in cases where classes, properties, and individuals form disjoint collections. These are roughly the limitations required to make reasoning in OWL be decidable, and thus this abstract syntax should be thought of a syntax for OWL DL.

OWL uses some of the facilities of XML Schema. [XML Schema Datatypes]. The following built-in non-list XML Schema datatypes, called the OWL datatypes, can be used in OWL by means of the XML Schema canonical URI reference for the datatype, http://www.w3.org/2001/XMLSchema#name, where name is the local name of the datatype: xsd:string, xsd:boolean, xsd:decimal, xsd:float, xsd:double, xsd:dateTime, xsd:time, xsd:date, xsd:gYearMonth, xsd:gYear, xsd:gMonthDay, xsd:gDay, xsd:gMonth, xsd:hexBinary, xsd:base64Binary, xsd:anyURI, xsd:normalizedString, xsd:token, xsd:language, xsd:NMTOKEN, xsd:Name, xsd:NCName, xsd:integer, xsd:nonPositiveInteger, xsd:negativeInteger, xsd:long, xsd:int, xsd:short, xsd:byte, xsd:nonNegativeInteger, xsd:unsignedLong, xsd:unsignedInt, xsd:unsignedShort, xsd:unsignedByte and xsd:positiveInteger. The other built-in XML Schema datatypes may be used, but with caveats (see below).

The specific considerations with the other built-in XML Schema datatypes are:

xsd:duration,

In the current version of XML Schema no equality function is defined for xsd:duration. This may give surprising results when combined with OWL cardinality restrictions. Later revisions of XML Schema datatypes are expected to provide such a function, in which case the revised duration datatype would be fully appropriate for use with OWL.

xsd:QName,

xsd:ENTITY,

These datatypes require an enclosing XML document context, which may not be available in a specific application scenario for an OWL ontology.

xsd:NOTATION,

This datatype is intended for use as a base type for user defined datatypes.

xsd:ID,

xsd:IDREF,

ID and IDREF are for cross references within an XML document and thus are not useful in OWL.

xsd:IDREFS,

xsd:ENTITIES,

xsd:NMTOKENS,

List valued datatypes are not used in OWL.

2.1. Ontologies

An OWL ontology in the abstract syntax is a sequence of axioms and facts, plus inclusion references to other ontologies, which are considered to be included in the ontology. Ontologies can also have annotations that can be used to record authorship and other information associated with an ontology. OWL ontologies are web documents, and can be referenced by means of a URI.

ontology ::= 'Ontology(' { directive } ')'

directive ::= 'Annotation(' URIreference URIreference ')'
            | 'Annotation(' URIreference dataLiteral ')'
	    | 'Imports(' URI ')'
	    | axiom
	    | fact

Ontologies incorporate information about classes, properties, and individuals, each of which can have an identifier which is a URI reference.

datatypeID                 ::= URIreference
classID                    ::= URIreference
individualID               ::= URIreference
datavaluedPropertyID       ::= URIreference
individualvaluedPropertyID ::= URIreference

If a URI reference is a datatype, i.e., the URI reference points to one of the useful XML Schema datatypes described above, then that URI reference cannot be used as the identifier of a class. However, a URI reference can be the identifier of a class or datatype as well as the identifier of a property as well as the identifier of an individual in this abstract syntax, although the ontology cannot then be translated into an OWL DL RDF graph. Individual identifiers are used to refer to resources, and data literals are used to refer to data values.

In OWL, as in RDF, a datatype denotes the set of data values that is the value space for the datatype. Classes denote sets of individuals. Properties relate individuals to other information, and are divided into two disjoint groups, data-valued properties and individual-valued properties. Data-valued properties relate individuals to data values; individual-valued properties relate individuals to other individuals.

There are two built-in classes in OWL, they both use URI references in the OWL URI, http://www.w3.org/2002/07/owl#, for which the namespace name owl is used here. The class with identifier owl:Thing is the class of all individuals, and is part of OWL Lite. The class with identifier owl:Nothing is the empty class.

Many OWL constructs use annotations, which, just like annotation directives, are used to record information associated with some portion of the construct.

annotation ::= 'annotation(' URIreference URIreference ')'
             | 'annotation(' URIreference dataLiteral ')'

2.2. Facts

There are two kinds of facts in the OWL abstract syntax.

The first kind of fact states information about a particular individual, in the form of classes that the individual belongs to plus properties and values of that individual. An individual can be given an individualID that will denote that individual, and can be used to refer to that individual. However, an individual need not be given an individualID. Such individuals are anonymous (blank in RDF terms) and cannot be directly referred to elsewhere. The syntax here is set up to mirror RDF/XML syntax without the use of rdf:nodeID.

fact ::= individual 
individual ::= 'Individual(' [ individualID ] { annotation }
                             { 'type(' type ')' } { propertyValue } ')'
propertyValue ::= 'value(' individualvaluedPropertyID  individualID ')'
                | 'value(' individualvaluedPropertyID  individual ')'
                | 'value(' datavaluedPropertyID  dataLiteral ')'

Facts are the same in the OWL Lite and OWL DL abstract syntaxes, except for what can be a type. In OWL Lite, types can be classIDs or OWL Lite restrictions

type ::= classID
       | restriction

In the OWL DL abstract syntax types can be general descriptions, which include classIDs and OWL Lite restrictions as well as other constructs

type ::= description

Data literals in the abstract syntax consist of a datatype and the lexical representation of a data value in that datatype (a typed literal) or just a string (an untyped literal). In the abstract syntax typed literals must be valid, i.e., xsd:integer1.5 is not a valid OWL data literal.

dataLiteral ::= typedLiteral | untypedLiteral
typedLiteral ::= datatypeID lexicalForm
untypedLiteral ::= lexicalForm
lexicalForm ::= UniCode string enclosed in quotes

The second kind of facts is used to make individual identifiers be the same or pairwise distinct.

fact ::= 'SameIndividual(' individualID {individualID} ')'
       | 'DifferentIndividuals(' individualID {individualID} ')'

2.3. Axioms

The biggest differences between the OWL Lite and OWL DL abstract syntaxes show up in the axioms, which are used to provide information about classes and properties. As it is the smaller language, OWL Lite axioms are given first, in Section 2.3.1. The OWL DL axioms are given in Section 2.3.2. The OWL DL axioms include the OWL Lite axioms as special cases.

Axioms are used to associate class and property identifiers with either partial or complete specifications of their characteristics, and to give other logical information about classes and properties. Axioms used to be called definitions, but they are not all definitions in the common sense of the term, as has been made evident in several discussions in the WG, and thus a more-neutral name has been chosen.

The syntax used here is meant to look somewhat like the syntax used in some frame systems. Each class axiom in OWL Lite contains a collection of more-general classes and a collection of local property restrictions in the form of restriction constructs. The restriction construct gives the local range of a property, how many values are permitted, and/or a collection of required values. The class is made either equivalent to or a subset of the intersection of these more-general classes and restrictions. In the OWL DL abstract syntax a class axiom contains a collection of descriptions, which can be more-general classes, restrictions, sets of individuals, and boolean combinations of descriptions. Classes can also be specified by enumeration or be made equivalent or disjoint.

Properties can be equivalent to or sub-properties of others; can be made functional, inverse functional, symmetric, or transitive; and can be given global domains and ranges. However, most information about properties is more naturally expressed in restrictions, which allow local range and cardinality information to be specified.

There is no requirement in the abstract syntax that there be an axiom for each class used in an ontology. In fact, there can be any number of axioms for each class, including none. Properties used in an abstract syntax ontology have to be categorized as either data-valued or individual-valued, so they need an axiom for this purpose at least. There is no requirement that there be at most one axiom for a class or property used in an ontology. Each axiom for a particular class (or property) identifier contributes to the meaning of the class (or property).

2.3.1. OWL Lite Axioms

2.3.1.1. OWL Lite Class Axioms

In OWL Lite class axioms are used to state that a class is exactly equivalent to, for the modality complete, or a subclass of, for the modality partial, the conjunction of a collection of superclasses and OWL Lite Restrictions.

axiom ::= 'Class(' classID modality { annotation } { super } ')'
modality ::= 'complete' | 'partial'
super ::= classID | restriction

In OWL Lite it is possible to state that two or more classes are equivalent.

axiom ::= 'EquivalentClasses(' classID { classID } ')'

2.3.1.2. OWL Lite Restrictions

Restrictions are used in OWL Lite class axioms to provide local constraints on properties in the class. Each allValuesFrom part of a restriction makes the constraint that all values of the property for individuals in the class must belong to the specified class or datatype. Each someValuesFrom part makes the constraint that there must be at least one value for the property that belongs to the specified class or datatype. The cardinality part says how many distinct values there are for the property for each individual in the class. In OWL Lite the only cardinalities allowed are 0 and 1.

There is a side condition in OWL Lite that properties that are transitive or that have transitive sub-properties may not have cardinality conditions expressed on them in restrictions.

restriction ::= 'restriction(' datavaluedPropertyID { 'allValuesFrom(' datatypeID ')'}
                               { 'someValuesFrom(' datatypeID ')' } { cardinality } ')'
              | 'restriction(' individualvaluedPropertyID { 'allValuesFrom(' classID ')'}
                               { 'someValuesFrom(' classID ')' } { cardinality } ')'
cardinality ::= 'minCardinality(0)' | 'minCardinality(1)' |
              | 'maxCardinality(0)' | 'maxCardinality(1)' |
              | 'cardinality(0)'    | 'cardinality(1)'

2.3.1.3. OWL Lite Property Axioms

Properties are also specified using a frame-like syntax. Properties are divided into data-valued properties, which relate individuals to data values, like integers, and individual-valued properties, which relate individuals to other individuals. Properties can be given super-properties, allowing the construction of a property hierarchy. It does not make sense to have an individual property be a super-property of a data property, or vice versa.

Properties can also be given domains and ranges. A domain for a property specifies which individuals are potential subjects of statements that have the property as predicate, just as in RDFS. In OWL Lite the domains of properties are classes. Properties can have multiple domains, in which case only individuals that belong to all of the domains are potential subjects. A range for a property specifies which individuals or data values can be objects of statements that have the property as predicate. Again, properties can have multiple ranges, in which case only individuals or data values that belong to all of the ranges are potential objects. In OWL Lite ranges for individual-valued properties are classes; ranges for data-valued properties are datatypes.

Data-valued properties can be specified as (partial) functional, i.e., given an individual, there can be at most one relationship to a data value for that individual in the property. Individual-valued properties can be specified to be the inverse of another property. Individual-valued properties can also be specified to be symmetric as well as partial functional, partial inverse-functional, or transitive.

Individual-valued properties that are transitive, or that have transitive sub-properties, may not have cardinality conditions expressed on them, either in restrictions or by being functional, or inverse functional. This is needed to maintain the decidability of the language.

axiom ::= 'DatatypeProperty(' datavaluedPropertyID { annotation } { 'super(' datavaluedPropertyID ')' }
                              {domain(classID')'} {range(datatypeID')' }
                              [Functional] ')'

axiom ::= 'ObjectProperty(' individualvaluedPropertyID { annotation } { 'super(' individualvaluedPropertyID ')'}
              { 'domain(' classID ')'} { 'range(' classID ')' } 
              ['inverseOf(' individualvaluedPropertyID' )'] [ Symmetric ] 
              [ 'Functional' | 'InverseFunctional' | 'Functional' 'InverseFunctional' | 'Transitive' ] ')'

The following axioms make several properties be equivalent, or make one property be a sub-property of another.

axiom ::= 'EquivalentProperties(' datavaluedPropertyID  { datavaluedPropertyID } ')'
        | 'SubPropertyOf(' datavaluedPropertyID  datavaluedPropertyID ')'
	| 'EquivalentProperties(' individualvaluedPropertyID  { individualvaluedPropertyID } ')'
	| 'SubPropertyOf(' individualvaluedPropertyID  individualvaluedPropertyID ')'

2.3.2. OWL DL Axioms

2.3.2.1. OWL DL Class Axioms

The OWL DL abstract syntax has more-general versions of the OWL Lite class axioms where superclasses, more-general restrictions, and boolean combinations of these are allowed. Together, these constructs are called descriptions.

axiom ::= 'Class(' classID modality { annotation } { description } ')'
modality ::= 'complete' | 'partial'

In the OWL DL abstract syntax it is also possible to make a class exactly consist of a certain set of individuals, as follows.

axiom ::= 'EnumeratedClass(' classID { annotation } { individualID } ')'

Finally, in the OWL DL abstract syntax it is possible to require that a collection of descriptions be pairwise disjoint, or have the same instances, or that one description is a subclass of another. Note that the last two of these axioms generalize, except for lack of annotataion, the first kind of class axiom just above.

axiom ::= 'DisjointClasses(' description { description } ')'
        | 'EquivalentClasses(' description { description } ')'
	| 'SubClassOf(' description description ')'

2.3.2.2. OWL DL Descriptions

Descriptions in the OWL DL abstract syntax include class identifiers and the restriction constructor. Descriptions can also be boolean combinations of other descriptions, and sets of individuals.

description ::= classID
              | restriction
              | 'unionOf(' { description } ')'
              | 'intersectionOf(' { description } ')'
              | 'complementOf(' description ')'
              | 'oneOf(' { individualID } ')'

2.3.2.3. OWL DL Restrictions

Restrictions in the OWL DL abstract syntax generalize OWL Lite restrictions by allowing descriptions where classes are allowed in OWL Lite and allowing sets of data values as well as datatypes. The combination of datatypes and sets of data values is called a data range. In the OWL DL abstract syntax, values can also be given for properties in classes. As well, cardinalities are not restricted to only 0 and 1.

restriction ::= 'restriction(' datavaluedPropertyID { 'allValuesFrom(' dataRange ')'}
                               { 'someValuesFrom(' dataRange ')'} { 'value(' dataLiteral ')' }
                               { cardinality } ')'
	      | 'restriction(' individualvaluedPropertyID { 'allValuesFrom(' description ')'}
                               { 'someValuesFrom(' description ')'} { 'value(' individualID ')' }
                               { cardinality } ')'
cardinality ::= 'minCardinality(' non-negative-integer ')'
              | 'maxCardinality(' non-negative-integer ')'
              | 'cardinality(' non-negative-integer ')'

A dataRange, used as the range of a data-valued property and in other places in the OWL DL abstract syntax, is either a datatype or a set of data values.

dataRange ::= datatypeID
            | 'oneOf(' { dataLiteral } ')'

As in OWL Lite, there is a side condition that properties that are transitive, or that have transitive sub-properties, may not have cardinality conditions expressed on them in restrictions.

2.3.2.4. OWL DL Property Axioms

Property axioms in the OWL DL abstract syntax generalize OWL Lite property axioms by allowing descriptions in place of classes and data ranges in place of datatypes in domains and ranges.

axiom ::= 'DatatypeProperty(' datavaluedPropertyID { annotation } { 'super(' datavaluedPropertyID ')'}
                              { 'domain(' description ')' } { 'range(' dataRange ')'}
                              [ 'Functional' ] ')'
        | 'ObjectProperty(' individualvaluedPropertyID { annotation } { 'super(' individualvaluedPropertyID ')'}
                { 'domain(' description ')' } { 'range(' description ')' } 
                [ 'inverseOf(' individualvaluedPropertyID ')' ] [ 'Symmetric' ] 
                [ 'Functional' | 'InverseFunctional' | 'Functional' 'InverseFunctional' | 'Transitive' ] ')'

As in OWL Lite, the following axioms make several properties be equivalent, or make one property be a sub-property of another.

axiom ::= 'EquivalentProperties(' datavaluedPropertyID  { datavaluedPropertyID } ')'
        | 'SubPropertyOf(' datavaluedPropertyID  datavaluedPropertyID ')'
	| 'EquivalentProperties(' individualvaluedPropertyID  { individualvaluedPropertyID } ')'
	| 'SubPropertyOf(' individualvaluedPropertyID  individualvaluedPropertyID ')'

3. Direct Model-Theoretic Semantics

This model-theoretic semantics for OWL goes directly from ontologies in the OWL DL abstract syntax, which includes the OWL Lite abstract syntax, to a standard model theory. It is simpler than the semantics in Section 5 for RDF graphs that is a vocabulary extension of the RDFS model theory.

3.1. Vocabularies and Interpretations

The semantics here starts with the notion of a vocabulary, which is a set of URI references. When considering an OWL ontology, the vocabulary must include all the URI references in that ontology, as well as ontologies that are imported by the ontology, but can include other URI references as well.

Definition: An OWL vocabulary V is a set of URI references, including http://www.w3.org/2002/07/owl#Thing (which will generally be written as owl:Thing) and http://www.w3.org/2002/07/owl#Nothing (which will generally be written as owl:Nothing). Each OWL vocabulary also includes the canonical URI references for the OWL datatypes. In the semantics below, LV is the (non-disjoint) union of the value spaces of the OWL datatypes and Unicode strings.

Definition: An Abstract OWL interpretation with vocabulary V is a four-tuple of the form: I = <R, EC, ER, S> where

• R is a non-empty set of resources, disjoint from LV
• EC : V → P(R) ∪ P(LV)
• ER : V → P(R×R) ∪ P(R×LV)
• S : V → R

EC and ER provide meaning for URI references that are used as OWL classes and OWL properties, respectively. S provides meaning for URI references that are used to denote OWL individuals. S is extended to untyped literals by mapping them onto themselves, i.e., S(l) = l for l an untyped literal. S is extended to typed data literals by utilizing the XML Schema mapping for the datatype, i.e., S(d l) is the value corresponding to l for the XML Schema dataytpe d. (P is the power set operator.)

Abstract OWL interpretations have the following conditions having to do with OWL datatypes:

1. If d is the canonical URI reference for an OWL datatype then EC(d) is the XML Schema value space for that datatype.
2. If c is not the URI reference for any OWL datatype then EC(c) ⊆ R.

3.2. Interpreting Embedded Constructs

EC is extended to the syntactic constructs of descriptions, dataRanges, individuals, and propertyValues as in the EC Extension Table.

3.3. Interpreting Axioms and Facts

An Abstract OWL interpretation, I, satisfies OWL axioms and facts as given in Axiom Interpretation Table. In the table, optional parts of axioms and facts are given in square brackets ([…]) and have corresponding optional conditions, also given in square brackets.

3.4. Interpreting Ontologies

From Section 2, an OWL ontology in the abstract syntax is a sequence of axioms, facts, imports, and annotations. The effect of an imports construct is to import the contents of another OWL ontology into the current ontology. The imported ontology is the one that can be found by accessing the document at the URI that is the argument of the imports construct.

Definition: The imports closure of an OWL ontology is then the result of adding the contents of imported ontologies into the current ontology. If these contents contain further imports constructs, the process is repeated as necessary. A particular ontology is never imported more than once in this process, so loops can be handled. Annotation directives have no effect on the semantics of OWL ontologies in the abstract syntax.

Definitions: An Abstract OWL interpretation, I, satisfies an OWL ontology, O, iff I satisfies each axiom and fact in the imports closure of O. An Abstract OWL ontology is consistent if there is some interpretation that satisfies it. An Abstract OWL ontology entails an OWL axiom or fact if each interpretation that satisfies the ontology also satisfies the axiom or fact. An Abstract OWL ontology entails another Abstract OWL ontology if each interpretation that satisfies the first ontology also satisfies the second ontology. Note that there is no need to create the imports closure of an ontology - any method that correctly determines the entailment relation is allowed.

4. Mapping to RDF Graphs

The exchange syntax for OWL is RDF/XML [RDF Syntax], as specified in the OWL Reference Description [OWL Reference]. Further, the meaning of an OWL ontology in RDF/XML is determined only from the RDF graph [RDF Concepts] that results from the RDF parsing of the RDF/XML document. Thus one way of translating an OWL ontology in abstract syntax form into the exchange syntax is by giving a transformation of each directive into a collection of triples. As all OWL Lite constructs are special cases of constructs in the full abstract syntax, transformations are only provided for the OWL DL versions.

The syntax for triples used here is the one used in the RDF Model Theory [RDF MT]. In this variant, qualified names are allowed. As detailed in the RDF Model Theory, to turn this syntax into the standard one just expand the qualified names into URI references in the standard RDF manner by concatenating the namespace name with the local name. The only namespace prefixes used in the transformation are rdf, rdfs, xsd, and owl, which correspond to the namespaces http://www.w3.org/1999/02/22-rdf-syntax-ns#, http://www.w3.org/2000/01/rdf-schema#, http://www.w3.org/2001/XMLSchema#, and http://www.w3.org/2002/07/owl#, respectively.

4.1. Translation to RDF Graphs

The Transformation Table gives transformation rules that transform the abstract syntax to the OWL exchange syntax. In a few cases, notably for the DifferentIndividuals construct, there are different transformation rules. In such cases either rule can be chosen, resulting in a non-deterministic translation. In a few other cases, notably for class and property axioms, there are triples that may or may not be generated. These triples are indicated by flagging them with [opt]. These non-determinisms allow the generation of more RDF Graphs.

The left column of the table gives a piece of syntax (S), the center column gives its transformation (T(S)), and the right column gives an identifier for the main node of the transformation (M(T(S))), but only for syntactic constructs that can occur as pieces of directives. Repeating components are listed using ellipses, as in description₁; … description_n, this form allows easy specification of the transformation for all values of n greater than or equal to zero. Optional portions of the abstract syntax (enclosed in square brackets) are optional portions of the transformation (signified by square brackets).

Some transformations in the table are for directives. Other transformations are for parts of directives. The last transformation is for sequences, which are not part of the abstract syntax per se. This last transformation is used to make some of the other transformations more compact and easier to read.

For many directives these transformation rules call for the transformation of components of the directive using other transformation rules. When the transformation of a component is used as the subject or object of a triple, the transformation of the construct is part of the production (but only once per production) and the main node of that transformation should be used for that node of the triple.

Bnode identifiers here must be taken as local to each transformation, i.e., different identifiers should be used for each invocation of a transformation rule. Also, some of the transformations require a URI for the current ontology. It is assumed that ontologies that are subject to this sort of transformation will be placed into a web-accessible document; the URI of this document is given as U.

4.2. Definition of OWL DL and OWL Lite Ontologies in RDF Graph Form

Definition: An RDF graph is an OWL DL ontology in RDF graph form if it is equal (see below for a slight expansion) to a result of the transformation to triples above of the imports closure of an OWL DL ontology in abstract syntax form and, moreover,

Definition: An RDF graph is an OWL Lite ontology in RDF graph form if it is equal (with the same relaxation as for OWL DL) to a result of the transformation to triples above of the imports closure of an OWL Lite ontology in abstract syntax form that meets the requirements given just above.

This transformation is not injective, as several OWL abstract ontologies that do not use the above reserved vocabulary can map into equal RDF graphs. However, the only cases where this can happen is with constructs that have the same meaning, such as several DisjointClasses axioms having the same effect as one larger one. It would be possible to define a canonical inverse transformation, if desired.

The above definition of OWL DL and OWL Lite ontologies in RDF graph form is couched from the perspective of the abstract syntax, as this is the perspective from which it can be easily stated. The following, much longer description of OWL DL ontologies in RDF graph form is couched from the perspective of RDF graphs. This description is strictly informative. The normative definition of what constitutes an OWL DL ontology in RDF graph form is given above.

Let G be an RDF graph. A node x1 in G is a non-empty list in G with elements e1,…,en if there is a set of triples in G of the form

	x1 rdf:type rdf:List .
	x1 rdf:first e1 .
	x1 rdf:rest x2 .
	...
	xn rdf:type rdf:List .
	xn rdf:first en .
	xn rdf:rest rdf:nil .

where each xi is a distinct blank node that appears as the object of exactly one triple in G and x1 does not appear as the object of an rdf:rest triple. The definition triples of x1 are the triples above plus the definition triples of e1,...,en.

A node x in G is a description in G if x is a blank node and there is a set of triples of one of the entries in the Description Triples table, where

1. r is an object property or a datatype property in G.
2. if r is an object property in G then d is a description or a class; if r is a datatype property in G then d is a data range or a datatype.
3. if r is an object property in G then i is an individual and URI reference; if r is a datatype property in G then i is a typed or untyped literal.
4. n is a typed literal whose data value is a non-negative integer.
5. ds is rdf:nil or a non-empty list whose elements are descriptions or classes.
6. dc is a description or a class.
7. is is rdf:nil or a non-empty list whose elements are individuals that are also URI references.

The definition triples of the description are the triples above plus any x rdf:type owl:Class . or x rdf:type rdfs:Class . triples plus the definition triples of any description, data range, or list in the triples above.

A node x in G is a data range in G if x is a blank node and there is a triple of the form x owl:oneOf rdf:nil . or x owl:oneOf is . where is is a non-empty list whose elements are typed or untyped literals. The definition triples of the data range are the triples above plus any triples of the form x rdf:type rdfs:Class . plus the definition triples of the list.

A node x in G is a datatype property if x is a URI reference and there is a triple of the form x rdf:type owl:DatatypeProperty . but no triple of any of the following forms

	x rdf:type owl:SymmetricProperty .
	x rdf:type owl:InverseFunctionalProperty .
	x rdf:type owl:TransitiveProperty .

The assertions about x in G are the triples in G of the following forms, where y is a datatype property in G, d is a description or class in G, and r is a data range or datatype in G

	x rdf:type owl:DatatypeProperty .
	x rdf:type rdf:Property .
	x rdfs:subPropertyOf y .
	x rdfs:domain d .
	x rdfs:range r .
	x rdf:type owl:FunctionalProperty .
	x owl:samePropertyAs y .

plus the definition triples of any description or data range in these triples.

A node x in G is an object property if x is a URI reference and there is a triple of the form x rdf:type owl:ObjectProperty . The assertions about x in G are the triples in G of the following forms, where y is an object property in G, d is a description or class in G

	x rdf:type owl:ObjectProperty .
	x rdf:type rdf:Property .
	x rdfs:subPropertyOf y .
	x rdfs:domain d .
	x rdfs:range d .
	x owl:inverseOf y .
	x rdf:type owl:SymmetricProperty .
	x rdf:type owl:FunctionalProperty .
	x rdf:type owl:InverseFunctionalProperty .
	x rdf:type owl:TransitiveProperty .
	x owl:samePropertyAs y .

plus the definition triples of any description in these triples.

A node x in G is a transitive object property if x is an object property and there is a triple of the form x rdf:type owl:TransitiveProperty .

A node x in G is a complex object property if x is an object property and there is a triple of any of the following forms in G

	x rdf:type owl:FunctionalProperty .
	x rdf:type owl:InverseFunctionalProperty .
	x owl:inverseOf y .
	x owl:samePropertyAs y .
	y rdfs:subClassOf x .

where y is a complex object property in G or if there are triples of each of the forms

	z owl:onProperty x .
	z c y .

where c is one of owl:minCardinality, owl:maxCardinality, or owl:cardinality.

A node x in G is a datatype if x is a URI reference and there is a triple of the form x rdf:type rdfs:Datatype . The assertions about x in G are the triples in G of the following forms, where d is a top-level description or class in G x rdf:type rdfs:Datatype .

A node x in G is a class if x is owl:Thing or owl:Nothing or x is a URI reference and there is a triple of the form x rdf:type owl:Class . The assertions about x in G are the triples in G of the following forms, where d is a top-level description or class in G and ds is rdf:nil or a non-empty list whose elements are descriptions or classes and is is rdf:nil or a non-empty list whose elements are individuals, plus the definition triples of any non-empty lists in these triples

	x rdf:type owl:Class .
	x rdf:type rdfs:Class .
	x rdfs:subClassOf d .
	x owl:sameClassAs d .
	x owl:disjointFrom d.
	x owl:complementOf d.
	x owl:intersectionOf ds.
	x owl:unionOf ds.
	x owl:oneOf is .

A node x in G is a top-level description if x is a description that is not in the definition triples of any other description in G nor an element of a list in G. The assertions about x in G are the triples in G of the following forms, where d is a top-level description or class in G

	x rdf:type owl:Class .
	x rdfs:subClassOf d .
	x owl:sameClassAs d .
	x owl:disjointWith d .

plus the definition triples of x.

A node x in G is an individual if there is a triple of the form x rdf:type c . where c is a description or class. The assertions about x in G are the triples of G of the following forms, where c is a description or class, rd is a datatype property, v is a typed or untyped literal, ro is an object property, and i is an individual.

	x rdf:type c .
	x rd v .
	x ro i .
	x owl:sameIndividualAs i .
	x owl:differentFrom i .

plus the definition triples of any description in these triples.

A node x in G is an all-different node if there is a triple of the form x rdf:type owl:allDifferent . and there is exactly one other triple in G whose subject is x and this triple is of one of the following forms, where l is a non-empty list whose elements are individuals

	x owl:distinctMembers owl:nil .
	x owl:distinctMembers l .

The assertions about x are the above triples, plus the definition triples of l, if present.

A node x in G is an ontology if x is a URI reference and there is a triple of the form x rdf:type owl:Ontology . The assertions about x are the triples of G of the following form

	x rdf:type owl:Ontology .
	x owl:imports y .

where y is a URI reference that is not a datatype property, an object property, a class, or an individual.

An RDF graph is an OWL DL graph if:

1. The datatype properties of G, the object properties of G, the classes of G, the datatypes of G, the individuals of G, and the ontologies of G are pairwise disjoint and disjoint from the RDF, RDFS, and OWL vocabularies (except owl:Thing, owl:Nothing, rdfs:Literal, and rdf:XMLLiteral).
2. The definition triples of any description or datarange are disjoint from the definition triples of other description or data range except for any description or data range that is a node of some triple in the definition triples of the description or data range. (Therefore the definition triples of any description or datarange form a tree.)
3. The triples of the graph can be disjointly partitioned such that each partition is either
   1. the assertions about a datatype property, object property, datatype, class, top-level description, individual, all-different node, or ontology;
   2. (annotation) triples whose subject is a datatype property, an object property, a datatype, a class, or an individual and whose predicate is not a datatype property, an object property, a class, an individual, nor any URI reference from the RDF, RDFS, or OWL namespaces that is given special meaning by RDF, RDFS, or OWL; or
   3. (ontology annotation) triples whose subject is an ontology and whose predicate is not a datatype property, an object property, a datatype, a class, an individual, or any URI reference from the RDF, RDFS, or OWL namespaces that is given special meaning by RDF, RDFS, or OWL.
4. The complex object properties and the transitive object properties of G are disjoint.

A quick incomplete gloss of the above is that

1. In an OWL DL ontology in RDF graph form a resource cannot be more than one of a class, a datatype, an object property, a datatype property, or an individual. OWL DL requires that inverse functional properties, symmetric properties, and transitive properties be object properties, so they cannot be datatype properties.
2. In an OWL DL ontology in RDF graph form an object property that participates in a cardinality restriction cannot be specified as a transitive property nor can it have a transitively-specified property as a descendant.
3. In an OWL DL ontology in RDF graph form all descriptions must be well-formed, with no missing or extra components, and must form tree-like structures.

5. RDFS-Compatible Model-Theoretic Semantics

This model-theoretic semantics for OWL is an extension of the RDFS semantics as defined in the RDF model theory [RDF MT], and defines the OWL semantic extension of RDF.

5.1. The OWL and RDF universes

All of the OWL vocabulary is defined on the 'OWL universe', which is a division of part of the RDF universe into three parts, namely the class extensions of owl:Thing, owl:Class, and owl:Property. The class extension of owl:Thing comprises the individuals of the OWL universe. The class extension of owl:Class comprises the classes of the OWL universe. The class extension of owl:Property comprises the properties of the OWL universe.

There are two different styles of using OWL. In the more free-wheeling style, called OWL Full, the three parts of the OWL universe are identified with their RDFS counterparts, namely the class extensions of rdfs:Resource, rdfs:Class, and rdf:Property. In OWL Full, as in RDFS, elements of the OWL universe can be both an individual and a class, or, in fact, even an individual, a class, and a property. In the more restrictive style, called OWL DL here, the three parts are different from their RDFS counterparts and, moreover, pairwise disjoint.

The OWL DL style gives up some expressive power in return for decidability of entailment. Both styles of OWL provide entailments that are missing in a naive translation of the DAML+OIL model-theoretic semantics into the RDFS semantics.

The chief differences in practice between the two styles lie in the care that is required to ensure that URI references are actually in the appropriate part of the OWL universe. In OWL Full, no care is needed. In OWL DL, localizing information must be provided for many of the URI references used. These localizing assumptions are all trivially true in OWL Full, and can also be ignored when one uses the OWL abstract syntax. But when writing OWL DL in triples, however, close attention must be paid to which elements of the vocabulary belong to which part of the OWL universe.

5.1.1. Qualified Names and URI References

Throughout this section qualified names are used as shorthand for URI references. The namespace identifiers used in such names, namely rdf, rdfs, xsd, and owl, should be used as if they are given their usual definitions. Throughout this section VRDFS is the RDF and RDFS built-in vocabulary, i.e., rdf:type, rdf:Property, rdfs:Class, rdfs:subClassOf, …, minus rdfs:Literal; and VOWL is the OWL built-in vocabulary, i.e., owl:Class, owl:onProperty, …, minus owl:Thing and owl:Nothing.

5.2. OWL Interpretations

The semantics of OWL DL and OWL Full are very similar. The common portion of their semantics is thus given first, and the differences left until later.

From the RDF model theory [RDF MT], for V a set of URI references containing the RDF and RDFS vocabulary and a set D of datatypes, a D-interpretation of V is a tuple I = < R_I, P_I, EXT_I, S_I, L_I >, where LV ⊆ R_I. Here R_I is the domain of discourse or universe, i.e., a set that contains the denotations of URI references. P_I is a subset of R_I, the properties of I. EXT_I is used to give meaning to properties, and is a mapping from P_I to P(R_I × R_I). S_I is a mapping from V to R_I that takes a URI reference to its denotation. L_I is a mapping from typed literals to LV.

CEXT_I is then defined as CEXT_I(c) = { x∈R_I | <x,c>∈EXT_I(S_I(rdf:type)) }. D-interpretations must meet several conditions, as detailed in the RDFS model theory. For example, I(rdfs:subClassOf) must be a transitive relation and the class extension of all datatypes must be in LV.

Definition: Let D be the RDF datatyping scheme generated by the OWL datatypes. An OWL interpretation, I = < R_I, P_I, EXT_I, S_I, L_I >, of a vocabulary V, where V includes VRDFS, rdfs:Literal, VOWL, owl:Thing, and owl:Nothing, and the canonical URI references for the OWL datatypes, as its datatypes, is a D-interpretation of V that satisfies all the constraints in this section.

Elements of the OWL vocabulary that correspond to Description Logic constructors are given a different treatment from elements of the OWL vocabulary that correspond to (other) semantic relationships. The former have only-if semantic conditions and comprehension principles; the latter have if-and-only-if semantic conditions. The only-if semantic conditions for the former are needed to prevent semantic paradoxes and other problems with the semantics. The comprehension principles for the former and the if-and-only-if semantic conditions for the latter are needed so that useful entailments are valid.

If-and-only-if conditions for RDFS domains and ranges

Note that IOC is the set of OWL classes, IDC is the set of OWL datatypes, and IOP is the set of OWL properties. These sets, and a few others, are defined in the next table.

Conditions concerning the parts of the OWL universe and syntactic categories

The above table is the definition of several semantic sets, namely IOC, IOT, IOR, IOP, IOOP, IODP, IDC, IAD, and IL. That is, these are simply shorthand names for the appropriate class extension.

Characteristics of OWL classes, datatypes, and properties

Characteristics of OWL vocabulary related to equivalence