OWL Web Ontology Language
Semantics and Abstract Syntax
Section 5. RDF-Compatible Model-Theoretic Semantics

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

Please refer to the errata for this document, which may include some normative corrections.

See also translations.


Contents


5. RDF-Compatible Model-Theoretic Semantics (Normative)

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

NOTE: There is a strong correspondence between the semantics for OWL DL defined in this section and the Direct Model-Theoretic Semantics defined in Section 3 (see Theorem 1 and Theorem 2 in Section 5.4). If, however, any conflict should ever arise between these two forms, then the Direct Model-Theoretic Semantics takes precedence.

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 OWL individuals, classes, and properties. 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 union of the class extensions of owl:ObjectProperty, owl:DatatypeProperty, owl:AnnotationProperty, and owl:OntologyProperty 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 RDF counterparts, namely the class extensions of rdfs:Resource, rdfs:Class, and rdf:Property. In OWL Full, as in RDF, 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 RDF counterparts and, moreover, pairwise disjoint. The more-restrictive 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 RDF semantics.

A major difference in practice between the two styles lies 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, which corresponds closely to OWL DL. 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.

Throughout this section the OWL vocabulary will be the disallowed vocabulary from OWL plus the built-in classes, the built-in annotation properties, and the built-in ontology properties.

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 semantics [RDF MTSemantics], for V a set of URI references and literals containing the RDF and RDFS vocabulary and D a datatype map, a D-interpretation of V is a tuple I = < RI, PI, EXTI, SI, LI, LVI >. RI is the domain of discourse or universe, i.e., a nonempty set that contains the denotations of URI references and literals in V. PI is a subset of RI, the properties of I. EXTI is used to give meaning to properties, and is a mapping from PI to P(RI × RI). SI is a mapping from URI references in V to their denotations in RI. LI is a mapping from typed literals in V to their denotations in RI. LVI is a subset of RI that contains at least the set of Unicode strings, the set of pairs of Unicode strings and language tags, and the value spaces for each datatype in D. The set of classes CI is defined as CI = { x ∈RI | <x,SI(rdfs:Class)> ∈ EXTI(SI(rdf:type)) }, and the mapping CEXTI from CI to P(RI) is defined as CEXTI(c) = { x∈RI | <x,c>∈EXTI(SI(rdf:type)) }. D-interpretations must meet several other conditions, as detailed in the RDF semantics. For example, EXTI(SI(rdfs:subClassOf)) must be a transitive relation and the class extension of all datatypes must be subsets of LVI.

Definition: Let D be a datatype map that includes datatypes for rdf:XMLLiteral, xsd:integer and xsd:string. An OWL interpretation, I = < RI, PI, EXTI, SI, LI, LVI >, of a vocabulary V, where V includes the RDF and RDFS vocabularies and the OWL vocabulary, is a D-interpretation of V that satisfies all the constraints in this section.

Note: Elements of the OWL vocabulary that construct descriptions in the abstract syntax 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.

Conditions concerning the parts of the OWL universe and syntactic categories

If E is then Note
SI(E)∈ CEXTI(SI(E))= and
owl:Class CIIOCIOC⊆CI This defines IOC as the set of OWL classes.
rdfs:Datatype IDCIDC⊆CI This defines IDC as the set of OWL datatypes.
owl:RestrictionCIIORIOR⊆IOC This defines IOR as the set of OWL restrictions.
owl:Thing IOCIOT IOT⊆RI and IOT ≠ ∅ This defines IOT as the set of OWL individuals.
owl:Nothing IOC{}
rdfs:Literal IDCLVILVI⊆RI
owl:ObjectProperty CIIOOPIOOP⊆PI This defines IOOP as the set of OWL individual-valued properties.
owl:DatatypeProperty CIIODPIODP⊆PI This defines IODP as the set of OWL datatype properties.
owl:AnnotationProperty CIIOAPIOAP⊆PI This defines IOAP as the set of OWL annotation properties.
owl:OntologyProperty CIIOXPIOXP⊆PI This defines IOXP as the set of OWL ontology properties.
owl:Ontology CIIX This defines IX as the set of OWL ontologies.
owl:AllDifferent CIIAD
rdf:List ILIL⊆RI This defines IL as the set of OWL lists.
rdf:nilIL
"l"^^d CEXTI(SI(d)) SI("l"^^d) ∈ LVI Typed literals are well-behaved in OWL.

OWL built-in syntactic classes and properties

I(owl:FunctionalProperty), I(owl:InverseFunctionalProperty), I(owl:SymmetricProperty), I(owl:TransitiveProperty), I(owl:DeprecatedClass), and I(owl:DeprecatedProperty) are in CI.

I(owl:equivalentClass), I(owl:disjointWith), I(owl:equivalentProperty), I(owl:inverseOf), I(owl:sameAs), I(owl:differentFrom), I(owl:complementOf), I(owl:unionOf), I(owl:intersectionOf), I(owl:oneOf), I(owl:allValuesFrom), I(owl:onProperty), I(owl:someValuesFrom), I(owl:hasValue), I(owl:minCardinality), I(owl:maxCardinality), I(owl:cardinality), and I(owl:distinctMembers) are all in PI.

I(owl:versionInfo), I(rdfs:label), I(rdfs:comment), I(rdfs:seeAlso), and I(rdfs:isDefinedBy) are all in IOAP. I(owl:imports), I(owl:priorVersion), I(owl:backwardCompatibleWith), and I(owl:incompatibleWith), are all in IOXP.

Characteristics of OWL classes, datatypes, and properties

If E is then if e∈CEXTI(SI(E)) then Note
owl:ClassCEXTI(e)⊆IOT Instances of OWL classes are OWL individuals.
rdfs:DatatypeCEXTI(e)⊆LVI
owl:DataRange CEXTI(e)⊆LVI OWL dataranges are special kinds of datatypes.
owl:ObjectPropertyEXTI (e)⊆IOTIOT(e)⊆IOT×IOT Values for individual-valued properties are OWL individuals.
owl:DatatypePropertyEXTI (e)⊆IOTLV(e)⊆IOT×LVI Values for datatype properties are literal values.
owl:AnnotationPropertyEXTI (e)⊆IOT(IOT∪LV(e)⊆IOT×(IOT∪LVI) Values for annotation properties are less unconstrained.
owl:OntologyPropertyEXTI (e)⊆IXIX(e)⊆IX×IX Ontology properties relate ontologies to other ontologies.
If E is then c∈CEXTI(SI(E)) iff c∈IOOP∪IODP and Note
owl:FunctionalProperty <x,y1>, <x,y2> ∈ EXTI(c) implies y1 = y2 Both individual-valued and datatype properties can be functional properties.
If E is then c∈CEXTI(SI(E)) iff c∈IOOP and Note
owl:InverseFunctionalProperty <x1,y>, <x2,y>∈EXTI(c) implies x1 = x2 Only individual-valued properties can be inverse functional properties.
owl:SymmetricProperty <x,y> ∈ EXTI(c) implies <y, x>∈EXTI(c) Only individual-valued properties can be symmetric properties.
owl:TransitiveProperty <x,y>, <y,z>∈EXTI(c) implies <x,z>∈EXTI(c) Only individual-valued properties can be transitive properties.

If-and-only-if conditions for rdfs:subClassOf, rdfs:subPropertyOf, rdfs:domain, and rdfs:range

If E is then for<x,y>∈EXTI(SI(E)) iff
rdfs:subClassOf x,y∈IOC CEXTI(x) ⊆ CEXTI(y)
rdfs:subPropertyOf x,y∈IOOP EXTI(x) ⊆ EXTI(y)
rdfs:subPropertyOf x,y∈IODP EXTI(x) ⊆ EXTI(y)
rdfs:domain x∈IOOP∪IODP,y∈IOC <z,w>∈EXTI(x) implies z∈CEXTI(y)
rdfs:range x∈IOOP∪IODP,y∈IOC∪IDC <w,z>∈EXTI(x) implies z∈CEXTI(y)

Characteristics of OWL vocabulary related to equivalence

If E is then <x,y>∈EXTI(SI(E)) iff
owl:equivalentClass x,y∈IOC and CEXTI(x)=CEXTI(y)
owl:disjointWith x,y∈IOC and CEXTI(x)∩CEXTI(y)={}
owl:equivalentProperty x,y∈IOOP∪IODP and EXTI(x) = EXTI(y)
owl:inverseOf x,y∈IOOP and <u,v>∈EXTI(x) iff <v,u>∈EXTI(y)
owl:sameAs x = y
owl:differentFrom x ≠ y

Conditions on OWL vocabulary related to boolean combinations and sets

We will say that l1 is a sequence of y1,…,yn over C iff n=0 and l1=SI(rdf:nil) or n>0 and l1∈IL and ∃ l2, …, ln ∈ IL such that
<l1,y1>∈EXTI(SI(rdf:first)), y1∈C, <l1,l2>∈EXTI(SI(rdf:rest)), …,
<ln,yn>∈EXTI(SI(rdf:first)), yn∈C, and <ln,SI(rdf:nil)>∈EXTI(SI(rdf:rest)).

If E is then <x,y>∈EXTI(SI(E)) iff
owl:complementOf x,y∈ IOC and CEXTI(x)=IOT-CEXTI(y)
owl:unionOf x∈IOC and y is a sequence of y1,…yn over IOC and CEXTI(x) = CEXTI(y1)∪…∪CEXTI(yn)
owl:intersectionOf x∈IOC and y is a sequence of y1,…yn over IOC and CEXTI(x) = CEXTI(y1)∩…∩CEXTI(yn)
owl:oneOf x∈CI and y is a sequence of y1,…yn over IOT or over LVI and CEXTI(x) = {y1,..., yn}

Further conditions on owl:oneOf

If E isand then if <x,l>∈EXTI(SI(E)) then
owl:oneOfl is a sequence of y1,…yn over LVI x∈IDC
owl:oneOfl is a sequence of y1,…yn over IOT x∈IOC

Conditions on OWL restrictions

If then x∈IOR, y∈IOC∪IDC, p∈IOOP∪IODP, and CEXTI(x) =
<x,y>∈EXTI(SI(owl:allValuesFrom))) ∧
<x,p>∈EXTI(SI(owl:onProperty)))
{u∈IOT | <u,v>∈EXTI(p) implies v∈CEXTI(y) }
<x,y>∈EXTI(SI(owl:someValuesFrom))) ∧
<x,p>∈EXTI(SI(owl:onProperty)))
{u∈IOT | ∃ <u,v>∈EXTI(p) such that v∈CEXTI(y) }
If then x∈IOR, y∈IOT∪LVI, p∈IOOP∪IODP, and CEXTI(x) =
<x,y>∈EXTI(SI(owl:hasValue))) ∧
<x,p>∈EXTI(SI(owl:onProperty)))
{u∈IOT | <u, y>∈EXTI(p) }
If then x∈IOR, y∈LVI, y is a non-negative integer, p∈IOOP∪IODP, and CEXTI(x) =
<x,y>∈EXTI(SI(owl:minCardinality))) ∧
<x,p>∈EXTI(SI(owl:onProperty)))
{u∈IOT | card({v ∈ IOT ∪ LV : <u,v>∈EXTI(p)}) ≥ y }
<x,y>∈EXTI(SI(owl:maxCardinality))) ∧
<x,p>∈EXTI(SI(owl:onProperty)))
{u∈IOT | card({v ∈ IOT ∪ LV : <u,v>∈EXTI(p)}) ≤ y }
<x,y>∈EXTI(SI(owl:cardinality))) ∧
<x,p>∈EXTI(SI(owl:onProperty)))
{u∈IOT | card({v ∈ IOT ∪ LV : <u,v>∈EXTI(p)}) = y }

Comprehension conditions (principles)

The first two comprehension conditions require the existence of the finite sequences that are used in some OWL constructs. The third comprehension condition requires the existence of instances of owl:AllDifferent. The remaining comprehension conditions require the existence of the appropriate OWL descriptions and data ranges.

If there exists then there exists l1,…,ln ∈ IL with
x1, …, xn ∈ IOC <l1,x1> ∈ EXTI(SI(rdf:first)), <l1,l2> ∈ EXTI(SI(rdf:rest)), …
<ln,xn> ∈ EXTI(SI(rdf:first)), <ln,SI(rdf:nil)> ∈ EXTI(SI(rdf:rest))
x1, …, xn ∈ IOT∪LVI <l1,x1> ∈ EXTI(SI(rdf:first)), <l1,l2> ∈ EXTI(SI(rdf:rest)), …
<ln,xn> ∈ EXTI(SI(rdf:first)), <ln,SI(rdf:nil)> ∈ EXTI(SI(rdf:rest))
If there exists then there exists y with
l, a sequence of x1,…,xn over IOT
with xi≠xj for 1≤i<j≤n
y∈IAD, <y,l>∈EXTI(SI(owl:distinctMembers))
If there exists then there exists y with
l, a sequence of x1,…,xn over IOC y∈IOC, <y,l> ∈ EXTI(SI(owl:unionOf))
l, a sequence of x1,…,xn over IOC y∈IOC, <y,l> ∈ EXTI(SI(owl:intersectionOf))
l, a sequence of x1,…,xn over IOT y∈IOC, <y,l> ∈ EXTI(SI(owl:oneOf))
l, a sequence of x1,…,xn over LVI y∈IDC, <y,l> ∈ EXTI(SI(owl:oneOf))
If there exists then there exists y ∈ IOC with
x ∈ IOC <y,x> ∈ EXTI(SI(owl:complementOf))
If there exists then there exists y ∈ IOR with
x ∈ IOOP∪IODP ∧ w ∈ IOC ∪ IDC <y,x> ∈ EXTI(SI(owl:onProperty)) ∧
<y,w> ∈ EXTI(SI(owl:allValuesFrom))
x ∈ IOOP∪IODP ∧ w ∈ IOC ∪ IDC <y,x> ∈ EXTI(SI(owl:onProperty)) ∧
<y,w> ∈ EXTI(SI(owl:someValuesFrom))
x ∈ IOOP∪IODP ∧ w ∈ IOT ∪ LVI <y,x> ∈ EXTI(SI(owl:onProperty)) ∧
<y,w> ∈ EXTI(SI(owl:hasValue))
x ∈ IOOP∪IODP ∧ w ∈ LVI ∧ w is a non-negative integer <y,x> ∈ EXTI(SI(owl:onProperty)) ∧
<y,w> ∈ EXTI(SI(owl:minCardinality))
x ∈ IOOP∪IODP ∧ w ∈ LVI ∧ w is a non-negative integer <y,x> ∈ EXTI(SI(owl:onProperty)) ∧
<y,w> ∈ EXTI(SI(owl:maxCardinality))
x ∈ IOOP∪IODP ∧ w ∈ LVI ∧ w is a non-negative integer <y,x> ∈ EXTI(SI(owl:onProperty)) ∧
<y,w> ∈ EXTI(SI(owl:cardinality))

5.3. OWL Full

OWL Full augments the common conditions with conditions that force the parts of the OWL universe to be the same as their analogues in RDF. These new conditions strongly interact with the common conditions. For example, because in OWL Full IOT is the entire RDF domain of discourse, the second comprehension condition for lists generates lists of any kind, including lists of lists.

Definition: An OWL Full interpretation of a vocabulary V is an OWL interpretation that satisfies the following conditions (recall that an OWL interpretation is with respect to a datatype map).

IOT = RI
IOOP = PI
IOC = CI

Definition: Let K be a collection of RDF graphs. K is imports closed iff for every triple in any element of K of the form x owl:imports u . then K contains a graph that is the result of the RDF processing of the RDF/XML document, if any, accessible at u into an RDF graph. The imports closure of a collection of RDF graphs is the smallest import-closed collection of RDF graphs containing the graphs.

Definitions: Let K and Q be collections of RDF graphs and D be a datatype map. Then K OWL Full entails Q with respect to D iff every OWL Full interpretation with respect to D (of any vocabulary V that includes the RDF and RDFS vocabularies and the OWL vocabulary) that satisfies all the RDF graphs in K also satisfies all the RDF graphs in Q. K is OWL Full consistent iff there is some OWL Full interpretation that satisfies all the RDF graphs in K.

5.4. OWL DL

OWL DL augments the conditions of Section 5.2 with a separation of the domain of discourse into several disjoint parts. This separation has two consequences. First, the OWL portion of the domain of discourse becomes standard first-order, in that predicates (classes and properties) and individuals are disjoint. Second, the OWL portion of a OWL DL interpretation can be viewed as a Description Logic interpretation for a particular expressive Description Logic.

Definition: A OWL DL interpretation of a vocabulary V is an OWL interpretation that satisfies the following conditions (recall that an OWL interpretation is with respect to a datatype map).

LVI, IOT, IOC, IDC, IOOP, IODP, IOAP, IOXP, IL, and IX are all pairwise disjoint.
For v in the disallowed vocabulary (Section 4.2), SI(v) ∈ RI - (LVI∪IOT∪IOC∪IDC∪IOOP∪IODP∪IOAP∪IOXP∪IL∪IX).

Entailment in OWL DL is defined similarly to entailment in OWL Full.

Definitions: Let K and Q be collections of RDF graphs and D be a datatype map. Then K OWL DL entails Q with respect to D iff every OWL DL interpretation with respect to D (of any vocabulary V that includes the RDF and RDFS vocabularies and the OWL vocabulary) that satisfies all the RDF graphs in K also satisfies all the RDF graphs in Q. K is OWL DL consistent iff there is some OWL DL interpretation that satisfies all the RDF graphs in K.

There is a strong correspondence between the Direct Model-Theoretic Semantics and the OWL DL semantics (but in case of any conflict, the Direct Model-Theoretic Semantics takes precedence—see the Note at the beginning of Section 5). Basically, an ontology that could be written in the abstract syntax OWL DL entails another exactly when it entails the other in the direct semantics. There are a number of complications to this basic story having to do with splitting up the vocabulary so that, for example, concepts, properties, and individuals do not interfere, and arranging that imports works the same.

For the correspondence to be valid there has to be some connection between an ontology in the abstract syntax with a particular name and the document available on the Web at that URI. This connection is outside the semantics here, and so must be specially arranged. This connection is also only an idealization of the Web, as it ignores temporal and transport aspects of the Web.

Definition: Let T be the mapping from the abstract syntax to RDF graphs from Section 4.1. Let O be a collection of OWL DL ontologies and axioms and facts in abstract syntax form. O is said to be imports closed iff for any URI, u, in an imports directive in any ontology in O the RDF parsing of the document accessible on the Web at u results in T(K), where K is the ontology in O with name u.

Theorem 1: Let O and O' be collections of OWL DL ontologies and axioms and facts in abstract syntax form that are imports closed, such that their union has a separated vocabulary (Section 4.2). Given a datatype map D that maps xsd:string and xsd:integer to the appropriate XML Schema datatypes and that includes the RDF mapping for rdf:XMLLiteral, then O entails O' with respect to D if and only if the translation (Section 4.1) of O OWL DL entails the translation of O' with respect to D.
The proof is contained in Appendix A.1.

A simple corollary of this is that, given a datatype map D that maps xsd:string and xsd:integer to the appropriate XML Schema datatypes and that includes the RDF mapping for rdf:XMLLiteral, O is consistent with respect to D if and only if the translation of O is consistent with respect to D.

There is also a correspondence between OWL DL entailment and OWL Full entailment.

Theorem 2: Let O and O' be collections of OWL DL ontologies and axioms and facts in abstract syntax form that are imports closed, such that their union has a separated vocabulary (Section 4.2). Given a datatype map D that maps xsd:string and xsd:integer to the appropriate XML Schema datatypes and that includes the RDF mapping for rdf:XMLLiteral, then the translation of O OWL Full entails the translation of O' with respect to D if the translation of O OWL DL entails the translation of O' with respect to D. A sketch of the proof is contained in Appendix A.2.