Copyright ©2002 W3C ^{©} ( MIT, INRIA, Keio). All Rights Reserved. W3C liability, trademark , document use and software licensing rules apply.
This model-theoretic semantics for OWL is upward-compatible with the RDFS semantics as defined in the RDF model theory [RDF MT].
All of the OWL vocabulary is defined on the 'OWL universe', which is a collection of RDFS classes that are intended to circumscribe the domain of application of the OWL vocabulary: owl:Thing, owl:Class and owl:Property. The RDFS class extension of owl:Thing comprises the individuals of the OWL universe. The RDFS class extension of owl:Class comprises the classes of the OWL universe. The RDFS 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 here, these three classes are identified with their RDFS counterparts. In OWL/Full, as in RDFS, resources 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, these three classes 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. Further, OWL/DL can be processed by efficient DL reasoners. 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 OWL universe. In OWL/Full, no care is needed, as the OWL universe is the same as the RDFS universe. In OWL/DL, typing 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 n-triples close attention must be paid to which parts of the vocabulary can be 'legally' used to refer to things in 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.
Throughout this section D will be a datatyping scheme, i.e., a set of URI references, the datatypes of D, that have class extensions that are subsets of LV and mappings from literal strings to elements of their class extension. A typed literal string is a pair, d,s, consisting of a datatype and a literal string. For d,s a typed literal string, D(d,s) is the element of LV that is the literal value for string s in datatype d.
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, an RDFS interpretation over V is a triple I = < R_{I}, EXT_{I}, S_{I} >. Here R_{I} is the domain of discourse or universe, i.e., a set that contains the denotations of URI references. EXT_{I} is used to give meaning to properties, and is a mapping from R_{I} to sets of pairs over R_{I} × (R_{I}∪LV). Finally, S_{I} is a mapping from V to R_{I} that takes a URI reference to its denotation. CEXT_{I} is then defined as CEXT_{I}(c) = { x∈R_{I} | <x,c>∈EXT_{I}(S_{I}(rdf:type)) }. RDFS interpretations must meet several conditions, as detailed in the RDFS model theory. For example, S_{I}(rdfs:subClassOf) must be a transitive relation.
An OWL interpretation, I = < R_{I}, EXT_{I}, S_{I} >, over a vocabulary V, where V includes VRDFS, rdfs:Literal, VOWL, owl:Thing, and owl:Nothing, is an RDFS interpretation over V that satisfies the following conditions:
Relationships between OWL classes
If E is | then CEXT_{I}(S_{I}(E))= | with |
---|---|---|
owl:Thing | IOT | IOT⊆R_{I} |
owl:Nothing | {} | |
rdfs:Literal | LV | |
owl:Class | IOC | IOC⊆CEXT_{I}(S_{I}(rdfs:Class)) |
owl:Restriction | IOR | IOR⊆IOC |
owl:Datatype | IDC | IDC⊆CEXT_{I}(S_{I}(rdfs:Class)) |
owl:Property | IOP | IOP⊆CEXT_{I}(S_{I}(rdf:Property)) |
owl:ObjectProperty | IOOP | IOOP⊆IOP |
owl:DataTypeProperty | IODP | IODP⊆IOP |
rdf:List | IL | IL⊆R_{I} |
Membership in OWL classes
If E is | then S_{I}(E)∈ |
---|---|
owl:Thing | IOC |
owl:Nothing | IOC |
rdfs:Literal | IDC |
a datatype of D | IDC |
rdf:nil | IL |
Characteristics of members of OWL classes
If E is | then if e∈CEXT_{I}(S_{I}(E)) then |
---|---|
owl:Class | CEXT_{I}(e)⊆IOT |
owl:Datatype | CEXT_{I}(e)⊆LV |
owl:ObjectProperty | EXT_{I}(e)⊆IOT×IOT |
owl:DatatypeProperty | EXT_{I}(e)⊆IOT×LV |
The next constraints are IFF, which may be harder to deal with in OWL/DL, as they extend the various categories of properties to all of owl:Property. However, in OWL/DL ontologies you can neither state that an owl:DatatypeProperty is inverse functional nor ask whether it is, so there should be not adverse consequences.
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}> and <x,y_{2}> ∈ EXT_{I}(c) → y_{1} = y_{2} |
owl:InverseFunctionalProperty | <x_{1},y>∈EXT_{I}(c) ∧ <x_{2},y>∈EXT_{I}(c) → x_{1} = x_{2} |
owl:TransitiveProperty | <x,y>∈EXT_{I}(c) ∧ <y,z>∈EXT_{I}(c) → <x,z>∈EXT_{I}(c) |
RDFS domains and ranges are strengthened to if-and-only-if over the OWL universe.
If E is | then for | <x,y>∈CEXT_{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) |
Some OWL properties have iff characterizations
If E is | then <x,y>∈EXT_{I}(S_{I}(E)) iff |
---|---|
owl:sameClassAs | x,y∈IOC ∧ CEXT_{I}(x)=CEXT_{I}(y) |
owl:disjointWith | x,y∈IOC ∧ CEXT_{I}(x)∩CEXT_{I}(y)={} |
owl:samePropertyAs | x,y∈IOP ∧ EXT_{I}(x) = EXT_{I}(y) |
owl:inverseOf | x,y∈IOOP ∧ <u,v>∈EXT_{I}(x) iff <v,u>∈EXT_{I}(y) |
owl:sameIndividualAs | x = y |
owl:sameAs | x = y |
owl:differentFrom | x ≠ y |
Some OWL properties have only-if characterizations
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}∈CEXT_{I}(C),
<l_{1},l_{2}>∈EXT_{I}(S_{I}(rdf:rest)), …,
<l_{n},y_{n}>∈EXT_{I}(S_{I}(rdf:first)), y_{n}∈CEXT_{I}(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) |
If E is | then if <x,l>∈EXT_{I}(S_{I}(E)) then |
---|---|
owl:unionOf | x∈IOC and l 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 l 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}(rdfs:Class) and l is a sequence of y_{1},…y_{n} over R_{I}∪LV and CEXT_{I}(x) = {y_{1},..., y_{n}} |
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}} |
If | then x∈IOR, y∈IOC, 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) → 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) ∧ 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 } |
R_{I} contains elements corresponding to all possible OWL descriptions and data ranges
The first three conditions require the existence of the finite sequences that are used in some OWL constructs. The remaining conditions require the existence of the 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 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∪LV | y∈CEXT_{I}(S_{I}(rdfs:Class)), <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 objects 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.
A OWL/DL interpretation over a vocabulary V', where V' includes VRDFS, rdfs:Literal, VOWL, owl:Thing, and owl:Nothing, 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 n ∈ VRDFS∪VOWL - {rdf:nil}, S_{I}(n) ∈ R_{I} - (LV∪IOT∪IOC∪IDC∪IOP∪IL). |
Now entailment in OWL/DL can be defined.
Let K be an RDF graph and let V be a vocabulary that includes VRDFS, rdfs:Literal, VOWL, owl:Thing, and owl:Nothing. An OWL/DL interpretation of K is an OWL/DL interpretation over V that is also an RDFS interpretation of K.
Let K be a set of n-triples. 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 is the empty URI and y is any URI then the imports closure of K contains the n-triples resulting from the RDF parsing of the document, if any, accessible at y into n-triples.
Let K and Q be collections of n-triples and let V be a vocabulary that includes VRDFS, rdfs:Literal, VOWL, owl:Thing, and owl:Nothing. Then K OWL/DL entails Q whenever all OWL/DL interpretations of the RDF graph specified by imports closure of K are also OWL/DL interpretations of the RDF graph specified by imports closure of Q.
One way to automatically obtain typing information for the vocabulary is to use translations into n-triples of certain kinds of OWL ontologies in the abstract syntax, as such translations contain information on which kind of entity a URI reference denotes. This is made more formal below.
A separated OWL vocabulary, V', is a set of URI references with a disjoint partition V' = < VI, VC, VD, VOP, VDP >, where owl:Thing and owl:Nothing are in VC, rdfs:Literal is in VD, and all the elements of D are in VD. Further V' is disjoint from VRDFS∪VOWL.
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, <individualvaluedPropertyIDs> are taken from VOP, and <datavaluedPropertyID>s are taken from VDP.
Let T be the mapping from OWL ontologies in the abstract syntax to n-triples. 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.
OWL/Full augments the common conditions with conditions that force the OWL and RDFS universes to be the same.
A OWL/Full interpretation over a vocabulary V, where V includes VRDFS, rdfs:Literal, VOWL, owl:Thing, and owl:Nothing, 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 is defined in same manner as OWL/DL entailment.
Let K,C be collections of n-triples 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.