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 7 documents:
The OWL Working Group intends to make OWL 2 be a superset of OWL 1, except for a limited number of situations where we believe the impact will be minimal. This means that OWL 2 will be backward compatible, and creators of OWL 1 documents need only move to OWL 2 when they want to make use of OWL 2 features. More details and advice concerning migration from OWL 1 to OWL 2 will be in future drafts.
The OWL Working Group seeks public feedback on this First Public Working Draft. Please send your comments to publicowlcomments@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 internalreview 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 modeltheoretic semantics for OWL 2, called "OWL 2 Full", is an extension of the semantics defined in the RDF Semantics, and defines the 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.
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, 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 the datatypes, 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 RDFBased 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: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 owl:SelfRestriction owl:someValuesFrom owl:sourceIndividual owl:subject owl:SymmetricProperty owl:targetIndividual owl:targetValue owl:Thing owl:TopDataProperty owl:TopObjectProperty owl:TransitiveProperty owl:unionOf owl:versionInfo owl:withRestrictions 
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 of rdf:XMLLiteral is described in Section 3.1 of the RDF Semantics. The interpretation of all other datatypes is described in Section 4 of the OWL 2 Structural Specification.
xsd:anyURI xsd:base64Binary xsd:boolean xsd:byte owl:dateTime xsd:decimal xsd:double xsd:ENTITY xsd:float xsd:hexBinary xsd:ID xsd:IDREF xsd:int xsd:integer xsd:language xsd:long xsd:Name xsd:NCName xsd:negativeInteger xsd:NMTOKEN xsd:nonNegativeInteger xsd:nonPositiveInteger xsd:normalizedString xsd:positiveInteger owl:real owl:realPlus xsd:short xsd:string rdf:text xsd:token xsd:unsignedByte xsd:unsignedInt xsd:unsignedLong xsd:unsignedShort rdf:XMLLiteral 
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 
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 Dinterpretation 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 interpretations 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" means 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. The set of classes IC is defined as
IC = { x ∈ IR  ⟨x,IS(rdfs:Class)⟩ ∈ IEXT(IS(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)) }
for c ∈ IC.
As detailed in the RDF Semantics, a Dinterpretation 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 Dinterpretation I, if I(G) = true.
Definition 3.1 (OWL 2 Full Datatype Map): Let D be a datatype map as defined in Section 5.1 of the RDF Semantics. D is an OWL 2 Full datatype map, if it contains at least all datatypes listed in Table 2.2.
Definition 3.2 (OWL 2 Full Interpretation): Let D be an 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 Dinterpretation of V that meets all the semantic conditions given in Section 4.
Definition 3.3 (OWL 2 Full Consistency): Let K be a collection of RDF graphs, let D be an 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. 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 satisfies every RDF graph in K.
Definition 3.4 (OWL 2 Full Entailment): Let K and Q be collections of RDF graphs, let D be an 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. K OWL 2 Full entails Q with respect to D iff every OWL 2 Full interpretation of V with respect to D that satisfies every RDF graph in K also satisfies every RDF graph in Q.
The semantic conditions presented here have to be regarded in conjunction with the semantic conditions given for Simple Entailment, RDF, RDFS and DEntailment 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.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.2 lists several "Convenient Abbreviations" for sets that are often used within semantic conditions. Table 4.3 and Table 4.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 "ifthen" 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.10, Nary Axioms in Table 4.12, and Negative Property Assertions in Table 4.16, have a multitriple 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 "ifthen" conditions, and the righttoleft "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 entries 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 u_{1},…, u_{n} ∈ S
means that u_{1} ∈ S,… , u_{n} ∈ S, and that there exist x_{1} ∈ IR,…, x_{n} ∈ IR, such that
IS(l) ∈ ICEXT(IS(rdf:List)),
IS(l) = IS(x_{1}),
⟨x_{1},u_{1}⟩ ∈ IEXT(IS(rdf:first)),
⟨x_{1},x_{2}⟩ ∈ IEXT(IS(rdf:rest)),
…,
⟨x_{n},u_{n}⟩ ∈ IEXT(IS(rdf:first)),
⟨x_{n},IS(rdf:nil)⟩ ∈ IEXT(IS(rdf:rest)).
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.3 and Table 4.4, occasionally in connection with Table 4.1. For example, the semantic condition for owl:allValuesFrom restrictions in Table 4.7 does not have the statement x ∈ ICEXT(IS(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.4, which determines that IEXT(IS(owl:allValuesFrom)) ⊆ ICEXT(IS(owl:Restriction)) × IC.
Table 4.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 data values  
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.2 provides abbreviations for additional sets, which are used throughout this document.
Name of Set S  Explanation 

INNI  The subset of LV which consists of all nonnegative integers. 
IFA(d)  The set of all facets allowed for datatype d. 
IFAV(d,f)  The set of all possible values for a given facet f and a datatype d. 
IFAEXT(d,f,u)  The subset of the class extension of datatype d that results from applying facet f with value u. 
Table 4.3 lists the classes of 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) ∈ IDC, and ICEXT(IS(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) ∈ 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)) = 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)) ⊆ S" ("ICEXT(IS(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)) = S. Additionally, the conditions on the sets given in Table 4.1 have to be taken into account. In particular, if an entry of Table 4.1 states S_{1} ⊆ S_{2} for some sets S_{1} and S_{2}, then this corresponds to some RDF triple C_{1} owl:subClassOf C_{2}, where C_{1} and C_{2} are the URIs of some classes with ICEXT(IS(C_{1})) = S_{1} and ICEEXT(IS(C_{2})) = S_{2}, respectively, according to Table 4.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)).
Vocabulary URI U  IS(U)  ICEXT(IS(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 
owl:SelfRestriction  ∈ IC  ⊆ ICEXT(IS(owl:Restriction)) 
owl:SymmetricProperty  ∈ IC  ⊆ IP 
owl:Thing  ∈ IC  = IR 
owl:TransitiveProperty  ∈ IC  ⊆ IP 
Table 4.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 are the different datatype facets, as given in Table 2.3. For a facet URI F, IS(F) ∈ IP, and IEXT(IS(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) ∈ 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)) = 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)) ⊆ S_{1} × S_{2}" for some sets S_{1} and S_{2}, then this entry corresponds to some RDF triples of the forms "U rdfs:domain C_{1}" and "U rdfs:range C_{2}", where C_{1} and C_{2} are the URIs of some classes with ICEXT(IS(C_{1})) = S_{1} and ICEEXT(IS(C_{2})) = S_{2}, respectively. Exceptions are the semantic conditions "IEXT(IS(owl:TopObjectProperty)) = IR × IR" and "IEXT(IS(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)).
Vocabulary URI U  IS(U)  IEXT(IS(U)) 

owl:allValuesFrom  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × IC 
owl:assertionProperty  ∈ IP  ⊆ ICEXT(IS(owl:NegativePropertyAssertion)) × IP 
owl:backwardCompatibleWith  ∈ IOXP  ⊆ IX × IX 
owl:BottomDataProperty  ∈ IODP  = ∅ 
owl:BottomObjectProperty  ∈ IP  = ∅ 
owl:cardinality  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × INNI 
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 × ICEXT(IS(rdf:List)) 
owl:disjointWith  ∈ IP  ⊆ IC × IC 
owl:distinctMembers  ∈ IP  ⊆ ICEXT(IS(owl:AllDifferent)) × ICEXT(IS(rdf:List)) 
owl:equivalentClass  ∈ IP  ⊆ IC × IC 
owl:equivalentProperty  ∈ IP  ⊆ IP × IP 
owl:hasKey  ∈ IP  ⊆ IC × ICEXT(IS(rdf:List)) 
owl:hasValue  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × IR 
owl:imports  ∈ IOXP  ⊆ IX × IX 
owl:incompatibleWith  ∈ IOXP  ⊆ IX × IX 
owl:intersectionOf  ∈ IP  ⊆ IC × ICEXT(IS(rdf:List)) 
owl:inverseOf  ∈ IP  ⊆ IP × IP 
rdfs:isDefinedBy  ∈ IOAP  ⊆ IR × IR 
rdfs:label  ∈ IOAP  ⊆ IR × LV 
owl:maxCardinality  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × INNI 
owl:maxQualifiedCardinality  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × INNI 
owl:members  ∈ IP  ⊆ IR × ICEXT(IS(rdf:List)) 
owl:minCardinality  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × INNI 
owl:minQualifiedCardinality  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × INNI 
owl:object  ∈ IP  ⊆ IR × IR 
owl:onClass  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × IC 
owl:onDataRange  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × IDC 
owl:onDatatype  ∈ IP  ⊆ IDC × IDC 
owl:oneOf  ∈ IP  ⊆ IC × ICEXT(IS(rdf:List)) 
owl:onProperty  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × IP 
owl:onProperties  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × ICEXT(IS(rdf:List)) 
owl:predicate  ∈ IP  ⊆ IR × IP 
owl:priorVersion  ∈ IOXP  ⊆ IX × IX 
owl:propertyChain  ∈ IP  ⊆ IP × ICEXT(IS(rdf:List)) 
owl:propertyDisjointWith  ∈ IP  ⊆ IP × IP 
owl:qualifiedCardinality  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × INNI 
owl:sameAs  ∈ IP  ⊆ IR × IR 
rdfs:seeAlso  ∈ IOAP  ⊆ IR × IR 
owl:someValuesFrom  ∈ IP  ⊆ ICEXT(IS(owl:Restriction)) × IC 
owl:sourceIndividual  ∈ IP  ⊆ ICEXT(IS(owl:NegativePropertyAssertion)) × IR 
owl:subject  ∈ IP  ⊆ IR × IR 
owl:targetIndividual  ∈ IP  ⊆ ICEXT(IS(owl:NegativePropertyAssertion)) × IR 
owl:targetValue  ∈ IP  ⊆ ICEXT(IS(owl:NegativePropertyAssertion)) × LV 
owl:TopDataProperty  ∈ IODP  = IR × LV 
owl:TopObjectProperty  ∈ IP  = IR × IR 
owl:unionOf  ∈ IP  ⊆ IC × ICEXT(IS(rdf:List)) 
owl:versionInfo  ∈ IOAP  ⊆ IR × IR 
owl:withRestrictions  ∈ IP  ⊆ IDC × ICEXT(IS(rdf:List)) 
Table 4.5 lists the semantic conditions for boolean combinations, which exist for building class and datatype complements, intersections, and unions of classes.
⟨c,d⟩ ∈ IEXT(IS(owl:complementOf))  iff  c, d ∈ IC ICEXT(c) = IR \ ICEXT(d) 

⟨c,d⟩ ∈ IEXT(IS(owl:datatypeComplementOf))  c, d ∈ IDC, ICEXT(c) = LV \ ICEXT(d) 

if l sequence of d_{1},…, d_{n} ∈ IR then  
⟨c,l⟩ ∈ IEXT(IS(owl:intersectionOf))  iff  c, d_{1},…, d_{n} ∈ IC, ICEXT(c) = ICEXT(d_{1}) ∩…∩ ICEXT(d_{n}) 
⟨c,l⟩ ∈ IEXT(IS(owl:unionOf))  c, d_{1},…, d_{n} ∈ IC, ICEXT(c) = ICEXT(d_{1}) ∪…∪ ICEXT(d_{n}) 
Table 4.6 lists the semantic conditions for enumerations, i.e. classes, which have an explicitly defined, finite set of instances. Enumerations entirely consisting of data values are datatypes.
if  then  

l sequence of u_{1},…,
u_{n} ∈ LV, n ≥ 1, ⟨c,l⟩ ∈ IEXT(IS(owl:oneOf)) 
c ∈ IDC  
if l sequence of u_{1},…, u_{n} ∈ IR then  
⟨c,l⟩ ∈ IEXT(IS(owl:oneOf))  iff  c ∈ IC, ICEXT(c) = { u_{1},…, u_{n} } 
Table 4.7 lists the semantic conditions for restriction classes, which are self restrictions, value restrictions, and (qualified) cardinality restrictions.
if  then 

x ∈ ICEXT(IS(owl:SelfRestriction)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  ⟨y,y⟩ ∈ IEXT(p)} 
⟨x,c⟩ ∈ IEXT(IS(owl:allValuesFrom)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  ∀z : ⟨y,z⟩ ∈ IEXT(p) → z ∈ ICEXT(c)} 
l sequence of p_{1},…, p_{n} ∈
IODP, ⟨x,c⟩ ∈ IEXT(IS(owl:allValuesFrom)), ⟨x,l⟩ ∈ IEXT(IS(owl:onProperties)) 
ICEXT(x) = {y  ∀z_{1},…,z_{n} : ⟨y,z_{1}⟩ ∈ IEXT(p_{1}) ∧…∧ ⟨y,z_{n}⟩ ∈ IEXT(p_{n}) → ⟨z_{1},…,z_{n}⟩ ∈ ICEXT(c)} 
⟨x,c⟩ ∈ IEXT(IS(owl:someValuesFrom)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  ∃z : ⟨y,z⟩ ∈ IEXT(p) ∧ z ∈ ICEXT(c)} 
l sequence of p_{1},…, p_{n} ∈
IODP, ⟨x,c⟩ ∈ IEXT(IS(owl:someValuesFrom)), ⟨x,l⟩ ∈ IEXT(IS(owl:onProperties)) 
ICEXT(x) = {y  ∃z_{1},…,z_{n} : ⟨y,z_{1}⟩ ∈ IEXT(p_{1}) ∧…∧ ⟨y,z_{n}⟩ ∈ IEXT(p_{n}) ∧ ⟨z_{1},…,z_{n}⟩ ∈ ICEXT(c)} 
⟨x,u⟩ ∈ IEXT(IS(owl:hasValue)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  ⟨y,u⟩ ∈ IEXT(p)} 
⟨x,n⟩ ∈ IEXT(IS(owl:cardinality)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  #{z⟨y,z⟩ ∈ IEXT(p)} = n} 
⟨x,n⟩ ∈ IEXT(IS(owl:minCardinality)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  #{z⟨y,z⟩ ∈ IEXT(p)} ≥ n} 
⟨x,n⟩ ∈ IEXT(IS(owl:maxCardinality)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  #{z⟨y,z⟩ ∈ IEXT(p)} ≤ n} 
⟨x,n⟩ ∈ IEXT(IS(owl:qualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onClass)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  #{z⟨y,z⟩ ∈ IEXT(p) ∧ z ∈ ICEXT(c)} = n} 
⟨x,n⟩ ∈ IEXT(IS(owl:qualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onDataRange)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
p ∈ IODP, ICEXT(x) = {y  #{z ∈ LV⟨y,z⟩ ∈ IEXT(p) ∧ z ∈ ICEXT(c)} = n} 
⟨x,n⟩ ∈
IEXT(IS(owl:minQualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onClass)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  #{z⟨y,z⟩ ∈ IEXT(p) ∧ z ∈ ICEXT(c)} ≥ n} 
⟨x,n⟩ ∈
IEXT(IS(owl:minQualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onDataRange)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
p ∈ IODP, ICEXT(x) = {y  #{z ∈ LV⟨y,z⟩ ∈ IEXT(p) ∧ z ∈ ICEXT(c)} ≥ n} 
⟨x,n⟩ ∈
IEXT(IS(owl:maxQualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onClass)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
ICEXT(x) = {y  #{z ⟨y,z⟩ ∈ IEXT(p) ∧ z ∈ ICEXT(c)} ≤ n} 
⟨x,n⟩ ∈
IEXT(IS(owl:maxQualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onDataRange)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
p ∈ IODP, ICEXT(x) = {y  #{z ∈ LV⟨y,z⟩ ∈ IEXT(p) ∧ z ∈ ICEXT(c)} ≤ n} 
Table 4.8 lists the semantic condition for datatype restrictions, which are specified by a set of facets with their 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, or adding an illegal value to a facet/datatype combination will lead to an unsatisfiable ontology.
if  then 

l sequence of y_{1},…, y_{n} ∈
IR, f_{1},…, f_{n} ∈ IP, ⟨c,d⟩ ∈ IEXT(IS(owl:onDatatype)), ⟨c,l⟩ ∈ IEXT(IS(owl:withRestrictions)), ⟨y_{1},u_{1}⟩ ∈ IEXT(f_{1}), …, ⟨y_{n},u_{n}⟩ ∈ IEXT(f_{n}) 
c, d ∈ IDC, f_{i} ∈ IFA(d) for 1≤i≤n, u_{i} ∈ IFAV(d,f_{i}) for 1≤i≤n, ICEXT(c) = ICEXT(d) ∩ IFAEXT(d,f_{1},u_{1}) ∩…∩ IFAEXT(d,f_{n},u_{n}) 
Table 4.9 extends the semantic conditions for the RDFS vocabulary. The original semantics for RDFS, as specified in the RDF Semantics, only provide "ifthen" 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⟩ ∈ IEXT(IS(rdfs:subClassOf))  iff  c, d ∈ IC, ICEXT(c) ⊆ ICEXT(d) 

⟨p,q⟩ ∈ IEXT(IS(rdfs:subPropertyOf))  p, q ∈ IP, IEXT(p) ⊆ IEXT(q) 

⟨p,c⟩ ∈ IEXT(IS(rdfs:domain))  p ∈ IP, c ∈ IC, ∀x,y : ⟨x,y⟩ ∈ IEXT(p) → x ∈ ICEXT(c) 

⟨p,c⟩ ∈ IEXT(IS(rdfs:range))  p ∈ IP, c ∈ IC, ∀x,y : ⟨x,y⟩ ∈ IEXT(p) → y ∈ ICEXT(c) 
Table 4.10 lists the semantic conditions for sub property chains.
if  then 

l sequence of p_{1},…, p_{n} ∈
IR, ⟨x,q⟩ ∈ IEXT(IS(rdfs:subPropertyOf)), ⟨x,l⟩ ∈ IEXT(IS(owl:propertyChain)) 
p_{1},…, p_{n} ∈ IP, ∀y_{0},…,y_{n} : ⟨y_{0},y_{1}⟩ ∈ IEXT(p_{1}) ∧…∧ ⟨y_{n1},y_{n}⟩ ∈ IEXT(p_{n}) → ⟨y_{0},y_{n}⟩ ∈ IEXT(q) 
if  then exists x ∈ IR 
l sequence of p_{1},…, p_{n} ∈
IP, ∀y_{0},…,y_{n} : ⟨y_{0},y_{1}⟩ ∈ IEXT(p_{1}) ∧…∧ ⟨y_{n1},y_{n}⟩ ∈ IEXT(p_{n}) → ⟨y_{0},y_{n}⟩ ∈ IEXT(q) 
⟨x,q⟩ ∈ IEXT(IS(rdfs:subPropertyOf)), ⟨x,l⟩ ∈ IEXT(IS(owl:propertyChain)) 
Table 4.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⟩ ∈ IEXT(IS(owl:sameAs))  iff  u = w 

⟨u,w⟩ ∈ IEXT(IS(owl:differentFrom))  u ≠ w  
⟨c,d⟩ ∈ IEXT(IS(owl:equivalentClass))  c, d ∈ IC, ICEXT(c) = ICEXT(d) 

⟨c,d⟩ ∈ IEXT(IS(owl:disjointWith))  c, d ∈ IC, ICEXT(c) ∩ ICEXT(d) = ∅ 

⟨p,q⟩ ∈ IEXT(IS(owl:equivalentProperty))  p, q ∈ IP, IEXT(p) = IEXT(q) 

⟨p,q⟩ ∈ IEXT(IS(owl:propertyDisjointWith))  p, q ∈ IP, IEXT(p) ∩ IEXT(q) = ∅ 

if l sequence of d_{1},…, d_{n} ∈ IR then  
⟨c,l⟩ ∈ IEXT(IS(owl:disjointUnionOf))  iff  c, d_{1},…, d_{n} ∈ IC, ICEXT(c) = ICEXT(d_{1}) ∪…∪ ICEXT(d_{n}), ICEXT(d_{i}) ∩ ICEXT(d_{k}) = ∅ for 1 ≤ i ≠ k ≤ n 
Table 4.12 lists the semantic conditions for the nary versions of the axioms for different individuals, disjoint classes, and disjoint properties.
if  then 

l sequence of u_{1},…, u_{n} ∈
IR, x ∈ ICEXT(IS(owl:AllDifferent)), ⟨x,l⟩ ∈ IEXT(IS(owl:distinctMembers)) 
u_{i} ≠ u_{k} for 1 ≤ i ≠ k ≤ n 
l sequence of u_{1},…, u_{n} ∈
IR, x ∈ ICEXT(IS(owl:AllDifferent)), ⟨x,l⟩ ∈ IEXT(IS(owl:members)) 
u_{i} ≠ u_{k} for 1 ≤ i ≠ k ≤ n 
l sequence of c_{1},…, c_{n} ∈
IR, x ∈ ICEXT(IS(owl:AllDisjointClasses)), ⟨x,l⟩ ∈ IEXT(IS(owl:members)) 
c_{1},…, c_{n} ∈ IC, ICEXT(c_{i}) ∩ ICEXT(c_{k}) = ∅ for 1 ≤ i ≠ k ≤ n 
l sequence of p_{1},…, p_{n} ∈
IR, x ∈ ICEXT(IS(owl:AllDisjointProperties)), ⟨x,l⟩ ∈ IEXT(IS(owl:members)) 
p_{1},…, p_{n} ∈ IP, IEXT(p_{i}) ∩ IEXT(p_{k}) = ∅ for 1 ≤ i ≠ k ≤ n 
if  then exists x ∈ IR 
l sequence of u_{1},…, u_{n} ∈
IR, u_{i} ≠ u_{k} for 1 ≤ i ≠ k ≤ n 
x ∈ ICEXT(IS(owl:AllDifferent)), ⟨x,l⟩ ∈ IEXT(IS(owl:distinctMembers)) 
l sequence of u_{1},…, u_{n} ∈
IR, u_{i} ≠ u_{k} for 1 ≤ i ≠ k ≤ n 
x ∈ ICEXT(IS(owl:AllDifferent)), ⟨x,l⟩ ∈ IEXT(IS(owl:members)) 
l sequence of c_{1},…, c_{n} ∈
IC, ICEXT(c_{i}) ∩ ICEXT(c_{k}) = ∅ for 1 ≤ i ≠ k ≤ n 
x ∈ ICEXT(IS(owl:AllDisjointClasses)), ⟨x,l⟩ ∈ IEXT(IS(owl:members)) 
l sequence of p_{1},…, p_{n} ∈
IP, IEXT(p_{i}) ∩ IEXT(p_{k}) = ∅ for 1 ≤ i ≠ k ≤ n 
x ∈ ICEXT(IS(owl:AllDisjointProperties)), ⟨x,l⟩ ∈ IEXT(IS(owl:members)) 
Table 4.13 lists the semantic condition for inverse property axioms.
⟨p,q⟩ ∈ IEXT(IS(owl:inverseOf))  iff  p, q ∈ IP, IEXT(p) = { ⟨x,y⟩  ⟨y,x⟩ ∈ IEXT(q) } 

Table 4.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 ∈ ICEXT(IS(owl:FunctionalProperty))  iff  p ∈ IP, ∀x,y,z : ⟨x,y⟩, ⟨x,z⟩ ∈ IEXT(p) → y = z 

p ∈ ICEXT(IS(owl:InverseFunctionalProperty))  p ∈ IP, ∀x,y,z : ⟨y,x⟩, ⟨z,x⟩ ∈ IEXT(p) → y = z 

p ∈ ICEXT(IS(owl:ReflexiveProperty))  p ∈ IP, ∀x : ⟨x,x⟩ ∈ IEXT(p) 

p ∈ ICEXT(IS(owl:IrreflexiveProperty))  p ∈ IP, ∀x : ⟨x,x⟩ ∉ IEXT(p) 

p ∈ ICEXT(IS(owl:SymmetricProperty))  p ∈ IP, ∀x,y : ⟨x,y⟩ ∈ IEXT(p) → ⟨y,x⟩ ∈ IEXT(p) 

p ∈ ICEXT(IS(owl:AsymmetricProperty))  p ∈ IP, ∀x,y : ⟨x,y⟩ ∈ IEXT(p) → ⟨y,x⟩ ∉ IEXT(p) 

p ∈ ICEXT(IS(owl:TransitiveProperty))  p ∈ IP, ∀x,y,z : ⟨x,y⟩, ⟨y,z⟩ ∈ IEXT(p) → ⟨x,z⟩ ∈ IEXT(p) 
Table 4.15 lists the semantic condition for Keys.
if l sequence of p_{1},…, p_{n} ∈ IR then  

⟨c,l⟩ ∈ IEXT(IS(owl:hasKey))  iff  c ∈ IC, p_{1},…, p_{n} ∈ IP, ∀x,y,z_{1},…,z_{n} : x, y ∈ ICEXT(c), ⟨x,z_{i}⟩, ⟨y,z_{i}⟩ ∈ IEXT(p_{i}), 1 ≤ i ≤ n → x = y 
Table 4.16 lists the semantic conditions for negative property assertions.
if  then 

⟨x,u⟩ ∈ IEXT(IS(owl:sourceIndividual)), ⟨x,p⟩ ∈ IEXT(IS(owl:assertionProperty)), ⟨x,w⟩ ∈ IEXT(IS(owl:targetIndividual)) 
x ∈
ICEXT(IS(owl:NegativePropertyAssertion)), ⟨u,w⟩ ∉ IEXT(p) 
⟨x,u⟩ ∈ IEXT(IS(owl:sourceIndividual)), ⟨x,p⟩ ∈ IEXT(IS(owl:assertionProperty)), ⟨x,w⟩ ∈ IEXT(IS(owl:targetValue)) 
x ∈
ICEXT(IS(owl:NegativePropertyAssertion)), p ∈ IODP, ⟨u,w⟩ ∉ IEXT(p) 
if  then exists x ∈ IR 
u ∈ IR, p ∈ IP, w ∈ IR, ⟨u,w⟩ ∉ IEXT(p) 
⟨x,u⟩ ∈ IEXT(IS(owl:sourceIndividual)), ⟨x,p⟩ ∈ IEXT(IS(owl:assertionProperty)), ⟨x,w⟩ ∈ IEXT(IS(owl:targetIndividual)) 
u ∈ IR, p ∈ IODP, w ∈ LV, ⟨u,w⟩ ∉ IEXT(p) 
⟨x,u⟩ ∈ IEXT(IS(owl:sourceIndividual)), ⟨x,p⟩ ∈ IEXT(IS(owl:assertionProperty)), ⟨x,w⟩ ∈ IEXT(IS(owl:targetValue)) 
Table 4.17 lists the semantic conditions for the OWL vocabulary used for some axiom annotations and for annotations on annotations. Both these kinds of annotations employ a reified version of a triple representing either the annotated axiom or the annotated annotation. The semantic conditions below recover the triple itself from the reified version.
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) 
Every wellformed RDF graph is a syntactically valid OWL 2 Full ontology, and its semantic meaning is given by the OWL 2 Full semantics.
If an OWL 2 Full ontology imports other OWL 2 Full ontologies, then one should 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.
This section is concerned with a strong relationship that holds between the RDFBased 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 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
G_{1} := {
ex:C rdf:type owl:Class .
ex:D rdf:type owl:Class .
ex:C rdfs:subClassOf ex:D .
}
entails the RDF graph
G_{2} := {
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 G_{1} in a way such that the set theoretical relationship
ICEXT(IS(ex:C)) ∩ ICEXT(IS(ex:D)) ⊆ ICEXT(IS(ex:D))
can be concluded. But since OWL 2 Full distinguishes between classes and their class extensions, G_{2} is not entailed, unless there exists some additional "helper" individual, which has the set
ICEXT(IS(ex:C)) ∩ ICEXT(IS(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 G_{2}.
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 4, and therefore do not need to be met by an OWL 2 Full interpretation as defined in Section 3. 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 x_{1},…, x_{n} ∈ IR 

u_{1},…, u_{n} ∈ IR  ⟨x_{1},u_{1}⟩ ∈
IEXT(IS(rdf:first)), ⟨x_{1},x_{2}⟩ ∈
IEXT(IS(rdf:rest)), …, ⟨x_{n},u_{n}⟩ ∈ IEXT(IS(rdf:first)), ⟨x_{n},IS(rdf:nil)⟩ ∈ IEXT(IS(rdf:rest)) 
Table 6.2 lists the comprehension principles for boolean combinations, 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⟩ ∈ IEXT(IS(owl:complementOf)) 
c ∈ IDC  ⟨x,c⟩ ∈ IEXT(IS(owl:datatypeComplementOf)) 
l sequence of c_{1},…, c_{n} ∈ IC  ⟨x,l⟩ ∈ IEXT(IS(owl:unionOf)) 
l sequence of c_{1},…, c_{n} ∈ IC  ⟨x,l⟩ ∈ IEXT(IS(owl:intersectionOf)) 
Table 6.3 lists the comprehension principle for enumerations, which provides the existence of classes representing each finite set of individuals.
if  then exists x ∈ IR 

l sequence of u_{1},…, u_{n} ∈ IR  ⟨x,l⟩ ∈ IEXT(IS(owl:oneOf)) 
Table 6.4 lists the comprehension principles for 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 ∈ ICEXT(IS(owl:SelfRestriction)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
c ∈ IC, p ∈ IP 
⟨x,c⟩ ∈ IEXT(IS(owl:allValuesFrom)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
c ∈ IDC, l sequence of p_{1},…, p_{n} ∈ IODP 
⟨x,c⟩ ∈ IEXT(IS(owl:allValuesFrom)), ⟨x,l⟩ ∈ IEXT(IS(owl:onProperties)) 
c ∈ IC, p ∈ IP 
⟨x,c⟩ ∈ IEXT(IS(owl:someValuesFrom)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
c ∈ IDC, l sequence of p_{1},…, p_{n} ∈ IODP 
⟨x,c⟩ ∈ IEXT(IS(owl:someValuesFrom)), ⟨x,l⟩ ∈ IEXT(IS(owl:onProperties)) 
u ∈ IR, p ∈ IP 
⟨x,u⟩ ∈ IEXT(IS(owl:hasValue)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, p ∈ IP 
⟨x,n⟩ ∈ IEXT(IS(owl:cardinality)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, p ∈ IP 
⟨x,n⟩ ∈ IEXT(IS(owl:minCardinality)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, p ∈ IP 
⟨x,n⟩ ∈ IEXT(IS(owl:maxCardinality)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, c ∈ IC, p ∈ IP 
⟨x,n⟩ ∈ IEXT(IS(owl:qualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onClass)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, c ∈ IDC, p ∈ IODP 
⟨x,n⟩ ∈ IEXT(IS(owl:qualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onDataRange)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, c ∈ IC, p ∈ IP 
⟨x,n⟩ ∈
IEXT(IS(owl:minQualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onClass)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, c ∈ IDC, p ∈ IODP 
⟨x,n⟩ ∈
IEXT(IS(owl:minQualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onDataRange)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, c ∈ IC, p ∈ IP 
⟨x,n⟩ ∈
IEXT(IS(owl:maxQualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onClass)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
n ∈ INNI, c ∈ IDC, p ∈ IODP 
⟨x,n⟩ ∈
IEXT(IS(owl:maxQualifiedCardinality)), ⟨x,c⟩ ∈ IEXT(IS(owl:onDataRange)), ⟨x,p⟩ ∈ IEXT(IS(owl:onProperty)) 
Table 6.5 lists the comprehension principle for datatype restrictions, which provides the existence of restrictions for each datatype, and for each combination of facets and values for which such a restriction is meaningful.
if  then exists x ∈ IR, l sequence of y_{1},…,y_{n} ∈ IR 

c ∈ IDC, f_{1},…,f_{n} facets, u_{1},…,u_{n} ∈ LV 
⟨x,c⟩ ∈ IEXT(IS(owl:onDatatype)), ⟨x,l⟩ ∈ IEXT(IS(owl:withRestrictions)), ⟨y_{1},u_{1}⟩ ∈ IEXT(f_{1}), …, ⟨y_{n},u_{n}⟩ ∈ IEXT(f_{n}) 
Theorem 6.1 (Correspondence Theorem): Let D be an OWL 2 Full datatype map, and let K and Q be collections of valid OWL 2 DL ontologies in RDF graph 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 which result from applying the Reverse RDF Mapping to K and Q, respectively. If F(K) OWL 2 DL entails F(Q) with respect to D, then K entails Q with respect to the OWL 2 Full semantics extended by the comprehension principles, and with respect to D.
Proof.
This section lists significant differences between OWL 2 Full and the original OWL Full.