©2002 Lucent Technologies, Inc., Patrick Hayes, Ian Horrocks, and Created as part of W3C activities, so the W3C Consortium agreement holds with respect to this document.
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.
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.
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.
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
If E is | then for | <x,y>∈EXT_{I}(S_{I}(E)) iff |
---|---|---|
rdfs:domain | x∈IOP,y∈IOC | <z,w>∈EXT_{I}(x) → z∈CEXT_{I}(y) |
rdfs:range | x∈IOP,y∈IOC∪IDC | <w,z>∈EXT_{I}(x) → z∈CEXT_{I}(y) |
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
If E is | then | ||
---|---|---|---|
S_{I}(E)∈ | CEXT_{I}(S_{I}(E))= | and | |
owl:Class | IOC | IOC⊆CEXT_{I}(S_{I}(rdfs:Class)) | |
owl:Thing | IOC | IOT | IOT⊆R_{I} |
owl:Nothing | IOC | {} | |
owl:Restriction | IOR | IOR⊆IOC | |
owl:Property | IOP | IOP⊆CEXT_{I}(S_{I}(rdf:Property)) | |
owl:ObjectProperty | IOOP | IOOP⊆IOP | |
owl:DatatypeProperty | IODP | IODP⊆IOP | |
rdfs:Datatype | IDC | IDC⊆CEXT_{I}(S_{I}(rdfs:Class)) | |
rdfs:Literal | IDC | LV | LV⊆R_{I} |
owl:Ontology | |||
owl:AllDifferent | IAD | ||
rdf:List | IL | IL⊆R_{I} | |
rdf:nil | IL |
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
If E is | then if e∈CEXT_{I}(S_{I}(E)) then |
---|---|
owl:Class | CEXT_{I}(e)⊆IOT |
rdfs:Datatype | CEXT_{I}(e)⊆LV |
owl:ObjectProperty | EXT_{I}(e)⊆IOT×IOT |
owl:DatatypeProperty | EXT_{I}(e)⊆IOT×LV |
If E is | then c∈CEXT_{I}(S_{I}(E)) iff c∈IOP and |
owl:SymmetricProperty | <x,y> ∈ EXT_{I}(c) → <y, x>∈EXT_{I}(c) |
owl:FunctionalProperty | <x,y_{1}>, <x,y_{2}> ∈ EXT_{I}(c) → y_{1} = y_{2} |
owl:InverseFunctionalProperty | <x_{1},y>, <x_{2},y>∈EXT_{I}(c) → x_{1} = x_{2} |
owl:TransitiveProperty | <x,y>, <y,z>∈EXT_{I}(c) → <x,z>∈EXT_{I}(c) |
Characteristics of OWL vocabulary related to equivalence
If E is | then <x,y>∈EXT_{I}(S_{I}(E)) iff |
---|---|
owl:sameClassAs | x,y∈IOC and CEXT_{I}(x)=CEXT_{I}(y) |
owl:disjointWith | x,y∈IOC and CEXT_{I}(x)∩CEXT_{I}(y)={} |
owl:samePropertyAs | x,y∈IOP and EXT_{I}(x) = EXT_{I}(y) |
owl:inverseOf | x,y∈IOOP and <u,v>∈EXT_{I}(x) iff <v,u>∈EXT_{I}(y) |
owl:sameIndividualAs | x = y |
owl:sameAs | x = y |
owl:differentFrom | x ≠ y |
Conditions on OWL vocabulary related to boolean combinations and sets
We will say that l_{1} is a sequence of
y_{1},…,y_{n} over C iff
n=0 and l_{1}=S_{I}(rdf:nil)
or n>0 and l_{1}∈IL and
∃ l_{2}, …, l_{n} ∈ IL such that
<l_{1},y_{1}>∈EXT_{I}(S_{I}(rdf:first)), y_{1}∈C,
<l_{1},l_{2}>∈EXT_{I}(S_{I}(rdf:rest)), …,
<l_{n},y_{n}>∈EXT_{I}(S_{I}(rdf:first)), y_{n}∈C, and
<l_{n},S_{I}(rdf:nil)>∈EXT_{I}(S_{I}(rdf:rest)).
If E is | then if <x,y>∈EXT_{I}(S_{I}(E)) then |
---|---|
owl:complementOf | x,y∈ IOC and CEXT_{I}(x)=IOT-CEXT_{I}(y) |
owl:unionOf | x∈IOC and y is a sequence of y_{1},…y_{n} over IOC and CEXT_{I}(x) = CEXT_{I}(y_{1})∪…∪CEXT_{I}(y_{n}) |
owl:intersectionOf | x∈IOC and y is a sequence of y_{1},…y_{n} over IOC and CEXT_{I}(x) = CEXT_{I}(y_{1})∩…∩CEXT_{I}(y_{n}) |
owl:oneOf | x∈CEXT_{I}(S_{I}(rdfs:Class)) and y is a sequence of y_{1},…y_{n} over IOT or over LV and CEXT_{I}(x) = {y_{1},..., y_{n}} |
Further conditions on owl:oneOf
If E is | and | then if <x,l>∈EXT_{I}(S_{I}(E)) then |
---|---|---|
owl:oneOf | l is a sequence of y_{1},…y_{n} over LV | x∈IDC and CEXT_{I}(x) = {y_{1},..., y_{n}} |
owl:oneOf | l is a sequence of y_{1},…y_{n} over IOT | x∈IOC and CEXT_{I}(x) = {y_{1},..., y_{n}} |
Conditions on OWL restrictions
If | then x∈IOR, y∈IOC∪IDC, p∈IOP, and CEXT_{I}(x) = |
---|---|
<x,y>∈EXT_{I}(S_{I}(owl:allValuesFrom))) ∧ <x,p>∈EXT_{I}(S_{I}(owl:onProperty))) |
{u∈IOT | <u,v>∈EXT_{I}(p) implies v∈CEXT_{I}(y) } |
<x,y>∈EXT_{I}(S_{I}(owl:someValuesFrom))) ∧ <x,p>∈EXT_{I}(S_{I}(owl:onProperty))) |
{u∈IOT | ∃ <u,v>∈EXT_{I}(p) such that v∈CEXT_{I}(y) } |
<x,y>∈EXT_{I}(S_{I}(owl:hasValue))) ∧ <x,p>∈EXT_{I}(S_{I}(owl:onProperty))) |
{u∈IOT | <u, y>∈EXT_{I}(p) } |
If | then x∈IOR, y∈LV, y is a non-negative integer, p∈IOP, and CEXT_{I}(x) = |
<x,y>∈EXT_{I}(S_{I}(owl:minCardinality))) ∧ <x,p>∈EXT_{I}(S_{I}(owl:onProperty))) |
{u∈IOT | card({v : <u,v>∈EXT_{I}(p)}) ≥ y } |
<x,y>∈EXT_{I}(S_{I}(owl:maxCardinality))) ∧ <x,p>∈EXT_{I}(S_{I}(owl:onProperty))) |
{u∈IOT | card({v : <u,v>∈EXT_{I}(p)}) ≤ y } |
<x,y>∈EXT_{I}(S_{I}(owl:cardinality))) ∧ <x,p>∈EXT_{I}(S_{I}(owl:onProperty))) |
{u∈IOT | card({v : <u,v>∈EXT_{I}(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 l_{1},…,l_{n} ∈ IL with |
---|---|
x_{1}, …, x_{n} ∈ IOC | <l_{1},x_{1}> ∈ EXT_{I}(S_{I}(rdf:first)),
<l_{1},l_{2}> ∈ EXT_{I}(S_{I}(rdf:rest)), … <l_{n},x_{n}> ∈ EXT_{I}(S_{I}(rdf:first)), <l_{n},S_{I}(rdf:nil)> ∈ EXT_{I}(S_{I}(rdf:rest)) |
x_{1}, …, x_{n} ∈ IOT∪LV | <l_{1},x_{1}> ∈ EXT_{I}(S_{I}(rdf:first)),
<l_{1},l_{2}> ∈ EXT_{I}(S_{I}(rdf:rest)), … <l_{n},x_{n}> ∈ EXT_{I}(S_{I}(rdf:first)), <l_{n},S_{I}(rdf:nil)> ∈ EXT_{I}(S_{I}(rdf:rest)) |
If there exists | then there exists y with |
l, a sequence of x_{1},…,x_{n} over IOT with x_{i}≠x_{j} for 1≤i<j≤n |
y∈IAD, <y,l>∈EXT_{I}(S_{I}(owl:distinctMembers)) |
If there exists | then there exists y with |
l, a sequence of x_{1},…,x_{n} over IOC | y∈IOC, <y,l> ∈ EXT_{I}(S_{I}(owl:unionOf)) |
l, a sequence of x_{1},…,x_{n} over IOC | y∈IOC, <y,l> ∈ EXT_{I}(S_{I}(owl:intersectionOf)) |
l, a sequence of x_{1},…,x_{n} over IOT | y∈IOC, <y,l> ∈ EXT_{I}(S_{I}(owl:oneOf)) |
l, a sequence of x_{1},…,x_{n} over LV | y∈IDC, <y,l> ∈ EXT_{I}(S_{I}(owl:oneOf)) |
If there exists | then there exists y ∈ IOC with |
x ∈ IOC | <y,x> ∈ EXT_{I}(S_{I}(owl:complementOf)) |
If there exists | then there exists y ∈ IOR with |
x ∈ IOP ∧ w ∈ IOC ∪ IDC | <y,x> ∈ EXT_{I}(S_{I}(owl:onProperty)) ∧ <y,w> ∈ EXT_{I}(S_{I}(owl:allValuesFrom)) |
x ∈ IOP ∧ w ∈ IOC ∪ IDC | <y,x> ∈ EXT_{I}(S_{I}(owl:onProperty)) ∧ <y,w> ∈ EXT_{I}(S_{I}(owl:someValuesFrom)) |
x ∈ IOP ∧ w ∈ IOT ∪ LV | <y,x> ∈ EXT_{I}(S_{I}(owl:onProperty)) ∧ <y,w> ∈ EXT_{I}(S_{I}(owl:hasValue)) |
x ∈ IOP ∧ w ∈ LV ∧ w is a non-negative integer | <y,x> ∈ EXT_{I}(S_{I}(owl:onProperty)) ∧ <y,w> ∈ EXT_{I}(S_{I}(owl:minCardinality)) |
x ∈ IOP ∧ w ∈ LV ∧ w is a non-negative integer | <y,x> ∈ EXT_{I}(S_{I}(owl:onProperty)) ∧ <y,w> ∈ EXT_{I}(S_{I}(owl:maxCardinality)) |
x ∈ IOP ∧ w ∈ LV ∧ w is a non-negative integer | <y,x> ∈ EXT_{I}(S_{I}(owl:onProperty)) ∧ <y,w> ∈ EXT_{I}(S_{I}(owl:cardinality)) |
OWL DL augments the above conditions 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 as above that satisfies the following conditions.
The domain of discourse is divided up into several pieces.
LV, IOT, IOC, IDC, IOP, and IL are all pairwise disjoint. |
There is a disjoint partition of IOP into IOOP and IODP. |
For v ∈ VRDFS∪VOWL - {rdf:nil}, S_{I}(v) ∈ R_{I} - (LV∪IOT∪IOC∪IDC∪IOP∪IL). |
Now entailment in OWL DL can be defined.
Definition: Let K be an RDF graph. The imports closure of K is the smallest superset of K such that if the imports closure of K contains a triple of the form x owl:imports y . where x and y are any URIs then the imports closure of K contains the triples resulting from the RDF parsing of the document, if any, accessible at y into triples.
Definitions: Let K and Q be RDF graphs. Then K OWL DL entails Q whenever every OWL DL interpretation (of any vocabulary V that includes VRDFS, rdfs:Literal, VOWL, owl:Thing, and owl:Nothing) that satisfies the RDF graph specified by imports closure of K also satisfies the RDF graph specified by imports closure of Q. K is OWL DL consistent if there is some OWL DL interpretation that satisfies the imports closure of K.
One way to automatically obtain typing information for the vocabulary is to use translations into RDF graphs of certain kinds of OWL ontologies in the abstract syntax, as such translations contain information on what a URI reference denotes. This is made more formal below.
Definition: A separated OWL vocabulary, V', is a set of URI references with a disjoint partition into VI, VC, VD, VOP, and VDP, where owl:Thing and owl:Nothing are in VC, rdfs:Literal is in VD, and all the canonical URI references for the OWL datatypes are in VD. Further V' is disjoint from VRDFS∪VOWL. A separated OWL vocabulary will generally be written as V' = VI + VC + VD + VOP + VDP. If the partition is not important, it will not be written out.
Definition: An OWL abstract ontology with separated names over a separated OWL vocabulary V' = VI + VC + VD + VOP + VDP, is a set of OWL axioms and facts in the abstract syntax without annotations as in Section 2 where <individualID>s are taken from VI, <classID>s are taken from VC, <datatypeID>s are taken from VD, <individualvaluedPropertyID>s are taken from VOP, and <datavaluedPropertyID>s are taken from VDP.
Theorem 1: Let T be the mapping from OWL ontologies in the abstract syntax to RDF graphs. Let V' = VI + VC + VD + VOP + VDP be a separated OWL vocabulary. Let K and Q be OWL abstract syntax ontologies with separated names over V' and let V = V' ∪ VRDFS ∪ VOWL. Then it is the case that K entails Q if and only if T(K) OWL DL entails T(Q). The proof is contained in Appendix A.1.
A simple corollary of this is that K is consistent if and only if T(K) is consistent.
OWL Full augments the common conditions with conditions that force the parts of the OWL universe to be the same as their analogues in RDFS. These new conditions interact with the common conditions. For example, because in OWL Full IOT is the entire RDF domain of discourse, the second comprension condition for lists generates lists of any kind, including lists of lists.
Definition: A OWL Full interpretation of a vocabulary V is an OWL interpretation as above that satisfies the following conditions.
IOT = R_{I} |
IOC = CEXT_{I}(S_{I}(rdfs:Class)) |
IOP = CEXT_{I}(S_{I}(rdf:Property)) |
OWL Full entailment and OWL Full consistency are defined in same manner as OWL DL entailment and OWL DL consistency.
Theorem 2: Let K,C be RDF graphs such that each of K, C, and K∪C is the translation of some OWL ontology in the abstract syntax with separated vocabulary. Then K OWL Full entails C if K OWL DL entails C. An initial sketch of the proof is contained in Appendix A.2.