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.
This document was updated since the version of 11 April 2008 in the following ways.
The OWL Working Group seeks public feedback on these Working Drafts. 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 
The purpose of an OWL 2 profile is to provide a trimmed down version of OWL 2 that trades expressive power for efficiency of reasoning. In logic, a profile is usually called a fragment or a sublanguage. This document describes three important profiles, each of which achieves efficiency in a different way and is useful in different application scenarios.
The choice of profile will depend on the structure of the ontologies used in the application and on the reasoning tasks to be performed, for example (ontology) consistency, (class) satisfiability, (class) subsumption, classification and conjunctive query answering. Precise definitions of these tasks can be found in Section 5.
OWL 2 profiles are defined by placing restrictions on the OWL 2 syntax. Syntactic restrictions can be specified by modifying the grammar of the functionalstyle syntax [OWL 2 Specification], and (possibly) giving additional global restrictions. In this document, the modified grammars are specified in two ways. In each profile definition, only the difference with respect to the full grammar is given; that is, only the productions that differ from the functionalstyle syntax are presented, while the productions that are the same as in the functionalstyle syntax are not repeated. In order to make this document selfcontained, the full grammar for each of the profiles is given in the Appendix.
An ontology in any profile can be written into a document by using any of the syntaxes of OWL 2.
Apart from the ones specified here, there are many other possible profiles of OWL 2 — there are, for example, a whole family of profiles that extend OWL 2 QL. Although we don't specifically document OWL lite [OWL 1 Reference] in this document, all OWL Lite ontologies are OWL 2 ontologies and so OWL Lite can be viewed as a profile of OWL 2. OWL 1 DL can also be viewed as a profile of OWL 2.
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 EL profile [EL++,EL++ Update] is designed as a subset of OWL 2 that
OWL 2 EL provides class constructors that are sufficient to express many complex ontologies, such as the biomedical ontology SNOMED CT [SNOMED CT].
OWL 2 EL places restrictions on the type of class restrictions that can be used in axioms. In particular, the following types of class restrictions are supported:
OWL 2 EL supports the following axioms, all of which are restricted to the allowed set of class expressions.
The following constructs are not supported in OWL 2 EL:
The following sections specify the structure of OWL 2 EL ontologies.
Entities are defined in OWL 2 EL in the same way as in the structural specification [OWL 2 Specification], and OWL 2 EL supports all predefined classes and properties. Furthermore, OWL 2 EL supports the following datatypes:
The set of supported datatypes has been designed such that the intersection of the value spaces of any set of these datatypes is finite, which is necessary to obtain the desired computational properties [EL++]. Consequently, the following datatypes MUST NOT be used in OWL 2 EL: owl:realPlus, xsd:double, xsd:float, xsd:nonPositiveInteger, xsd:positiveInteger, xsd:negativeInteger, xsd:long, xsd:int, xsd:short, xsd:byte, xsd:unsignedLong, xsd:unsignedInt, xsd:unsignedShort, xsd:unsignedByte, xsd:language, and xsd:boolean.
Inverse properties are not supported in OWL 2 EL, so object property expressions are restricted to named properties. Data property expressions are defined in the same way as in the structural specification [OWL 2 Specification].
ObjectPropertyExpression := ObjectProperty
In order to allow for efficient reasoning, OWL 2 EL restricts the set of supported class expressions to ObjectIntersectionOf, ObjectSomeValuesFrom, ObjectExistsSelf, ObjectHasValue, DataSomeValuesFrom, DataHasValue, and objectOneOf containing a single individual.
ClassExpression :=
Class 
ObjectIntersectionOf 
ObjectOneOf 
ObjectSomeValuesFrom  ObjectExistsSelf  ObjectHasValue 
DataSomeValuesFrom  DataHasValue
The class expressions are as defined in the same way as in the structural specification [OWL 2 Specification], with the exception of the objectOneOf class expression, which in OWL 2 EL admits only a single individual.
ObjectOneOf := 'OneOf' '(' Individual ')'
A data range expression is restricted in OWL 2 EL to the predefined datatypes admitted in OWL 2 EL and to enumerated datatypes consisting of a single literal.
DataRange := Datatype  DataOneOf
DataOneOf := 'OneOf' '('
Literal ')'
The class axioms of OWL 2 EL are the same as in the structural specification [OWL 2 Specification], with the exception that DisjointUnion is disallowed. Different class axioms are defined in the same way as in the structural specification [OWL 2 Specification], with the difference that they use the new definition of ClassExpression.
ClassAxiom := SubClassOf  EquivalentClasses  DisjointClasses
OWL 2 EL supports the following object property axioms, which are defined in the same way as in the structural specification [OWL 2 Specification], with the difference that they use the new definition of ObjectPropertyExpression.
ObjectPropertyAxiom :=
EquivalentObjectProperties  SubObjectPropertyOf 
ObjectPropertyDomain  ObjectPropertyRange 
TransitiveObjectProperty  ReflexiveObjectProperty
OWL 2 EL provides the same axioms about data properties as the structural specification [OWL 2 Specification] apart from DisjointDataProperty.
DataPropertyAxiom :=
SubDataPropertyOf 
EquivalentDataProperties 
DataPropertyDomain 
DataPropertyRange 
FunctionalDataProperty
The assertions in OWL 2 EL, as well as all other axioms, are the same as in the structural specification [OWL 2 Specification], with the difference that class object property expressions are restricted as defined in the previous sections.
OWL 2 EL extends the global restrictions on axioms from Section 11 of the structural specification [OWL 2 Specification] with an additional condition [EL++ Update]. In order to define this condition, the following notion is used.
Let CE be a class expression. We say that Ax imposes a range restriction to CE on an object property OP_{1} if Ax contains the following axioms, where k ≥ 1 is an integer and OP_{i} are object properties:
The axiom closure Ax of an OWL 2 EL ontology MUST obey the restrictions described in Section 11 of the structural specification [OWL 2 Specification] and, in addition, if
then Ax MUST impose a range restriction to CE on OP_{n}.
This additional restriction is vacuously true for each SubObjectPropertyOf axiom in which in the first item of the previous definition does not contain a property chain. There are no additional restrictions for range restrictions on reflexive and transitive roles; that is, a range restriction can be placed on a reflexive and/or transitive role provided that it satisfies the aforementioned restriction.
The OWL 2 QL profile admits sound and complete reasoning in LOGSPACE with respect to the size of the data (assertions). OWL 2 QL includes many of the main features of conceptual models such as UML class diagrams and ER diagrams.
OWL 2 QL is based on the DLLite family of description logics. Several variants of DLLite have been described in the literature [DLLite]. OWL 2 QL is based on DLLite_{R} — an expressive DL containing the intersection of RDFS and OWL 2. DLLite_{R} does not require the unique name assumption (UNA), since making this assumption would have no impact on the semantic consequences of a DLLite_{R} ontology. More expressive variants of DLLite, such as DLLite_{A}, extend DLLite_{R} with functional properties, and these can also be extended with keys; however, for query answering to remain in LOGSPACE, these extensions require UNA and need to impose certain global restrictions on the interaction between properties used in different types of axiom. Basing OWL 2 QL on DLLite_{R} avoids practical problems involved in the explicit axiomatization of UNA. Other variants of DLLite can also be supported on top of OWL 2 QL, but may require additional restrictions on the structure of ontologies [DLLite].
OWL 2 QL is defined not only in terms of the set of supported constructs, but it also restricts the places in which these constructs are allowed to occur. The allowed usage of constructs in class expressions is summarized in Table 1.
Subclass Expressions  Superclass Expressions 

a class existential quantification (ObjectSomeValuesFrom)
where the class is limited to owl:Thing 
a class existential quantification to a class (ObjectSomeValuesFrom) negation (ObjectComplementOf) intersection (ObjectIntersectionOf) 
OWL 2 QL supports the following axioms, constrained so as to be compliant with the mentioned restrictions on class expressions:
The following constructs are not supported in OWL 2 QL:
The productions for OWL 2 QL are defined in the following sections. Note that each OWL 2 QL ontology must satisfy the global restrictions on axioms defined in Section 11 of the structural specification [OWL 2 Specification].
Entities are defined in OWL 2 QL in the same way as in the structural specification [OWL 2 Specification], and OWL 2 QL supports all predefined classes and properties. Furthermore, OWL 2 QL supports the following datatypes:
The set of supported datatypes has been designed such that the intersection of the value spaces of any set of these datatypes is finite, which is necessary to obtain the desired computational properties. Consequently, the following datatypes MUST NOT be used in OWL 2 QL: owl:realPlus, xsd:double, xsd:float, xsd:nonPositiveInteger, xsd:positiveInteger, xsd:negativeInteger, xsd:long, xsd:int, xsd:short, xsd:byte, xsd:unsignedLong, xsd:unsignedInt, xsd:unsignedShort, xsd:unsignedByte, xsd:language, and xsd:boolean.
OWL 2 QL object and data property expressions are the same as in the structural specification [OWL 2 Specification].
In OWL 2 QL, there are two types of class expressions. The subClassExpression production defines the class expressions that can occur as subclass expressions in SubClassOf axioms, and the superClassExpression production defines the classes that can occur as superclass expressions in SubClassOf axioms.
subClassExpression :=
Class 
'SomeValuesFrom' '(' ObjectPropertyExpression owl:Thing
')'
superClassExpression :=
Class 
'SomeValuesFrom' '(' ObjectPropertyExpression Class ')'
'ComplementOf' '(' subClassExpression ')' 
'IntersectionOf' '(' superClassExpression superClassExpression { superClassExpression } ')'
A data range expression is restricted in OWL 2 QL to the predefined datatypes.
DataRange := Datatype
The class axioms of OWL 2 QL are the same as in the structural specification [OWL 2 Specification], with the exception that DisjointUnion is disallowed; however, all axioms that refer to the ClassExpression production are redefined so as to use subClassExpression and/or superClassExpression as appropriate.
SubClassOf := 'SubClassOf'
'(' { annotation } subClassExpression superClassExpression ')'
EquivalentClasses :=
'EquivalentClasses' '(' { annotation } subClassExpression subClassExpression { subClassExpression } ')'
DisjointClasses :=
'DisjointClasses' '(' { annotation
} subClassExpression subClassExpression { subClassExpression } ')'
ClassAxiom := SubClassOf  EquivalentClasses  DisjointClasses
OWL 2 QL disallows the use of property chains in property inclusion axioms; however, simple property inclusions are supported. Furthermore, OWL 2 QL disallows the use of functional, transitive, asymmetric, reflexive and irreflexive object properties, and it restricts the class expressions in object property domain and range axioms to superClassExpression.
ObjectPropertyDomain :=
'PropertyDomain' '(' { annotation
} ObjectPropertyExpression
superClassExpression ')'
ObjectPropertyRange :=
'PropertyRange' '(' { annotation }
ObjectPropertyExpression
superClassExpression ')'
SubObjectPropertyOf :=
'SubPropertyOf' '(' { annotation }
ObjectPropertyExpression
ObjectPropertyExpression ')'
ObjectPropertyAxiom :=
SubObjectPropertyOf  EquivalentObjectProperties 
DisjointObjectProperties  InverseObjectProperties 
ObjectPropertyDomain  ObjectPropertyRange 
SymmetricObjectProperty
OWL 2 QL disallows functional data property axioms, and it restricts the class expressions in data property domain axioms to superClassExpression.
DataPropertyDomain :=
'PropertyDomain' '(' { annotation
} DataPropertyExpression
superClassExpression ')'
DataPropertyAxiom :=
SubDataPropertyOf  EquivalentDataProperties  DisjointDataProperties 
DataPropertyDomain  DataPropertyRange
OWL 2 QL disallows negative object property assertions and equality axioms. Furthermore, class assertions in OWL 2 QL can involve only atomic classes. Inequality axioms and property assertions are the same as in the structural specification [OWL 2 Specification].
ClassAssertion :=
'ClassAssertion' '(' { annotation
} Class Individual ')'
Assertion := DifferentIndividuals  ClassAssertion  ObjectPropertyAssertion  DataPropertyAssertion
Finally, the axioms in OWL 2 QL are the same as those in the structural specification [OWL 2 Specification], with the exception that keys are not allowed.
Axiom := Declaration  ClassAxiom  ObjectPropertyAxiom  DataPropertyAxiom  Assertion  EntityAnnotation  AnonymousIndividualAnnotation
The OWL 2 RL profile is aimed at applications that require scalable reasoning without sacrificing too much expressive power. It is designed to accommodate both OWL 2 applications that can trade the full expressivity of the language for efficiency, and RDF(S) applications that need some added expressivity from OWL 2. This is achieved by defining a syntactic subset of OWL 2 which is amenable to implementation using rulebased technologies (see Section 4.2), and presenting a partial axiomatization of the OWL 2 RDFBased Semantics in the form of firstorder implications that can be used as the basis for such an implementation (see Section 4.3). The design of OWL 2 RL has been inspired by Description Logic Programs [DLP] and pD* [pD*].
For ontologies satisfying the syntactic constraints described in Section 4.2, a suitable rulebased implementation will have desirable computational properties; for example, it can return all and only the correct answers to certain kinds of query (see Section 4.3 and [Conformance]. Such an implementation can also be used with arbitrary RDF graphs. In this case, however, these properties no longer hold — in particular, it is no longer possible to guarantee that all correct answers can be returned.
Restricting the way in which constructs are used makes it possible to implement reasoning systems using rulebased reasoning engines, while still providing desirable computational guarantees. These restrictions are designed so as to avoid the need to infer the existence of individuals not explicitly present in the knowledge base, and to avoid the need for nondeterministic reasoning. This is achieved by restricting the use of constructs to certain syntactic positions. For example in SubClassOf axioms, the constructs in the subclass and superclass expressions must follow the usage patterns shown in Table 2.
Subclass Expressions  Superclass Expressions 

a class a nominal class (OneOf) intersection of class expressions (ObjectIntersectionOf) union of class expressions (ObjectUnionOf) existential quantification to a class expressions (ObjectSomeValuesFrom) existential quantification to an individual (ObjectHasValue) 
a class intersection of classes (ObjectIntersectionOf) universal quantification to a class expressions (ObjectAllValuesFrom) atmost 1 cardinality restrictions (ObjectMaxCardinality 1) existential quantification to an individual (ObjectHasValue) 
All axioms in OWL 2 RL are constrained in a way that is compliant with these restrictions. Thus, OWL 2 RL supports all axioms of OWL 2 apart from disjoint unions of classes (DisjointUnion), reflexive object property axioms (ReflexiveObjectProperty), and negative object and data property assertions (NegativeObjectPropertyAssertion and NegativeDataPropertyAssertion).
Implementations based on the partial axiomatization (presented in Section 4.3) can also be used with arbitrary RDF graphs, but in this case it is no longer possible to provide the above mentioned computational guarantees. Such implementations will, however, still produce only correct entailments (see [Conformance]).
The productions for OWL 2 RL are defined in the following sections. OWL 2 RL is defined not only in terms of the set of supported constructs, but it also restricts the places in which these constructs can be used. Note that each OWL 2 RL ontology must satisfy the global restrictions on axioms defined in Section 11 of the structural specification [OWL 2 Specification].
Entities are defined in OWL 2 RL in the same way as in the structural specification [OWL 2 Specification], and OWL 2 RL supports the owl:Thing and owl:Nothing predefined classes; however, it does not support the predefined object and data properties owl:TopObjectProperty, owl:BottomObjectProperty, owl:TopDataProperty, and owl:BottomDataProperty. Finally, OWL 2 RL supports the following datatypes:
The set of supported datatypes has been designed such that the intersection of the value spaces of any set of these datatypes is finite, which is necessary to obtain the desired computational properties. Consequently, the following datatypes MUST NOT be used in OWL 2 RL: owl:realPlus, xsd:double, xsd:float, xsd:nonPositiveInteger, xsd:positiveInteger, xsd:negativeInteger, xsd:long, xsd:int, xsd:short, xsd:byte, xsd:unsignedLong, xsd:unsignedInt, xsd:unsignedShort, xsd:unsignedByte, xsd:language, and xsd:boolean.
Property expressions in OWL 2 RL are identical to the property expressions in the structural specification [OWL 2 Specification].
There are three types of class expressions in OWL 2 RL. The subClassExpression production defines the class expressions that can occur as subclass expressions in SubClassOf axioms; the superClassExpression production defines the classes that can occur as superclass expressions in SubClassOf axioms; and the equivClassExpressions production defines the classes that can occur in EquivalentClasses axioms.
zeroOrOne := '0' 
'1'
subClassExpression :=
Class other
than owl:Thing 
'OneOf' '(' Individual { Individual } ')'
'IntersectionOf' '(' subClassExpression subClassExpression { subClassExpression } ')' 
'UnionOf' '(' subClassExpression subClassExpression { subClassExpression } ')' 
'SomeValuesFrom' '(' ObjectPropertyExpression subClassExpression ')' 
'SomeValuesFrom' '(' DataPropertyExpression { DataPropertyExpression } DataRange ')' 
'HasValue' '(' ObjectPropertyExpression Individual ')' 
'HasValue' '(' DataPropertyExpression Literal ')'
superClassExpression :=
Class 
'IntersectionOf' '(' superClassExpression superClassExpression { superClassExpression } ')' 
'AllValuesFrom' '(' ObjectPropertyExpression superClassExpression ')' 
'AllValuesFrom' '(' DataPropertyExpression { DataPropertyExpression } DataRange ')' 
'MaxCardinality' '(' zeroOrOne ObjectPropertyExpression [ subClassExpression ] ')' 
'MaxCardinality' '(' zeroOrOne DataPropertyExpression [ DataRange ] ')' 
'HasValue' '(' ObjectPropertyExpression Individual ')' 
'HasValue' '(' DataPropertyExpression Literal ')'
equivClassExpression :=
Class other
than owl:Thing 
'IntersectionOf' '(' equivClassExpression equivClassExpression { equivClassExpression } ')' 
'HasValue' '(' ObjectPropertyExpression Individual ')' 
'HasValue' '(' DataPropertyExpression Literal ')'
A data range expression is restricted in OWL 2 RL to the predefined datatypes admitted in OWL 2 RL.
DataRange := Datatype
OWL 2 RL redefines all axioms of the structural specification [OWL 2 Specification] that refer to class expressions. In particular, it restricts various class axioms to use the appropriate form of class expressions (i.e., one of subClassExpression, superClassExpression, or equivClassExpression), and it disallows the DisjointUnion axiom.
ClassAxiom := SubClassOf  EquivalentClasses  DisjointClasses
SubClassOf := 'SubClassOf'
'(' { annotation } subClassExpression superClassExpression ')'
EquivalentClasses :=
'EquivalentClasses' '(' { annotation } equivClassExpression equivClassExpression { equivClassExpression } ')'
DisjointClasses :=
'DisjointClasses' '(' { annotation
} subClassExpression subClassExpression { subClassExpression } ')'
OWL 2 RL axioms about property expressions are as in the structural specification [OWL 2 Specification], the only difference being that class expressions in property domain and range axioms are restricted to superClassExpression.
ObjectPropertyDomain :=
'PropertyDomain' '(' { annotation
} ObjectPropertyExpression
superClassExpression ')'
ObjectPropertyRange :=
'PropertyRange' '(' { annotation }
ObjectPropertyExpression
superClassExpression ')'
DataPropertyDomain :=
'PropertyDomain' '(' { annotation
} DataPropertyExpression
superClassExpression ')'
OWL 2 RL restricts class expressions in positive assertions to superClassExpression, and it disallows negative property assertions. Equality and inequality between individuals and positive assertions are the same as in the structural specification [OWL 2 Specification].
ClassAssertion :=
'ClassAssertion' '(' { annotation
} Individual superClassExpression ')'
Assertion := SameIndividual  DifferentIndividuals  ClassAssertion  ObjectPropertyAssertion  DataPropertyAssertion
OWL 2 RL restricts class expressions in keys to subClassExpression.
HasKey := 'HasKey' '(' { annotation } subClassExpression ObjectPropertyExpression  DataPropertyExpression { ObjectPropertyExpression  DataPropertyExpression } ')'
Axioms about properties are redefined in OWL 2 RL to disallow the reflexive properties.
ObjectPropertyAxiom :=
SubObjectPropertyOf  EquivalentObjectProperties 
DisjointObjectProperties  InverseObjectProperties 
ObjectPropertyDomain  ObjectPropertyRange 
FunctionalObjectProperty  InverseFunctionalObjectProperty 
IrreflexiveObjectProperty 
SymmetricObjectProperty  AsymmetricObjectProperty
TransitiveObjectProperty
All other axioms in OWL 2 RL are defined as in the structural specification [OWL 2 Specification].
This section presents a partial axiomatization of the OWL 2 RDFBased Semantics in the form of firstorder (material) implications; we will call this axiomatization the OWL 2 RL/RDF rules. These rules provide a useful starting point for practical implementation using rulebased technologies.
The rules are given as universally quantified firstorder implications over a ternary predicate T. This predicate represents a generalization of RDF triples in which bnodes and literals are allowed in all positions (similar to the partial generalization in pD* [pD*] and to generalized RDF triples in RIF [RIF]); thus, T(s, p, o) represents a generalized RDF triple with the subject s, predicate p, and the object o. Variables in the implications are preceded with a question mark. The propositional symbol false is a special symbol denoting contradiction: if it is derived, then the initial RDF graph was inconsistent.
Many conditions contain atoms that match to the list construct of RDF. In order to simplify the presentation of the rules, LIST[h, e_{1}, ..., e_{n}] is used as an abbreviation for the conjunction of triples shown in Table 3, where z_{2}, ..., z_{n} are fresh variables that do not occur anywhere where the abbreviation is used.
T(h, rdf:first, e_{1})  T(h, rdf:rest, z_{2}) 
T(z_{2}, rdf:first, e_{2})  T(z_{2}, rdf:rest, z_{3}) 
...  ... 
T(z_{n}, rdf:first, e_{n})  T(z_{n}, rdf:rest, rdf:nil) 
The axiomatization is split into several tables for easier navigation. Table 4 axiomatizes the semantics of equality. In particular, it defines the equality relation on resources owl:sameAs as being reflexive, symmetric, and transitive, and it axiomatizes the standard replacement properties of equality for it.
If  then  

T(?s, ?p, ?o) 
T(?s, owl:sameAs, ?s) T(?p, owl:sameAs, ?p) T(?o, owl:sameAs, ?o) 

T(?x, owl:sameAs, ?y)  T(?y, owl:sameAs, ?x)  
T(?x, owl:sameAs, ?y) T(?y, owl:sameAs, ?z) 
T(?x, owl:sameAs, ?z)  
T(?s, owl:sameAs, ?s') T(?s, ?p, ?o) 
T(?s', ?p, ?o)  
T(?p, owl:sameAs, ?p') T(?s, ?p, ?o) 
T(?s, ?p', ?o)  
T(?o, owl:sameAs, ?o') T(?s, ?p, ?o) 
T(?s, ?p, ?o')  
T(?x, owl:sameAs, ?y) T(?x, owl:differentFrom, ?y) 
false  
T(?y_{i},
owl:sameAs, ?y_{j}) T(?x, rdf:type, owl:AllDifferent) LIST[?x, ?y_{1}, ..., ?y_{n}] 
false  for each 1 ≤ i < j ≤ n 
Table 5 specifies the semantic conditions on axioms about properties.
If  then  

T(?p, rdfs:domain, ?c) T(?x, ?p, ?y) 
T(?x, rdf:type, ?c)  
T(?p, rdfs:range, ?c) T(?x, ?p, ?y) 
T(?y, rdf:type, ?c)  
T(?p, rdf:type, owl:FunctionalProperty) T(?x, ?p, ?y_{1}) T(?x, ?p, ?y_{2}) 
T(?y_{1}, owl:sameAs, ?y_{2})  
T(?p, rdf:type,
owl:InverseFunctionalProperty) T(?x_{1}, ?p, ?y) T(?x_{2}, ?p, ?y) 
T(?x_{1}, owl:sameAs, ?x_{2})  
T(?p, rdf:type, owl:IrreflexiveProperty) T(?x, ?p, ?x) 
false  
T(?p, rdf:type, owl:SymmetricProperty) T(?x, ?p, ?y) 
T(?y, ?p, ?x)  
T(?p, rdf:type, owl:AsymmetricProperty) T(?x, ?p, ?y) T(?y, ?p, ?x) 
false  
T(?p, rdf:type, owl:TransitiveProperty) T(?x, ?p, ?y) T(?y, ?p, ?z) 
T(?x, ?p, ?z)  
T(?p_{1},
rdfs:subPropertyOf, ?p_{2}) T(?x, ?p_{1}, ?y) 
T(?x, ?p_{2}, ?y)  
T(?sc, owl:propertyChain, ?x) LIST[?x, ?p_{1}, ..., ?p_{n}] T(?sc, rdfs:subPropertyOf, ?p) T(?u_{1}, ?p_{1}, ?u_{2}) T(?u_{2}, ?p_{2}, ?u_{3}) ... T(?u_{n}, ?p_{n}, ?u_{n+1}) 
T(?u_{1}, ?p, ?u_{n+1})  
T(?p_{1},
owl:equivalentProperty, ?p_{2}) T(?x, ?p_{1}, ?y) 
T(?x, ?p_{2}, ?y)  
T(?p_{1},
owl:equivalentProperty, ?p_{2}) T(?x, ?p_{2}, ?y) 
T(?x, ?p_{1}, ?y)  
T(?p_{1},
owl:propertyDisjointWith, ?p_{2}) T(?x, ?p_{1}, ?y) T(?x, ?p_{2}, ?y) 
false  
T(?z, rdf:type, owl:AllDisjointProperties) LIST[?z, ?p_{1}, ..., ?p_{n}] T(?x, ?p_{i}, ?y) T(?x, ?p_{j}, ?y) 
false  for each 1 ≤ i < j ≤ n 
T(?p_{1},
owl:inverseOf, ?p_{2}) T(?x, ?p_{1}, ?y) 
T(?y, ?p_{2}, ?x)  
T(?p_{1},
owl:inverseOf, ?p_{2}) T(?x, ?p_{2}, ?y) 
T(?y, ?p_{1}, ?x)  
T(?c, owl:hasKey, ?u) LIST[?u, ?p_{1}, ..., ?p_{n}] T(?x, rdf:type, ?c) T(?x, ?p_{1}, ?z_{1}) ... T(?x, ?p_{n}, ?z_{n}) T(?y, rdf:type, ?c) T(?y, ?p_{1}, ?z_{1}) ... T(?y, ?p_{n}, ?z_{n}) 
T(?x, owl:sameAs, ?y) 
Table 6 specifies the semantic conditions on classes.
If  then  

T(?c, owl:intersectionOf, ?x) LIST[?x, ?c_{1}, ..., ?c_{n}] T(?y, rdf:type, ?c_{1}) T(?y, rdf:type, ?c_{2}) ... T(?y, rdf:type, ?c_{n}) 
T(?y, rdf:type, ?c)  
T(?c, owl:intersectionOf, ?x) LIST[?x, ?c_{1}, ..., ?c_{n}] T(?y, rdf:type, ?c) 
T(?y,
rdf:type, ?c_{1}) T(?y, rdf:type, ?c_{2}) ... T(?y, rdf:type, ?c_{n}) 

T(?c, owl:unionOf, ?x) LIST[?x, ?c_{1}, ..., ?c_{n}] T(?y, rdf:type, ?c_{i}) 
T(?y, rdf:type, ?c)  for each 1 ≤ i ≤ n 
T(?x, owl:someValuesFrom, ?y) T(?x, owl:onProperty, ?p) T(?u, ?p, ?v) T(?v, rdf:type, ?y) 
T(?u, rdf:type, ?x)  
T(?x, owl:allValuesFrom, ?y) T(?x, owl:onProperty, ?p) T(?u, rdf:type, ?x) T(?u, ?p, ?v) 
T(?v, rdf:type, ?y)  
T(?x, owl:hasValue, ?y) T(?x, owl:onProperty, ?p) T(?u, rdf:type, ?x) 
T(?u, ?p, ?y)  
T(?x, owl:hasValue, ?y) T(?x, owl:onProperty, ?p) T(?u, ?p, ?y) 
T(?u, rdf:type, ?x)  
T(?x, owl:maxCardinality,
"0"^^xsd:nonNegativeInteger) T(?x, owl:onProperty, ?p) T(?u, rdf:type, ?x) T(?u, ?p, ?y) 
false  
T(?x, owl:maxCardinality,
"1"^^xsd:nonNegativeInteger) T(?x, owl:onProperty, ?p) T(?u, rdf:type, ?x) T(?u, ?p, ?y_{1}) T(?u, ?p, ?y_{2}) 
T(?y_{1}, owl:sameAs, ?y_{2})  
T(?x, owl:maxQualifiedCardinality,
"0"^^xsd:nonNegativeInteger) T(?x, owl:onProperty, ?p) T(?x, owl:onClass, ?c) T(?u, rdf:type, ?x) T(?u, ?p, ?y) T(?y, rdf:type, ?c) 
false  
T(?x, owl:maxQualifiedCardinality,
"1"^^xsd:nonNegativeInteger) T(?x, owl:onProperty, ?p) T(?x, owl:onClass, ?c) T(?u, rdf:type, ?x) T(?u, ?p, ?y_{1}) T(?y_{1}, rdf:type, ?c) T(?u, ?p, ?y_{2}) T(?y_{2}, rdf:type, ?c) 
T(?y_{1}, owl:sameAs, ?y_{2})  
T(?c, owl:oneOf, ?x) LIST[?x, ?y_{1}, ..., ?y_{n}] 
T(?y_{i}, rdf:type, ?c)  for each 1 ≤ i ≤ n 
Table 7 specifies the semantic conditions on class axioms.
If  then  

T(?c_{1},
rdfs:subClassOf, ?c_{2}) T(?x, rdf:type, ?c_{1}) 
T(?x, rdf:type, ?c_{2})  
T(?c_{1},
owl:equivalentClass, ?c_{2}) T(?x, rdf:type, ?c_{1}) 
T(?x, rdf:type, ?c_{2})  
T(?c_{1},
owl:equivalentClass, ?c_{2}) T(?x, rdf:type, ?c_{2}) 
T(?x, rdf:type, ?c_{1})  
T(?c_{1},
owl:disjointWith, ?c_{2}) T(?x, rdf:type, ?c_{1}) T(?x, rdf:type, ?c_{2}) 
false  
T(?y, rdf:type, owl:AllDisjointClasses) LIST[?y, ?c_{1}, ..., ?c_{n}] T(?x, rdf:type, ?c_{i}) T(?x, rdf:type, ?c_{j}) 
false  for each 1 ≤ i < j ≤ n 
Table 8 specifies the semantics of datatype literals.
If  then  

true  T(lt, rdf:type, dt)  for each literal lt and each datatype
dt supported in OWL 2 RL such that the data value of lt is contained in the value space of dt 
true  T(lt_{1}, owl:sameAs, lt_{2})  for all literals lt_{1} and lt_{2} with the same data value 
true  T(lt_{1}, owl:differentFrom, lt_{2})  for all literals lt_{1} and lt_{2} with different data values 
T(lt, rdf:type, dt)  false  for each literal lt and each datatype
dt supported in OWL 2 RL such that the data value of lt is not contained in the value space of dt 
Table 9 specifies the semantic restrictions on the vocabulary used to define the schema.
If  then 

T(?c, rdf:type, owl:Class)  T(?c, rdfs:subClassOf, ?c) T(?c, owl:equivalentClass, ?c) 
T(?c_{1},
rdfs:subClassOf, ?c_{2}) T(?c_{2}, rdfs:subClassOf, ?c_{3}) 
T(?c_{1}, rdfs:subClassOf, ?c_{3}) 
T(?c_{1}, owl:equivalentClass, ?c_{2})  T(?c_{1},
rdfs:subClassOf, ?c_{2}) T(?c_{2}, rdfs:subClassOf, ?c_{1}) 
T(?p, rdf:type, owl:ObjectProperty)  T(?p, rdfs:subPropertyOf, ?p) T(?p, owl:equivalentProperty, ?p) 
T(?p, rdf:type, owl:DatatypeProperty)  T(?p, rdfs:subPropertyOf, ?p) T(?p, owl:equivalentProperty, ?p) 
T(?p_{1},
rdfs:subPropertyOf, ?p_{2}) T(?p_{2}, rdfs:subPropertyOf, ?p_{3}) 
T(?p_{1}, rdfs:subPropertyOf, ?p_{3}) 
T(?p_{1}, owl:equivalentProperty, ?p_{2})  T(?p_{1},
rdfs:subPropertyOf, ?p_{2}) T(?p_{2}, rdfs:subPropertyOf, ?p_{1}) 
T(?p, rdfs:domain, ?c_{1}) T(?c_{1}, rdfs:subClassOf, ?c_{2}) 
T(?p, rdfs:domain, ?c_{2}) 
T(?p_{2}, rdfs:domain, ?c) T(?p_{1}, rdfs:subPropertyOf, ?p_{2}) 
T(?p_{1}, rdfs:domain, ?c) 
T(?p, rdfs:range, ?c_{1}) T(?c_{1}, rdfs:subClassOf, ?c_{2}) 
T(?p, rdfs:range, ?c_{2}) 
T(?p_{2}, rdfs:range, ?c) T(?p_{1}, rdfs:subPropertyOf, ?p_{2}) 
T(?p_{1}, rdfs:range, ?c) 
T(?c_{1}, owl:hasValue, ?i) T(?c_{1}, owl:onProperty, ?p_{1}) T(?c_{2}, owl:hasValue, ?i) T(?c_{2}, owl:onProperty, ?p_{2}) T(?p_{1}, rdfs:subPropertyOf, ?p_{2}) 
T(?c_{1}, rdfs:subClassOf, ?c_{2}) 
T(?c_{1},
owl:someValuesFrom, ?y_{1}) T(?c_{1}, owl:onProperty, ?p) T(?c_{2}, owl:someValuesFrom, ?y_{2}) T(?c_{2}, owl:onProperty, ?p) T(?y_{1}, rdfs:subClassOf, ?y_{2}) 
T(?c_{1}, rdfs:subClassOf, ?c_{2}) 
T(?c_{1},
owl:someValuesFrom, ?y) T(?c_{1}, owl:onProperty, ?p_{1}) T(?c_{2}, owl:someValuesFrom, ?y) T(?c_{2}, owl:onProperty, ?p_{2}) T(?p_{1}, rdfs:subPropertyOf, ?p_{2}) 
T(?c_{1}, rdfs:subClassOf, ?c_{2}) 
T(?c_{1},
owl:allValuesFrom, ?y_{1}) T(?c_{1}, owl:onProperty, ?p) T(?c_{2}, owl:allValuesFrom, ?y_{2}) T(?c_{2}, owl:onProperty, ?p) T(?y_{1}, rdfs:subClassOf, ?y_{2}) 
T(?c_{1}, rdfs:subClassOf, ?c_{2}) 
T(?c_{1},
owl:allValuesFrom, ?y) T(?c_{1}, owl:onProperty, ?p_{1}) T(?c_{2}, owl:allValuesFrom, ?y) T(?c_{2}, owl:onProperty, ?p_{2}) T(?p_{1}, rdfs:subPropertyOf, ?p_{2}) 
T(?c_{2}, rdfs:subClassOf, ?c_{1}) 
T(?c, owl:intersectionOf, ?x) LIST[?x, ?c_{1}, ..., ?c_{n}] 
T(?c, rdfs:subClassOf, ?c_{1}) T(?c, rdfs:subClassOf, ?c_{2}) ... T(?c, rdfs:subClassOf, ?c_{n}) 
T(?c, owl:unionOf, ?x) LIST[?x, ?c_{1}, ..., ?c_{n}] 
T(?c_{1}, rdfs:subClassOf, ?c) T(?c_{2}, rdfs:subClassOf, ?c) ... T(?c_{n}, rdfs:subClassOf, ?c) 
OWL 2 RL/RDF rules include neither the axiomatic triples and entailment rules of RDF and RDFS [RDF Semantics] nor the axiomatic triples for the relevant OWL vocabulary [OWL 2 RDFBased Semantics], as these might cause performance problems in practice. An OWL 2 RL/RDF implementation MAY include these triples and entailment rules as necessary without invalidating the conformance requirements for OWL 2 RL [Conformance].
Theorem 1. Let R be the OWL 2 RL/RDF rules as defined above; and let O_{1} and O_{2} be OWL 2 RL ontologies in both of which no URI is used for more than one type of entity (i.e., no URIs is used both as, say, a class and an individual), and where all axioms in O_{2} are assertions of the following form with a, a_{1}, ..., a_{n} named individuals:
Furthermore, let RDF(O_{1}) and RDF(O_{2}) be translations of O_{1} and O_{2}, respetively, into RDF graphs as specified in the OWL 2 Mapping to RDF Graphs [OWL 2 RDF Mapping]; and let FO(RDF(O_{1})) and FO(RDF(O_{2})) be the translation of these graphs into firstorder theories in which triples are represented using the T predicate — that is, T(s, p, o) represents an RDF triple with the subject s, predicate p, and the object o. Then, O_{1} entails O_{2} under the OWL 2 RDFBased semantics [OWL 2 RDFBased Semantics] if and only if FO(RDF(O_{1})) ∪ R entails FO(RDF(O_{2})) under the standard firstorder semantics.
This section describes the computational complexity of the most relevant reasoning problems of the languages defined in this document. The reasoning problems considered here ontology consistency, class expression satisfiability, class expression subsumption, instance checking, and (Boolean) conjunctive query answering [OWL 2 Direct Semantics]. When evaluating complexity, the following parameters will be considered:
Table 10 summarizes the known complexity results for OWL 2 DL, OWL 1 DL, OWL 2 EL, OWL 2 QL, and OWL 2 RL. Whenever the complexity for a given problem is described as "Open", * denotes that the problem's decidability is still an open question; if * is omitted, then the problem is known to be decidable but precise complexity bounds have not yet been established.
Language  Reasoning Problems  Taxonomic Complexity  Data Complexity  Query Complexity  Combined Complexity 

OWL 2 DL  Ontology Consistency, Class Expression
Satisfiability, Class Expression Subsumption, Instance Checking 
2NEXPTIMEcomplete  Open (NPHard) 
Not Applicable  2NEXPTIMEcomplete 
Conjunctive Query Answering  Open*  Open*  Open*  Open*  
OWL 1 DL  Ontology Consistency, Class Expression
Satisfiability, Class Expression Subsumption, Instance Checking 
NEXPTIMEcomplete  Open (NPHard) 
Not Applicable  NEXPTIMEcomplete 
Conjunctive Query Answering  Open*  Open*  Open*  Open*  
OWL 2 EL  Ontology Consistency, Class Expression
Satisfiability, Class Expression Subsumption, Instance Checking 
PTIMEcomplete  PTIMEcomplete  Not Applicable  PTIMEcomplete 
Conjunctive Query Answering  PTIMEcomplete  PTIMEcomplete  NPcomplete  PSPACEcomplete  
OWL 2 QL  Ontology Consistency, Class Expression
Satisfiability, Class Expression Subsumption, Instance Checking, 
In PTIME  In LOGSPACE  Not Applicable  In PTIME 
Conjunctive Query Answering  In PTIME  In LOGSPACE  NPcomplete  NPcomplete  
OWL 2 RL  Ontology Consistency, Class Expression
Satisfiability, Class Expression Subsumption, Instance Checking 
PTIMEcomplete  PTIMEcomplete  Not Applicable  PTIMEcomplete 
Conjunctive Query Answering  PTIMEcomplete  PTIMEcomplete  NPcomplete  NPcomplete 