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 goes directly from ontologies in the abstract syntax to a standard model theory. It is much simpler than the semantics Section 5 that uses an OWL knowledge base in the form of n-triples and is an extension of the RDFS model theory.
The semantics here starts with the notion of a vocabulary, which can be thought of as the URI references that are of interest in a knowledge base. It is, however, not necessary that a vocabulary consist only of the URI references in a knowledge base.
An OWL vocabulary V is a set of URI references, including owl:Thing, owl:Nothing, and rdfs:Literal. Each OWL vocabulary also includes URI references for each of the XML Schema non-list built-in simple datatypes. In the semantics LV is the (non-disjoint) union of the value spaces of these datatypes.
An Abstract OWL interpretation with vocabulary V is a four-tuple of the form:
I = <R, S, EC, ER>
where
S provides meaning for URI references that are used to denote OWL individuals, while EC and ER provide meaning for URI references that are used as OWL classes and OWL properties, respectively.
Abstract OWL interpretations have the following conditions having to do with datatypes:
EC is extended to the syntactic constructs of <description>s, <dataRange>s, <individual>s, and <propertyValue>s as follows:
| Syntax - S | EC(S) |
|---|---|
| owl:Thing | R |
| owl:Nothing | { } |
| rdfs:Literal | LV |
| complementOf(c) | R - EC(c) |
| unionOf(c1 … cn) | EC(c1) ∪ … ∪ EC(cn) |
| intersectionOf(c1 … cn) | EC(c1) ∩ … ∩ EC(cn) |
| oneOf(i1 … in) | {S(i1), …, S(in)} |
| oneOf(d1,l1 … dn,ln) | {D(d1,l1), …, D(dn,ln)} |
| restriction(p x1 … xn) | EC(restriction(p x1))∩…∩EC(restriction(p xn)) |
| restriction(p allValuesFrom(r)) | {x ∈ R | <x,y> ∈ ER(p) → y ∈ EC(r)} |
| restriction(p someValuesFrom(e)) | {x ∈ R | ∃ <x,y> ∈ ER(p) ∧ y ∈ EC(e)} |
| restriction(p value(i)) | {x ∈ R | <x,S(i)> ∈ ER(p)} |
| restriction(p value(d,l)) | {x ∈ R | <x,D(d,l)> ∈ ER(p)} |
| restriction(p minCardinality(n)) | {x ∈ R | card({y : <x,y> ∈ ER(p)}) ≤ n} |
| restriction(p maxCardinality(n)) | {x ∈ R | card({y : <x,y> ∈ ER(p)}) ≥ n} |
| restriction(p cardinality(n)) | {x ∈ R | card({y : <x,y> ∈ ER(p)}) = n} |
| Individual(annotation(…) … annotation(…) type(c1) … type(cm) pv1 … pvn) | EC(c1) ∩ … ∩ EC(cm) ∩ EC(pv(pv1)) ∩…∩ EC(pv(pvn)) |
| Individual(i annotation(…) … annotation(…) type(c1) … type(cm) pv1 … pvn) | {S(i)} ∩ EC(c) ∩ … ∩ EC(cm) ∩ EC(pv(pv1)) ∩…∩ EC(pv(pvn)) |
| pv(p Individual(…)) | {x ∈ R | ∃ y∈EC(Individual(…)) : <x,y> ∈ ER(p)} |
| pv(p id), for id an individualID | {x ∈ R | <x,S(id)> ∈ ER(p) } |
| pv(p d,l) | {x ∈ R | <x,D(d,l)> ∈ ER(p) } |
An Abstract OWL interpretation, I, is an interpretation of OWL axioms and facts as given in the table below. In the table, optional parts of axioms and facts are given in square brackets ([…]) and have corresponding optional conditions, also given in square brackets.
| Directive | Conditions on interpretations |
|---|---|
| Class(c complete annotation(…) … annotation(…) descr1 … descrn) | EC(c) = EC(descr1) ∩…∩ EC(descrn) |
| Class(c partial annotation(…) … annotation(…) descr1 … descrn) | EC(c) ⊆ EC(descr1) ∩…∩ EC(descrn) |
| EnumeratedClass(c annotation(…) … annotation(…) i1 … in) | EC(c) = { S(i1), …, S(in) } |
| DisjointClasses(d1 … dn) | EC(di) ∩ EC(dj) = { } for 1 ≤ i < j ≤ n |
| EquivalentClasses(d1 … dn) | EC(di) = EC(dj) for 1 ≤ i < j ≤ n |
| SubClassOf(d1 d2) | EC(d1) ⊆ EC(d2) |
| DataProperty(p annotation(…) … annotation(…) super(s1) … super(sn) domain(d1) … domain(dn) range(r1) … range(rn) [Functional]) |
ER(p) ⊆ ER(s1) ∩…∩ ER(sn) ∩ EC(d1)×LV ∩…∩ EC(dn)×LV ∩ R×EC(r1) ∩…∩ R×EC(rn) [ER(p) is functional] |
| IndividualProperty(p annotation(…) … annotation(…) super(s1) … super(sn) domain(d1) … domain(dn) range(r1) … range(rn) [inverse(i)] [Symmetric] [Functional] [InverseFunctional] [Transitive]) |
ER(p) ⊆ ER(s1) ∩…∩ ER(sn) ∩ EC(d1)×R ∩…∩ EC(dn)×R ∩ R×EC(r1) ∩…∩ R×EC(rn) [ER(p) is the inverse of ER(i)] [ER(p) is symmetric] [ER(p) is functional] [ER(p) is inverse functional] [ER(p) is transitive] |
| EquivalentProperties(p1 … pn) | ER(pi) = ER(pj) for 1 ≤ i < j ≤ n |
| SubPropertyOf(p1 p2) | ER(p1) ⊆ ER(p2) |
| SameIndividual(i1 … in) | S(ij) = S(ik) for 1 ≤ j < k ≤ n |
| DifferentIndividuals(i1 … in) | S(ij) ≠ S(ik) for 1 ≤ j < k ≤ n |
| Individual([i] annotation(…) … annotation(…) type(c1) … type(cm) pv1 … pvn) |
EC(Individual([i] type(c1) … type(cm) pv1 … pvn)) is nonempty |
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. 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.
Annotations have no effect on the semantics of OWL ontologies in the abstract syntax.
An Abstract OWL interpretation, I, is an interpretation of an OWL ontology, O, iff I is an interpretation of each axiom and fact in the imports closure of O.
An Abstract OWL ontology entails an OWL axiom or fact if each interpretation of the ontology is also an interpretation of the axiom or fact. An Abstract OWL ontology entails another Abstract OWL ontology if each interpretation of the first ontology is also an interpretation of 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.