Web Ontology Language (OWL) Abstract Syntax and Semantics
Section 3. Direct Model-Theoretic Semantics

Editors:
Peter F. Patel-Schneider, Bell Labs Research, Lucent Technologies
Ian Horrocks, Department of Computer Science, University of Manchester

Contents


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

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.

EC Extension Table
Abstract SyntaxInterpretation (EC)
owl:Thing R
owl:Nothing { }
complementOf(c) R - EC(c)
unionOf(c1 … cn) EC(c1) ∪ … ∪ EC(cn)
intersectionOf(c1 … cn) EC(c1) ∩ … ∩ EC(cn)
oneOf(i1 … in), for ij individualIDs {S(i1), …, S(in)}
oneOf(v1 … vn), for vj literals {S(v1), …, S(vn)}
restriction(p x1 … xn) EC(restriction(p x1)) ∩…∩EC(restriction(p xn))
restriction(p allValuesFrom(r)) {x ∈ R | <x,y> ∈ ER(p) implies 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(v)) {x ∈ R | <x,S(v)> ∈ ER(p)}
restriction(p minCardinality(n)) {x ∈ R | card({y ∈ R∪LV : <x,y> ∈ ER(p)}) ≥ n}
restriction(p maxCardinality(n)) {x ∈ R | card({y ∈ R∪LV : <x,y> ∈ ER(p)}) ≤ n}
restriction(p cardinality(n)) {x ∈ R | card({y ∈ R∪LV : <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(c1) ∩ … ∩ EC(cm) ∩ EC(pv(pv1)) ∩…∩ EC(pv(pvn))
value(p Individual(…)) {x ∈ R | ∃ y∈EC(Individual(…)) : <x,y> ∈ ER(p)}
value(p id) for id an individualID {x ∈ R | <x,S(id)> ∈ ER(p) }
value(p v) {x ∈ R | <x,S(v)> ∈ ER(p) }

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.

Interpretation of Axioms and Facts
DirectiveConditions 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)
DatatypeProperty(p annotation(…) … annotation(…)
    super(s1) … super(sn)
    domain(d1) … domain(dn) range(r1) … range(rn)
    [ Functional ])
ER(p) ⊆ R×LV ∩ ER(s1) ∩…∩ ER(sn) ∩
       EC(d1)×LV ∩…∩ EC(dn)×LV ∩
       R×EC(r1) ∩…∩ R×EC(rn)
[ER(p) is functional]
ObjectProperty(p annotation(…) … annotation(…)
    super(s1) … super(sn)
   
domain(d1) … domain(dn) range(r1) … range(rn)
   
[ inverse(i) ] [ Symmetric ]
    [
Functional ] [ InverseFunctional ]
    [
Transitive ])
ER(p) ⊆ R×R ∩ 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

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.