Copyright © 2008 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document is being published as one of a set of 711 documents:
The OWL Working Group seeks
public feedback on this First Publicthese Working Draft.Drafts. Please send your
comments to public-owl-comments@w3.org (public archive). If possible, please offer
specific changes to the text that would address your
concern. You may also wish to check the Wiki
Version of this document for internal-review comments and changes being
drafted which may address your concerns.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
Contents |
However, it has been proposed that there is no need to introduce such an additional sort of extension.
This document defines the RDF-compatible model-theoretic
semantics forof OWL 2, called "OWL 2 Full", which is an extension of the semantics defined in the RDF Semantics , and definesthe OWL 2
semantic
extension of RDFS. The document presented here extends the RDF Semantics document, and therefore has to be read in conjunction with it.RDFS [RDF
Semantics]. OWL 2 Full is specified forinherits every aspect of the semantic
specification of RDFS, and therefore the semantic meaning given to
an RDF graph by OWL 2 Full vocabulary inincludes the meaning given to the graph
by RDFS. Further, OWL 2 Full defines additional semantic meaning to
all the language features of OWL 2, following the design principles
that have been applied to the semantics of RDF. The content of this
document is not meant to be self-contained, but builds on top of
the RDF Semantics document by only adding the OWL 2 specific parts
of the semantics. Hence, the complete definition of OWL 2 Full is
actually given by the combination of these two documents.
OWL 2 Full is specified for the OWL 2 Full vocabulary in the form of a vocabulary interpretation, which is
defined on the OWL 2 Full universe. The OWL 2 Full universe
is identified with the RDFS universe, and comprises the set of all
individuals. It is further divided into sub parts, namely the
classes, the properties, and the interpretations of the literals,datatype values, which are thus
also individuals. Every class has a set of individuals associated
with it, the so called "class extension", which is distinguished
from the class itself. Analog, every property is associated with a
"property extension", which is a binary relation, i.e. a set of
pairs of individuals. The classes subsume the interpretations of thedatatypes, and the
properties subsume the data properties, the annotation properties,
and the ontology properties. Individuals may play different roles
at the same time. They can, for example, be both a class and a
property, or both a data property and an annotation property.
Every RDF graph is a syntactically valid OWL 2 Full ontology, which receives its semantic meaning by applying the set of OWL 2 Full semantic conditions. For ontologies importing other ontologies, the whole imports closure of that ontology will generally have to be taken into account.
A strong relationship holds between the RDF-Based Semantics of OWL 2 Full and the Direct Semantics of OWL 2 DL, in that OWL 2 Full is, in some sense, able to reflect all logical conclusions of OWL 2 DL. The precise relationship is stated by the OWL 2 correspondence theorem.
The italicized keywords MUST, MUST NOT, SHOULD, SHOULD NOT, and MAY specify certain aspects of the normative behavior of OWL 2 tools, and are interpreted as specified in RFC 2119 [RFC 2119].
The OWL 2 Full vocabulary is a set of URI references in the OWL namespace, owl:, which is given by the URI reference
Table 2.1 lists the OWL 2 Full vocabulary, which extends the RDF and RDFS vocabulary as specified by Sections 3.1 and 4.1 of the RDF Semantics. Excluded are those URI references from the OWL namespace, which are mentioned in one of the other tables in this section.
owl:AllDifferent owl:AllDisjointClasses
owl:AllDisjointProperties owl:allValuesFrom owl:Annotation
owl:AnnotationProperty owl:assertionProperty owl:AsymmetricProperty
owl:Axiom owl:backwardCompatibleWith owl:bottomDataProperty
owl:bottomObjectProperty owl:cardinality owl:Class owl:complementOf
owl:DataRange owl:datatypeComplementOf owl:DatatypeProperty
owl:deprecated owl:DeprecatedClass owl:DeprecatedProperty
owl:differentFrom owl:disjointUnionOf owl:disjointWith
owl:distinctMembers owl:equivalentClass owl:equivalentProperty
owl:FunctionalProperty owl:hasKey owl:hasSelf owl:hasValue
owl:imports owl:incompatibleWith owl:intersectionOf
owl:InverseFunctionalProperty owl:inverseOf owl:IrreflexiveProperty
owl:maxCardinality owl:maxQualifiedCardinality owl:members
owl:minCardinality owl:minQualifiedCardinality owl:NamedIndividual
owl:NegativePropertyAssertion owl:Nothing owl:object
owl:ObjectProperty owl:onClass owl:onDataRange owl:onDatatype
owl:oneOf owl:onProperty owl:onProperties owl:Ontology
owl:OntologyProperty owl:predicate owl:priorVersion
owl:propertyChain owl:propertyDisjointWith owl:qualifiedCardinality
owl:ReflexiveProperty owl:Restriction owl:sameAs |
Note: The use of the URI reference owl:DataRange has been deprecated as of OWL 2. The URI reference rdfs:Datatype SHOULD be used instead.
Table 2.2 lists the
set of datatypes supported by OWL 2 Full. The interpretation ofdatatype
rdf:XMLLiteral is described in Section
3.1 of the RDF Semantics.
The interpretation ofAll other datatypes isare described in Section 4 of the OWL 2 Structural Specification.
xsd:anyURI xsd:base64Binary xsd:boolean xsd:byte
owl:dateTime xsd:decimal xsd:double |
Table 2.3 lists the set of datatype facets supported by OWL 2 Full. Section 4 of the OWL 2 Structural Specification describes the meaning of each facet, and to which datatypes it can be applied, respectively.
rdf:langPattern xsd:length xsd:maxExclusive xsd:maxInclusive xsd:maxLength xsd:minExclusive xsd:minInclusive xsd:minLength xsd:pattern |
Every well-formed RDF graph is a syntactically valid OWL 2 Full
providesontology. If a vocabulary interpretation and vocabulary entailment (see Section 2.1 of the RDF Semantics ) for the RDF vocabulary, the RDFS vocabulary, and theOWL 2 Full vocabulary . Fromontology imports other OWL 2 Full
ontologies, then the RDF Semantics , let V be a setwhole imports closure of URI references and literals containing the RDF and RDFS vocabulary, andthat ontology
has to be taken into account.
Definition 3.1 (Import Closure): Let DK be a datatype map according to Section 5.1collection of
theRDF Semantics . A D-interpretation ofgraphs. 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 referred to by u. The imports
closure of a collection of RDF graphs is the smallest imports
closed collection of RDF graphs containing the graphs.
An OWL 2 Full ontology MAY contain an ontology header, with optional information about the ontology's version, if the ontology's author wants to signal that the ontology is a OWL 2 Full ontology. The OWL 2 RDF Mapping provides details about the syntax of ontology headers.
OWL 2 Full provides a vocabulary interpretation and vocabulary entailment (see Section 2.1 of the RDF Semantics) for the RDF vocabulary, the RDFS vocabulary, and the OWL 2 Full vocabulary.
From the RDF Semantics, let V be a set of URI references and literals containing the RDF and RDFS vocabulary, and let D be a datatype map according to Section 5.1 of the RDF Semantics. A D-interpretation I of V is a tuple
I = 〈 IR, IP, IEXT, IS, IL, LV 〉.
IR is the domain of discourse or universe, i.e., a nonempty set
that contains the denotations of URI references and literals in V.
IP is a subset of IR, the properties of I. LV is a subset of IR
that covers at least the interpretationsvalue spaces of all datatypes in D. IEXT
is used to associate properties with their property extension, and
is a mapping from IP to P(IR × IR), where "P " meansis the
powerset. IS is a mapping from URI references in V to their
denotations in IR. IL is a mapping from typed literals in V to
their denotations in LV.IR, where in particular the denotations of all
well-typed literals are members of LV (Section 5.1 of the RDF Semantics explains why the
range of IL is actually IR instead of LV). The set of classes IC is
defined as
IC = { x ∈ IR | 〈x,IS(rdfs:Class)〉〈x,I(rdfs:Class)〉 ∈ IEXT(IS(rdf:type))IEXT(I(rdf:type)) }.
The mapping ICEXT from IC to P(IR) associates classes with their class extension, and is defined as
ICEXT(c) = { x ∈ IR | 〈x,c〉 ∈ IEXT(IS(rdf:type))IEXT(I(rdf:type)) }
for c ∈ IC.
As detailed in the RDF Semantics, a D-interpretation has to meet additional semantic conditions, which constrain the set of RDF graphs that are true under this interpretation. An RDF graph G is said to be satisfied by a D-interpretation I, if I(G) = true.
Definition 3.14.1 (OWL 2 Full Datatype Map): Let D be a
datatype map as defined in Section 5.1 of the RDF Semantics. D is ana OWL 2
Full datatype map, if it contains at least all datatypes listed
in Table 2.2.
Definition 3.24.2 (OWL 2 Full Interpretation): Let D be ana
OWL 2 Full datatype map, and let V be a vocabulary that includes
the RDF and RDFS vocabularies, and the OWL 2 Full vocabulary
together with all the datatype and facet names listed in Section 2. An OWL 2 Full
interpretation, I = 〈 IR, IP, IEXT, IS, IL, LV 〉, of V with
respect to D, is a D-interpretation of V that meetssatisfies all the
extra semantic conditions given in Section 45.
Definition 3.34.3 (OWL 2 Full Consistency): Let K be a
collection of RDF graphs, and let D be ana OWL 2 Full datatype map, and let V be amap. K
is OWL 2 Full consistent with respect to D iff there is some
OWL 2 Full interpretation I with respect to D of some vocabulary V
that includes the RDF and RDFS vocabularies, and the OWL 2 Full
vocabulary together with all the datatype and facet names listed in
Section 2 . K is OWL 2 Full consistent with respect to D iff there is some OWL 2 Full interpretation of V with respect to D that, where I satisfies everyall
the RDF graphgraphs in K.
Definition 3.44.4 (OWL 2 Full Entailment): Let K and Q be
collections of RDF graphs, and let D be ana OWL 2 Full datatype map, and let V be amap.
K OWL 2 Full entails Q with respect to D iff every OWL 2
Full interpretation I with respect to D of any vocabulary V that
includes the RDF and RDFS vocabularies,vocabularies and the OWL 2 Full
vocabulary together with all the datatype and facet names listed in
Section 2 . K OWL 2 Full entails Q with respect to D iff every OWL 2 Full interpretation of V with respect to D that, and where I satisfies
everyall the RDF graphgraphs in KK, then I also satisfies everyall the RDF graphgraphs
in Q.
The semantic conditions presented here haveare those specific to the
OWL 2 Full vocabulary. This
set of semantic conditions is not self-contained, but has to be
regarded in conjunction with the semantic conditions given for
Simple Entailment, RDF, RDFS and D-Entailment in the RDF Semantics.
The denotations of RDF triples, which occur in the semantic conditions, are closely related to triple sets given in the RDF Mapping .Table 4.15.1 on "Basic
Sets" enumerates the different parts of the OWL 2 Full universe,
such as the sets of classes, properties, etc., which are referred
to by many semantic conditions in this section. Table 4.25.2 lists several
"Convenient Abbreviations" for sets that are often used within
semantic conditions. Table
4.35.3 and Table
4.45.4 list basic semantic conditions for the classes and the
properties of the OWL 2 Full vocabulary, which can be regarded as
the OWL 2 Full "axiomatic triples" (this is further explained by
the introduction of these tables). The remaining tables in this
section specify the OWL 2 Full semantic conditions for the
different language features of OWL 2.
Most semantic conditions are "iff" conditions, which exactly
specify the semantics of the respective language feature. Some
language features only have "if-then" conditions in order to avoid
certain semantic paradoxes and other problems with the semantics.
Several language features with "iff" conditions, namely Sub
Property Chains in Table 4.105.10, N-ary Axioms in Table 4.125.12, and Negative
Property Assertions in Table 4.165.16, have a multi-triple representation in RDF,
where the different triples share a common "root node" x. In
order to treat this specific syntactic aspect technically, the
"iff" conditions of these language features are split into two
"if-then" conditions, and the right-to-left "if" condition contains
an additional premise of the form "∃x ∈ IR", which has the single
purpose to provide the needed "root node" x.
Conventions used in this section:
Several conventions are used when presenting logic expressions
in the below tables. Having a comma between two entriesstatements
in a semantic condition, as in
c ∈ IC , p ∈ IP
means a logical "and". If no scope is given for a variable x, as in "∀x:…" or in "{x|…}", then x is unconstrained, which means that x ∈ IR. An expression of the form
l sequence of u1,…, un ∈ S
means that u1 ∈ S,… , un ∈ S, and that there exist x1 ∈ IR,…, xn ∈ IR, such that
IS(l)I(l) ∈ ICEXT(IS(rdf:List)), IS(l)ICEXT(I(rdf:List)),
I(l) = IS(xI(x1),
〈x1,u1〉 ∈ IEXT(IS(rdf:first)),IEXT(I(rdf:first)),
〈x1,x2〉 ∈ IEXT(IS(rdf:rest)),IEXT(I(rdf:rest)),
…,
〈xn,un〉 ∈ IEXT(IS(rdf:first)),IEXT(I(rdf:first)),
〈xn ,IS(rdf:nil)〉,I(rdf:nil)〉 ∈ IEXT(IS(rdf:rest)).IEXT(I(rdf:rest)).
The following names for sets are used in addition to those given in Section 4:
The semantic conditions in the tables below sometimes do not
explicitly list typing statements in their consequent that one
would normally expect. This may be the case if these statements can
already be deduced by means of the semantic conditions given in
Table 4.35.3 and Table 4.45.4, occasionally in
connection with Table 4.15.1.
For example, the semantic condition for owl:allValuesFrom
restrictions in Table
4.75.7 does not have the statement x ∈
ICEXT(IS(ICEXT(I(owl:Restriction)) on its
right hand side. The reason is that this result can already be
obtained from the third column of the entry for owl:allValuesFrom in Table 4.45.4, which determines
that IEXT(IS(owl:allValuesFrom))IEXT(I(owl:allValuesFrom)) ⊆ ICEXT(IS(owl:Restriction))ICEXT(I(owl:Restriction)) ×
IC.
Table 4.15.1 presents
basic sets used in OWL 2 Full, their relationship to other sets,
and properties of their instances.
Name of Set S |
Conditions on Set S |
Conditions on Instances x of S |
Explanation |
---|---|---|---|
IR | S ≠ ∅ | all individuals (or resources) | |
LV | S ⊆ IR | all |
|
IX | S ⊆ IR | all ontologies | |
IC | S ⊆ IR | ICEXT(x) ⊆ IR | all classes |
IDC | S ⊆ IC | ICEXT(x) ⊆ LV | all datatypes |
IP | S ⊆ IR | IEXT(x) ⊆ IR × IR | all (object) properties |
IODP | S ⊆ IP | IEXT(x) ⊆ IR × LV | all data properties |
IOAP | S ⊆ IP | IEXT(x) ⊆ IR × IR | all annotation properties |
IOXP | S ⊆ IP | IEXT(x) ⊆ IX × IX | all ontology properties |
Table 4.25.2
provides abbreviations for additional sets, which are used
throughout this document.
Name of Set S | Explanation |
---|---|
|
The set of all facets allowed for datatype d. |
|
The set of all |
IFEXT(d,f,u) | The subset of the class extension of datatype d that results
from applying facet f with facet value |
Table 4.35.3 lists the
classes of the OWL 2 Full vocabulary (and certain classes from RDF
and RDFS), together with their relationship to other classes. Not
included in this table are the different datatypes, as given
in Table 2.2. For a
datatype URI D, IS(D)I(D) ∈
IDC, and ICEXT(IS(D))ICEXT(I(D)) ⊆ LV.
Informative Note: The semantic conditions given here can
be regarded as the OWL 2 Full "axiomatic triples" for classes: For
each URI U occurring in the first column of the table, if the
second column contains an entry "IS(U)"I(U) ∈ S" for some set S, then
this entry corresponds to some RDF triple of the form "U rdf:type
C", where C is the URI of some class with ICEXT(IS(C))ICEXT(I(C)) = S. In this
table, S will always be either the set IC of all classes, or a
subset of IC. Hence, in a corresponding RDF triple the URI C will
typically be one of "rdfs:Class" or "owl:Class" (S=IC in both
cases), or "rdfs:Datatype" (S=IDC). Further, for each URI U in the
first column, if the third column contains an entry "ICEXT(IS(U))"ICEXT(I(U)) ⊆
S" ("ICEXT(IS(U))("ICEXT(I(U)) = S") for some set S, then this entry corresponds
to some RDF triple of the form "U rdfs:subClassOf C" ("U
owl:equivalentClass C"), where C is the URI of some class with
ICEXT(IS(C))ICEXT(I(C)) = S. Additionally, the conditions on the sets given in
Table 4.15.1 have to be taken
into account. In particular, if an entry of Table 4.15.1 states S1 ⊆
S2 for some sets S1 and S2, then
this corresponds to some RDF triple C1 owl:subClassOf
C2, where C1 and C2 are the URIs
of some classes with ICEXT(IS(CICEXT(I(C1)) = S1 and
ICEEXT(IS(CICEXT(I(C2)) = S2, respectively, according to
Table 4.35.3. Note that
some of the RDF triples received in this way already follow from
the RDFS Semantics. These
axiomatic triples are "simple" in the following sense: For every
set S mentioned in the second and the third column of the
table there exists a URI C of some class in the vocabularies
for RDF, RDFS or those given in Section 2, for which S = ICEXT(IS(C))ICEXT(I(C)).
Vocabulary URI U | |
ICEXT(I(U)) |
---|---|---|
owl:AllDifferent | ∈ IC | ⊆ IR |
owl:AllDisjointClasses | ∈ IC | ⊆ IR |
owl:AllDisjointProperties | ∈ IC | ⊆ IR |
owl:Annotation | ∈ IC | ⊆ IR |
owl:AnnotationProperty | ∈ IC | = IOAP |
owl:AsymmetricProperty | ∈ IC | ⊆ IP |
owl:Axiom | ∈ IC | ⊆ IR |
rdfs:Class | ∈ IC | = IC |
owl:Class | ∈ IC | = IC |
owl:DataRange | ∈ IC | = IDC |
rdfs:Datatype | ∈ IC | = IDC |
owl:DatatypeProperty | ∈ IC | = IODP |
owl:DeprecatedClass | ∈ IC | ⊆ IC |
owl:DeprecatedProperty | ∈ IC | ⊆ IP |
owl:FunctionalProperty | ∈ IC | ⊆ IP |
owl:InverseFunctionalProperty | ∈ IC | ⊆ IP |
owl:IrreflexiveProperty | ∈ IC | ⊆ IP |
rdfs:Literal | ∈ IDC | = LV |
owl:NamedIndividual | ∈ IC | = IR |
owl:NegativePropertyAssertion | ∈ IC | ⊆ IR |
owl:Nothing | ∈ IC | = ∅ |
owl:ObjectProperty | ∈ IC | = IP |
owl:Ontology | ∈ IC | = IX |
owl:OntologyProperty | ∈ IC | = IOXP |
rdf:Property | ∈ IC | = IP |
owl:ReflexiveProperty | ∈ IC | ⊆ IP |
rdfs:Resource | ∈ IC | = IR |
owl:Restriction | ∈ IC | ⊆ IC |
|
∈ IC | ⊆ IP |
owl:Thing | ∈ IC | = IR |
owl:TransitiveProperty | ∈ IC | ⊆ IP |
Table 4.45.4 lists
the properties of the OWL 2 Full vocabulary (and certain properties
from RDF and RDFS), together with their domain and range. Not included in this table areNote that
the ranges of the properties owl:deprecated and owl:hasSelf are not restricted to be boolean values,
in order to allow assertions with one of these properties to have
objects of arbitrary type.
Not included in this table are the different datatype
facets, as given in Table
2.3. For a facet URI F, IS(F)I(F) ∈ IP, and IEXT(IS(F))IEXT(I(F)) ⊆ IR ×
LV.
Informative Note: The semantic conditions given here can
be regarded as the OWL 2 Full "axiomatic triples" for properties:
For each URI U occurring in the first column of the table, if the
second column contains an entry "IS(U)"I(U) ∈ S" for some set S, then
this entry corresponds to some RDF triple of the form "U rdf:type
C", where C is the URI of some class with ICEXT(IS(C))ICEXT(I(C)) = S. In this
table, S will always be either the set IP of all properties, or a
subset of IP. Hence, in a corresponding RDF triple the URI C will
typically be one of "rdf:Property" or "owl:ObjectProperty" (S=IP in
both cases), "owl:DatatypeProperty" (S=IODP),
"owl:AnnotationProperty" (S=IOAP), or "owl:OntologyProperty"
(S=IOXP). Further, for each URI U in the first column, if the third
column contains an entry "IEXT(IS(U))"IEXT(I(U)) ⊆ S1 ×
S2" for some sets S1 and S2, then
this entry corresponds to some RDF triples of the forms "U
rdfs:domain C1" and "U rdfs:range C2", where
C1 and C2 are the URIs of some classes with
ICEXT(IS(CICEXT(I(C1)) = S1 and ICEEXT(IS(CICEXT(I(C2))
= S2, respectively. Exceptions are the semantic
conditions "IEXT(IS(owl:TopObjectProperty))"IEXT(I(owl:topObjectProperty)) = IR × IR" and
"IEXT(IS(owl:TopDataProperty))"IEXT(I(owl:topDataProperty)) = IR × LV", for which there are no
corresponding domain and range triples. These axiomatic triples are
"simple" in the following sense: For every set S mentioned
in the second column of the table, and as the left or right hand
side of a Cartesian product in the third column of the table there
exists a URI C of some class in the vocabularies for RDF,
RDFS or those given in Section 2,
for which S = ICEXT(IS(C))ICEXT(I(C)).
Vocabulary URI U | |
IEXT(I(U)) |
---|---|---|
owl:allValuesFrom | ∈ IP | ⊆ |
owl:assertionProperty | ∈ IP | ⊆ |
owl:backwardCompatibleWith | ∈ IOXP | ⊆ IX × IX |
owl:bottomDataProperty | ∈ IODP | = ∅ |
owl:bottomObjectProperty | ∈ IP | = ∅ |
owl:cardinality | ∈ IP | ⊆ |
rdfs:comment | ∈ IOAP | ⊆ IR × LV |
owl:complementOf | ∈ IP | ⊆ IC × IC |
owl:datatypeComplementOf | ∈ IP | ⊆ IDC × IDC |
owl:deprecated | ∈ IOAP | ⊆ IR × IR |
owl:differentFrom | ∈ IP | ⊆ IR × IR |
owl:disjointUnionOf | ∈ IP | ⊆ IC × |
owl:disjointWith | ∈ IP | ⊆ IC × IC |
owl:distinctMembers | ∈ IP | ⊆ |
owl:equivalentClass | ∈ IP | ⊆ IC × IC |
owl:equivalentProperty | ∈ IP | ⊆ IP × IP |
owl:hasKey | ∈ IP | ⊆ IC × |
owl:hasSelf | ∈ IP | ⊆ ICEXT(I(owl:Restriction)) × IR |
owl:hasValue | ∈ IP | ⊆ |
owl:imports | ∈ IOXP | ⊆ IX × IX |
owl:incompatibleWith | ∈ IOXP | ⊆ IX × IX |
owl:intersectionOf | ∈ IP | ⊆ IC × |
owl:inverseOf | ∈ IP | ⊆ IP × IP |
rdfs:isDefinedBy | ∈ IOAP | ⊆ IR × IR |
rdfs:label | ∈ IOAP | ⊆ IR × LV |
owl:maxCardinality | ∈ IP | ⊆ |
owl:maxQualifiedCardinality | ∈ IP | ⊆ |
owl:members | ∈ IP | ⊆ IR × |
owl:minCardinality | ∈ IP | ⊆ |
owl:minQualifiedCardinality | ∈ IP | ⊆ |
owl:object | ∈ IP | ⊆ IR × IR |
owl:onClass | ∈ IP | ⊆ |
owl:onDataRange | ∈ IP | ⊆ |
owl:onDatatype | ∈ IP | ⊆ IDC × IDC |
owl:oneOf | ∈ IP | ⊆ IC × |
owl:onProperty | ∈ IP | ⊆ |
owl:onProperties | ∈ IP | ⊆ |
owl:predicate | ∈ IP | ⊆ IR × IP |
owl:priorVersion | ∈ IOXP | ⊆ IX × IX |
owl:propertyChain | ∈ IP | ⊆ IP × |
owl:propertyDisjointWith | ∈ IP | ⊆ IP × IP |
owl:qualifiedCardinality | ∈ IP | ⊆ |
owl:sameAs | ∈ IP | ⊆ IR × IR |
rdfs:seeAlso | ∈ IOAP | ⊆ IR × IR |
owl:someValuesFrom | ∈ IP | ⊆ |
owl:sourceIndividual | ∈ IP | ⊆ |
owl:subject | ∈ IP | ⊆ IR × IR |
owl:targetIndividual | ∈ IP | ⊆ |
owl:targetValue | ∈ IP | ⊆ |
owl:topDataProperty | ∈ IODP | = IR × LV |
owl:topObjectProperty | ∈ IP | = IR × IR |
owl:unionOf | ∈ IP | ⊆ IC × |
owl:versionInfo | ∈ IOAP | ⊆ IR × IR |
owl:withRestrictions | ∈ IP | ⊆ IDC × |
Table 4.55.5 lists the
semantic conditions for boolean combinations,class expressions, which exist for
building class and datatypecomplements, intersections, and unions of classes. An
intersection or union of a set of datatypes is itself a datatype.
While a "normal" complement of a class is created w.r.t. to the
whole domain, a datatype complement is created for a datatype
w.r.t. the set of data values only, and results itself in a
datatype.
〈c,d〉 ∈ |
iff | c, d ∈ IC ICEXT(c) = IR \ ICEXT(d) |
---|---|---|
〈c,d〉 ∈ |
c, d ∈ IDC, ICEXT(c) = LV \ ICEXT(d) |
|
if l sequence of d1,…, dn ∈ IR then | ||
〈c,l〉 ∈ |
iff | c, d1,…, dn ∈ IC, ICEXT(c) = ICEXT(d1) ∩…∩ ICEXT(dn) |
〈c,l〉 ∈ |
c, d1,…, dn ∈ IC, ICEXT(c) = ICEXT(d1) ∪…∪ ICEXT(dn) |
|
if | then | |
l sequence of d1,…,
dn ∈ IDC, n ≥ 1, 〈c,l〉 ∈ IEXT(I(owl:intersectionOf)) |
c ∈ IDC | |
l sequence of d1,…,
dn ∈ IDC, n ≥ 1, 〈c,l〉 ∈ IEXT(I(owl:unionOf)) |
c ∈ IDC |
Table 4.65.6 lists
the semantic conditions for enumerations, i.e. classes, which have
an explicitly defined, finite set of instances. EnumerationsAn enumeration
entirely consisting of datadatatype values are datatypes.is a datatype.
if |
||
---|---|---|
〈c,l〉 ∈ |
iff | c ∈ ICEXT(c) = { u1,…, un } |
if | then | |
l sequence of u1,…,
un ∈ 〈c,l〉 ∈ |
c ∈ |
Table 4.75.7 lists
the semantic conditions for restriction classes, which areproperty restrictions, including self
restrictions, value restrictions, and (qualified) cardinality
restrictions. Note that the semantic condition for self
restrictions does not entail the right hand side of a owl:hasSelf assertion to be a boolean value, in order
to allow such assertions having right hand sides of arbitrary
type.
if | then |
---|---|
〈x,p〉 ∈ |
ICEXT(x) = {y | 〈y,y〉 ∈ IEXT(p)} |
〈x,c〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | ∀z : 〈y,z〉 ∈ IEXT(p) → z ∈ ICEXT(c)} |
l sequence of p1,…, pn ∈
〈x,c〉 ∈ 〈x,l〉 ∈ |
p1,…, pn ∈ IODP, c ∈ IDC, ICEXT(x) = {y | ∀z1,…,zn : 〈y,z1〉 ∈ IEXT(p1) ∧…∧ 〈y,zn〉 ∈ IEXT(pn) → 〈z1,…,zn〉 ∈ ICEXT(c)} |
〈x,c〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | ∃z : 〈y,z〉 ∈ IEXT(p) ∧ z ∈ ICEXT(c)} |
l sequence of p1,…, pn ∈
〈x,c〉 ∈ 〈x,l〉 ∈ |
p1,…, pn ∈ IODP, c ∈ IDC, ICEXT(x) = {y | ∃z1,…,zn : 〈y,z1〉 ∈ IEXT(p1) ∧…∧ 〈y,zn〉 ∈ IEXT(pn) ∧ 〈z1,…,zn〉 ∈ ICEXT(c)} |
〈x,u〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | 〈y,u〉 ∈ IEXT(p)} |
〈x,n〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | #{z|〈y,z〉 ∈ IEXT(p)} = n} |
〈x,n〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | #{z|〈y,z〉 ∈ IEXT(p)} ≥ n} |
〈x,n〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | #{z|〈y,z〉 ∈ IEXT(p)} ≤ n} |
〈x,n〉 ∈ 〈x,c〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | #{z|〈y,z〉 ∈ IEXT(p) ∧ z ∈ ICEXT(c)} = n} |
〈x,n〉 ∈ 〈x,c〉 ∈ 〈x,p〉 ∈ |
p ∈ IODP, ICEXT(x) = {y | #{z ∈ LV|〈y,z〉 ∈ IEXT(p) ∧ z ∈ ICEXT(c)} = n} |
〈x,n〉 ∈
〈x,c〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | #{z|〈y,z〉 ∈ IEXT(p) ∧ z ∈ ICEXT(c)} ≥ n} |
〈x,n〉 ∈
〈x,c〉 ∈ 〈x,p〉 ∈ |
p ∈ IODP, ICEXT(x) = {y | #{z ∈ LV|〈y,z〉 ∈ IEXT(p) ∧ z ∈ ICEXT(c)} ≥ n} |
〈x,n〉 ∈
〈x,c〉 ∈ 〈x,p〉 ∈ |
ICEXT(x) = {y | #{z |〈y,z〉 ∈ IEXT(p) ∧ z ∈ ICEXT(c)} ≤ n} |
〈x,n〉 ∈
〈x,c〉 ∈ 〈x,p〉 ∈ |
p ∈ IODP, ICEXT(x) = {y | #{z ∈ LV|〈y,z〉 ∈ IEXT(p) ∧ z ∈ ICEXT(c)} ≤ n} |
Table 4.85.8 lists the
semantic conditionconditions for datatype restrictions, which are specified
by a set of facets with their facet values applied to a datatype.
Note that if no facet is applied to a given datatype, then the
resulting datatype will be equivalent to the original datatype.
Note further that the semantic condition is specified in a way that
applying a facet to a datatype, for which it is not defined, orwill
lead to an unsatisfiable ontology. Likewise, adding an illegalinapplicable
facet value to a facet/datatypecertain combination of a datatype a facet will
lead to an unsatisfiable ontology. Table 4.8:As a consequence, a datatype
Restrictions if then l sequence of yrestriction with one or more specified facets will lead to an
unsatisfiable ontology when applied to a datatype for which no
facets are defined (usually a set of facets only exists for
datatypes contained in the datatype map).
if | then |
---|---|
l sequence of y1,…, yn ∈
IR, f1,…, fn ∈ IP, 〈c,d〉 ∈ 〈c,l〉 ∈ 〈y1,u1〉 ∈ IEXT(f1), …, 〈yn,un〉 ∈ IEXT(fn) |
c, d ∈ IDC, fi ∈ ui ∈ ICEXT(c) = ICEXT(d) ∩ |
Table 4.95.9
extends the semantic conditions for the RDFS vocabulary. The
original semantics for RDFS, as specified in the RDF Semantics, only provide
"if-then" semantic conditions, while OWL 2 Full specifies stronger
"iff" semantic conditions. Note that only the additional semantic
conditions are given here and that the other conditions on the RDF
and RDFS vocabulary are retained.
〈c,d〉 ∈ |
iff | c, d ∈ IC, ICEXT(c) ⊆ ICEXT(d) |
---|---|---|
〈p,q〉 ∈ |
p, q ∈ IP, IEXT(p) ⊆ IEXT(q) |
|
〈p,c〉 ∈ |
p ∈ IP, c ∈ IC, ∀x,y : 〈x,y〉 ∈ IEXT(p) → x ∈ ICEXT(c) |
|
〈p,c〉 ∈ |
p ∈ IP, c ∈ IC, ∀x,y : 〈x,y〉 ∈ IEXT(p) → y ∈ ICEXT(c) |
Table 4.105.10
lists the semantic conditions for sub property chains.
if | then |
---|---|
l sequence of p1,…, pn ∈
IR, 〈x,q〉 ∈ 〈x,l〉 ∈ |
p1,…, pn ∈ IP, ∀y0,…,yn : 〈y0,y1〉 ∈ IEXT(p1) ∧…∧ 〈yn-1,yn〉 ∈ IEXT(pn) → 〈y0,yn〉 ∈ IEXT(q) |
if | then exists x ∈ IR |
l sequence of p1,…, pn ∈
IP, ∀y0,…,yn : 〈y0,y1〉 ∈ IEXT(p1) ∧…∧ 〈yn-1,yn〉 ∈ IEXT(pn) → 〈y0,yn〉 ∈ IEXT(q) |
〈x,q〉 ∈ 〈x,l〉 ∈ |
Table 4.115.11
lists the semantic conditions for equal and different individuals,
equivalent and disjoint classes, and equivalent and disjoint
properties. Also treated here are axioms to specify disjoint
unions.
〈u,w〉 ∈ |
iff | u = w |
---|---|---|
〈u,w〉 ∈ |
u ≠ w | |
〈c,d〉 ∈ |
c, d ∈ IC, ICEXT(c) = ICEXT(d) |
|
〈c,d〉 ∈ |
c, d ∈ IC, ICEXT(c) ∩ ICEXT(d) = ∅ |
|
〈p,q〉 ∈ |
p, q ∈ IP, IEXT(p) = IEXT(q) |
|
〈p,q〉 ∈ |
p, q ∈ IP, IEXT(p) ∩ IEXT(q) = ∅ |
|
if l sequence of d1,…, dn ∈ IR then | ||
〈c,l〉 ∈ |
iff | c, d1,…, dn ∈ IC, ICEXT(c) = ICEXT(d1) ∪…∪ ICEXT(dn), ICEXT(di) ∩ ICEXT(dk) = ∅ for 1 ≤ i ≠ k ≤ n |
Table 4.125.12 lists
the semantic conditions for the n-ary versions of the axioms for
different individuals, disjoint classes, and disjoint
properties.
if | then |
---|---|
l sequence of u1,…, un ∈
IR, x ∈ 〈x,l〉 ∈ |
ui ≠ uk for 1 ≤ i ≠ k ≤ n |
l sequence of u1,…, un ∈
IR, x ∈ 〈x,l〉 ∈ |
ui ≠ uk for 1 ≤ i ≠ k ≤ n |
l sequence of c1,…, cn ∈
IR, x ∈ 〈x,l〉 ∈ |
c1,…, cn ∈ IC, ICEXT(ci) ∩ ICEXT(ck) = ∅ for 1 ≤ i ≠ k ≤ n |
l sequence of p1,…, pn ∈
IR, x ∈ 〈x,l〉 ∈ |
p1,…, pn ∈ IP, IEXT(pi) ∩ IEXT(pk) = ∅ for 1 ≤ i ≠ k ≤ n |
if | then exists x ∈ IR |
l sequence of u1,…, un ∈
IR, ui ≠ uk for 1 ≤ i ≠ k ≤ n |
x ∈ 〈x,l〉 ∈ |
l sequence of u1,…, un ∈
IR, ui ≠ uk for 1 ≤ i ≠ k ≤ n |
x ∈ 〈x,l〉 ∈ |
l sequence of c1,…, cn ∈
IC, ICEXT(ci) ∩ ICEXT(ck) = ∅ for 1 ≤ i ≠ k ≤ n |
x ∈ 〈x,l〉 ∈ |
l sequence of p1,…, pn ∈
IP, IEXT(pi) ∩ IEXT(pk) = ∅ for 1 ≤ i ≠ k ≤ n |
x ∈ 〈x,l〉 ∈ |
Table 4.135.13 lists
the semantic condition for inverse property axioms.
〈p,q〉 ∈ |
iff | p, q ∈ IP, IEXT(p) = { 〈x,y〉 | 〈y,x〉 ∈ IEXT(q) } |
---|
Table
4.145.14 lists the semantic conditions for property
characteristics, i.e. functionality and inverse functionality,
reflexivity and irreflexivity, symmetry and asymmetry, and
transitivity of properties.
p ∈ |
iff | p ∈ IP, ∀x,y,z : 〈x,y〉, 〈x,z〉 ∈ IEXT(p) → y = z |
---|---|---|
p ∈ |
p ∈ IP, ∀x,y,z : 〈y,x〉, 〈z,x〉 ∈ IEXT(p) → y = z |
|
p ∈ |
p ∈ IP, ∀x : 〈x,x〉 ∈ IEXT(p) |
|
p ∈ |
p ∈ IP, ∀x : 〈x,x〉 ∉ IEXT(p) |
|
p ∈ |
p ∈ IP, ∀x,y : 〈x,y〉 ∈ IEXT(p) → 〈y,x〉 ∈ IEXT(p) |
|
p ∈ |
p ∈ IP, ∀x,y : 〈x,y〉 ∈ IEXT(p) → 〈y,x〉 ∉ IEXT(p) |
|
p ∈ |
p ∈ IP, ∀x,y,z : 〈x,y〉, 〈y,z〉 ∈ IEXT(p) → 〈x,z〉 ∈ IEXT(p) |
Table 4.155.15 lists the
semantic condition for Keys.
if l sequence of p1,…, pn ∈ IR then | ||
---|---|---|
〈c,l〉 ∈ |
iff | c ∈ IC, p1,…, pn ∈ IP, ∀x,y,z1,…,zn : x, y ∈ ICEXT(c), 〈x,zi〉, 〈y,zi〉 ∈ IEXT(pi), 1 ≤ i ≤ n → x = y |
Table
4.165.16 lists the semantic conditions for negative property
assertions.
if | then |
---|---|
〈x,u〉 ∈ 〈x,p〉 ∈ 〈x,w〉 ∈ |
x ∈ 〈u,w〉 ∉ IEXT(p) |
〈x,u〉 ∈ 〈x,p〉 ∈ 〈x,w〉 ∈ |
x ∈ p ∈ IODP, 〈u,w〉 ∉ IEXT(p) |
if | then exists x ∈ IR |
u ∈ IR, p ∈ IP, w ∈ IR, 〈u,w〉 ∉ IEXT(p) |
〈x,u〉 ∈ 〈x,p〉 ∈ 〈x,w〉 ∈ |
u ∈ IR, p ∈ IODP, w ∈ LV, 〈u,w〉 ∉ IEXT(p) |
〈x,u〉 ∈ 〈x,p〉 ∈ 〈x,w〉 ∈ |
This intosection is concerned with a single semantic condition without the typing triples, i.e. where the LHS ofstrong relationship that holds
between the semantic condition only consistsRDF-Based Semantics of the three triples for owl:subject, owl:predicate, and owl:object? Table 4.17: Reified Axioms and Annotations if then x in ICEXT(IS(owl:Axiom)), 〈x,u〉 ∈ IEXT(IS(owl:subject)), 〈x,p〉 ∈ IEXT(IS(owl:predicate)), 〈x,w〉 ∈ IEXT(IS(owl:object)) 〈u,w〉 ∈ IEXT(p) x in ICEXT(IS(owl:Annotation)), 〈x,u〉 ∈ IEXT(IS(owl:subject)), 〈x,p〉 ∈ IEXT(IS(owl:predicate)), 〈x,w〉 ∈ IEXT(IS(owl:object)) 〈u,w〉 ∈ IEXT(p) 5 Ontologies Editor's Note: Open Question : Should something be said about Ontology headers and versioning? This does not have a special semantics, and so its treatment isn't really needed technically. But maybe they should be treated for completeness? Every well-formed RDF graph is a syntactically validOWL 2 Full ontology,and its semantic meaning is given bythe Direct Semantics of OWL 2 Full semantics. If anDL.
One design goal of OWL 2 Full ontology imports otherhas been that OWL 2 Full ontologies, then oneshould regard the semantic meaning of the whole imports closure (see Definition 5.1 ) of that ontology. Note that Section 3 defines the terms "OWL 2 Full Consistency" and "OWL 2 Full Entailment" for collections of RDF graphs. Definition 5.1 (Import Closure): 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 referred to by u. The imports closure of a collection of RDF graphs is the smallest imports closed collection of RDF graphs containing the graphs. 6 Relationship to OWL 2 DL This section is concerned with a strong relationship that holds between the RDF-Based Semantics of OWL 2 Full and the Direct Semantics of OWL 2 DL. One design goal of OWL 2 has been that OWL 2 Full should reflect every logical consequencereflect
every logical consequence of OWL 2 DL, as long as this consequence
and all its premises can be represented as valid OWL 2 DL
ontologies in RDF graph form. However, a fundamental semantic
difference exists between OWL 2 DL and OWL 2 Full, which
complicates a comparison of the semantic expressiveness of the two
languages. OWL 2 DL treats classes as sets, i.e. subsets of
the universe, while classes in OWL 2 Full are individuals,
which have such a set associated as their class extension. Hence,
under OWL 2 Full semantics, all classes are instances of the
universe, but this cannot generally be assumed under OWL 2 Direct
Semantics. An analog difference exists for properties.
An effect of this difference is that certain logical conclusions of OWL 2 DL do not become "visible" under the OWL 2 Full semantics, although they are reflected by OWL 2 Full at a set theoretical level. For example, under OWL 2 Direct Semantics, the RDF graph
G1 := {
ex:C rdf:type owl:Class .
ex:D rdf:type owl:Class .
ex:C rdfs:subClassOf ex:D .
}
entails the RDF graph
G2 := {
ex:C rdf:type owl:Class .
ex:D rdf:type owl:Class .
_:x owl:intersectionOf (SEQ ex:C ex:D) .
_:x rdfs:subClassOf ex:D .
}.
OWL 2 Full, on the other hand, interprets G1 in a way such that the set theoretical relationship
ICEXT(IS(ex:C))ICEXT(I(ex:C)) ∩ ICEXT(IS(ex:D))ICEXT(I(ex:D)) ⊆ ICEXT(IS(ex:D))ICEXT(I(ex:D))
can be concluded. But since OWL 2 Full distinguishes between classes and their class extensions, G2 is not entailed, unless there exists some additional "helper" individual, which has the set
ICEXT(IS(ex:C))ICEXT(I(ex:C)) ∩ ICEXT(IS(ex:D))ICEXT(I(ex:D))
as its class extension. Whether such a helper individual exists or not has no effect on the answer to the question, whether the basic logical conclusion that exists at the set theoretical level holds or not. The individual is, however needed, to represent this conclusion in the particular form given by G2.
The following subsection introduces a set of "comprehension
principles", which have the purpose to provide the missing
"helper" individuals. These comprehension principles are not
part of the set of semantic conditions given in Section 45, and therefore do not need to
be met by ana OWL 2 Full interpretation as defined in Section 34. They are, however, needed for
the correspondence theorem, stated in the second subsection,
to hold, since the correspondence theorem compares OWL 2 Full and
OWL 2 DL based on entailments.
Table 6.1 lists the comprehension principle for lists, which provides the existence of RDF lists for each finite combination of individuals.
if | then exists x1,…, xn ∈ IR |
---|---|
u1,…, un ∈ IR | 〈x1,u1〉 ∈
…, 〈xn,un〉 ∈ |
Table 6.2 lists the
comprehension principles for boolean combinations,class expressions, which
provide the existence of classes representing the complement of
each class, and the datatype complement of each datatype, and the
union and intersection of each finite set of classes.
if | then exists x ∈ IR |
---|---|
c ∈ IC | 〈x,c〉 ∈ |
c ∈ IDC | 〈x,c〉 ∈ |
l sequence of c1,…, cn ∈ IC | 〈x,l〉 ∈ |
l sequence of c1,…, cn ∈ IC | 〈x,l〉 ∈ |
Table 6.3 lists the
comprehension principleprinciples for enumerations,enumeration classes, which providesprovide the
existence of classes representing each finite set of
individuals.
if | then exists x ∈ IR |
---|---|
l sequence of u1,…, un ∈ IR | 〈x,l〉 ∈ |
Table 6.4 lists the comprehension principles for property restrictions, which provide the existence of self restrictions, value restrictions, cardinality restrictions, and qualified cardinality restrictions for each property, class and individual for which such a restriction is meaningful.
if | then exists x ∈ IR |
---|---|
p ∈ IP | 〈x,p〉 ∈ |
c ∈ IC, p ∈ IP |
〈x,c〉 ∈ 〈x,p〉 ∈ |
c ∈ IDC, l sequence of p1,…, pn ∈ IODP |
〈x,c〉 ∈ 〈x,l〉 ∈ |
c ∈ IC, p ∈ IP |
〈x,c〉 ∈ 〈x,p〉 ∈ |
c ∈ IDC, l sequence of p1,…, pn ∈ IODP |
〈x,c〉 ∈ 〈x,l〉 ∈ |
u ∈ IR, p ∈ IP |
〈x,u〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, p ∈ IP |
〈x,n〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, p ∈ IP |
〈x,n〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, p ∈ IP |
〈x,n〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, c ∈ IC, p ∈ IP |
〈x,n〉 ∈ 〈x,c〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, c ∈ IDC, p ∈ IODP |
〈x,n〉 ∈ 〈x,c〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, c ∈ IC, p ∈ IP |
〈x,n〉 ∈
〈x,c〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, c ∈ IDC, p ∈ IODP |
〈x,n〉 ∈
〈x,c〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, c ∈ IC, p ∈ IP |
〈x,n〉 ∈
〈x,c〉 ∈ 〈x,p〉 ∈ |
n ∈ INNI, c ∈ IDC, p ∈ IODP |
〈x,n〉 ∈
〈x,c〉 ∈ 〈x,p〉 ∈ |
Table 6.5 lists the
comprehension principleprinciples for datatype restrictions, which provides
the existence of restrictions for each datatype, and for each
combination of facets and facet values for which such a restriction
is meaningful.
if | then exists x ∈ IR, l sequence of y1,…,yn ∈ IR |
---|---|
c ∈ IDC, f1,…,fn facets, u1,…,un ∈ LV |
〈x,c〉 ∈ 〈x,l〉 ∈ 〈y1,u1〉 ∈ IEXT(f1), …, 〈yn,un〉 ∈ IEXT(fn) |
Theorem 6.1 (Correspondence Theorem): Let D be ana OWL 2 Full datatype map, and let K
and Q be collections of valid OWL 2 DL ontologies in RDF graph formgraph form
that are imports closed, and without annotations occurring in Q.
Let F(K) and F(Q) be the collections of OWL 2 DL ontologies in
Functional Syntax that result from applying the Reverse RDF Mapping to K and Q,
respectively. If F(K) entails F(Q) with respect to the OWL 2 Direct
Semantics and with respect to D, then K entails Q with respect to
the OWL 2 RDF-Based Semantics extended by the comprehension
principles, and with respect to D.
Proof.
This section lists significant changes since the First Public Working Draft.
This section lists significant differences between OWL 2 Full
and the original version of OWL Full.Full, as defined in Section 5 of
the OWL Semantics and Abstract
Syntax.