OWL 2 Web Ontology Language:
Profiles

W3C Working Draft 08 October 2008

This version:: http://www.w3.org/TR/2008/WD-owl2-profiles-20081008/
Latest version:: http://www.w3.org/TR/owl2-profiles/
Previous version:: http://www.w3.org/TR/2008/WD-owl2-profiles-20080411/

Editors:: Boris Motik, Oxford University; Bernardo Cuenca Grau, Oxford University; Ian Horrocks, Oxford University; Zhe Wu, Oracle; Achille Fokoue, IBM; Carsten Lutz, Dresden University of Technology
Contributors:: Diego Calvanese, Free University of Bolzano; Giuseppe De Giacomo, University of Rome “La Sapienza”; Bijan Parsia, The University of Manchester; Peter F. Patel-Schneider, Bell Labs Research, Alcatel-Lucent; Note: The complete list of contributors is being compiled and will be included in the next draft.

Abstract

OWL 2 extends the W3C OWL Web Ontology Language with a small but useful set of features that have been requested by users, for which effective reasoning algorithms are now available, and that OWL tool developers are willing to support. The new features include extra syntactic sugar, additional property and qualified cardinality constructors, extended datatype support, simple metamodelling, and extended annotations.
This document provides a specification of several profiles of OWL 2 which can be more simply and/or efficiently implemented. In logic, profiles are often called fragments. Most profiles are defined by placing restrictions on the syntax of OWL 2. These restrictions have been specified by modifying the productions of the functional-style syntax.

Status of this Document

May Be Superseded

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:

Compatibility with OWL 1

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.

Summary of Changes

This document was updated since the version of 11 April 2008 in the following ways.

The profiles were renamed into OWL 2 EL, OWL 2 QL, and OWL 2 RL.
The definition of each profile has been updated in accordance with the major changes of the structural specification.
A number of errors and omissions in all three profiles were corrected.
The OWL 2 RL profile has been substantially further developed.

Please Comment By 2008-10-23

The OWL Working Group seeks public feedback on these Working 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.

No Endorsement

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.

Patents

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.

1 Introduction

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 EL is particularly useful in applications employing ontologies that contain very large numbers of properties and/or classes: it captures the expressive power used by many such ontologies and is a subset of OWL 2 for which the basic reasoning problems can be performed in time that is polynomial with respect to the size of the ontology [EL++]. Dedicated reasoning algorithms for this profile are available and have been demonstrated to be implementable in a highly scalable way.
OWL 2 QL is aimed at applications that use very large volumes of instance data, and where query answering is the most important reasoning task. In OWL 2 QL, conjunctive query answering can be implemented using conventional relational database systems, and can directly access data stored in such systems. Using this technique, sound and complete query answering can be performed in LOGSPACE with respect to the size of the data (assertions). As in OWL 2 EL, there are polynomial time algorithms for consistency, subsumption, and classification reasoning. The expressive power of the profile is necessarily quite limited, although it does include most of the main features of conceptual models such as UML class diagrams and ER diagrams.
OWL 2 RL 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. OWL 2 RL reasoning systems can be implemented using rule-based reasoning engines. Such rule-based approaches can be used to perform consistency, satisfiability, subsumption, classification, instance checking, and conjunctive query answering in time that is polynomial with respect to the size of the ontology.

OWL 2 profiles are defined by placing restrictions on the OWL 2 syntax. Syntactic restrictions can be specified by modifying the grammar of the functional-style 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 functional-style syntax are presented, while the productions that are the same as in the functional-style syntax are not repeated. In order to make this document self-contained, 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].

2 OWL 2 EL

The OWL 2 EL profile [EL++,EL++ Update] is designed as a subset of OWL 2 that

captures the expressive power used by many large-scale ontologies and
for which the following reasoning problems can be decided in polynomial time: satisfiability, subsumption, classification, and instance checking.

OWL 2 EL provides class constructors that are sufficient to express many complex ontologies, such as the biomedical ontology SNOMED CT [SNOMED CT].

2.1 Feature Overview

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:

existential quantification to a class expression (ObjectSomeValuesFrom) or a data range (DataSomeValuesFrom)
existential quantification to an individual (ObjectHasValue) or a literal (DataHasValue)
self-restriction (ObjectExistsSelf)
enumerations involving a single individual (ObjectOneOf) or a single literal (DataOneOf)
intersection of classes (ObjectIntersectionOf)

OWL 2 EL supports the following axioms, all of which are restricted to the allowed set of class expressions.

class inclusion (SubClassOf)
class equivalence (EquivalentClasses)
class disjointness (DisjointClasses)
object property inclusion (SubObjectPropertyOf) with or without property chains, and data property inclusion (SubDataPropertyOf)
property equivalence (EquivalentObjectProperties and EquivalentDataProperties),
transitive object properties (TransitiveObjectProperty)
reflexive object properties (ReflexiveObjectProperty)
domain restrictions (ObjectPropertyDomain and DataPropertyDomain)
range restrictions (ObjectPropertyRange and DataPropertyRange)
assertions (SameIndividual, DifferentIndividuals, ClassAssertion, ObjectPropertyAssertion, DataPropertyAssertion, NegativeObjectPropertyAssertion, and NegativeDataPropertyAssertion)
functional data properties (FunctionalDataProperty)
keys (HasKey)

The following constructs are not supported in OWL 2 EL:

universal quantification to a class expression (ObjectAllValuesFrom) or a data range (DatAllaValuesFrom)
cardinality restrictions (ObjectMaxCardinality, ObjectMinCardinality, ObjectExactCardinality, DataMaxCardinality, DataMinCardinality, and DataExactCardinality)
disjunction (ObjectUnionOf and DisjointUnion)
class negation (ObjectComplementOf)
enumerations involving more than one individual (ObjectOneOf and DataOneOf)
disjoint properties (DisjointObjectProperties and DisjointDataProperties)
irreflexive object properties (IrreflexiveObjectProperty)
inverse object properties (InverseObjectProperties)
functional and inverse-functional object properties (FunctionalObjectProperty and InverseFunctionalObjectProperty)
symmetric object properties (SymmetricObjectProperty)
asymmetric object properties (AsymmetricObjectProperty)

2.2 Profile Specification

The following sections specify the structure of OWL 2 EL ontologies.

2.2.1 Entities

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:

rdf:text
rdfs:Literal
owl:real
xsd:decimal
xsd:integer
xsd:nonNegativeInteger
xsd:string
xsd:normalizedString
xsd:token
xsd:Name
xsd:NCName
xsd:NMTOKEN
xsd:ID
xsd:IDREF
xsd:ENTITY
xsd:hexBinary
xsd:base64Binary
xsd:anyURI
owl:dateTime

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.

2.2.2 Property Expressions

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

2.2.3 Class Expressions

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.

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 ')'

2.2.4 Data Ranges

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 ')'

2.2.5 Axioms

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.

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.

2.2.6 Global Restrictions

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₁ if Ax contains the following axioms, where k ≥ 1 is an integer and OP_i are object properties:

SubPropertyOf( OP₁ OP₂)
...
SubPropertyOf( OP_k-1 OP_k )
PropertyRange( OP_k CE )

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

Ax contains SubPropertyOf( PropertyChain( OP₁ ... OP_n ) OP ) and
Ax imposes a range restriction to some class expression CE on OP

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 afore-mentioned restriction.

3 OWL 2 QL

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 DL-Lite family of description logics. Several variants of DL-Lite have been described in the literature [DL-Lite]. OWL 2 QL is based on DL-Lite_R — an expressive DL containing the intersection of RDFS and OWL 2. DL-Lite_R does not require the unique name assumption (UNA), since making this assumption would have no impact on the semantic consequences of a DL-Lite_R ontology. More expressive variants of DL-Lite, such as DL-Lite_A, extend DL-Lite_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 DL-Lite_R avoids practical problems involved in the explicit axiomatization of UNA. Other variants of DL-Lite can also be supported on top of OWL 2 QL, but may require additional restrictions on the structure of ontologies [DL-Lite].

3.1 Feature Overview

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.

Table 1. Syntactic Restrictions on Class Expressions in OWL 2 QL
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:

subclass axioms (SubClassOf)
class expression equivalence (EquivalentClasses)
class expression disjointness (DisjointClasses)
inverse object properties (InverseObjectProperties)
property inclusion (SubObjectPropertyOf not involving property chains and SubDataPropertyOf)
property equivalence (EquivalentObjectProperties and EquivalentDataProperties)
property domain (ObjectPropertyDomain and DataPropertyDomain)
property range (ObjectPropertyRange and DataPropertyRange)
disjoint properties (DisjointObjectProperties and DisjointDataProperties)
symmetric properties (SymmetricObjectProperty)
assertions other than the equality assertions (DifferentIndividuals, ClassAssertion, ObjectPropertyAssertion, and DataPropertyAssertion)

The following constructs are not supported in OWL 2 QL:

existential quantification to a class expression or a data range (ObjectSomeValuesFrom and DataSomeValuesFrom in the subclass position)
self-restriction (ObjectExistsSelf)
existential quantification to an individual or a literal (ObjectHasValue, DataHasValue)
nominals (ObjectOneOf, DataOneOf)
universal quantification to a class expression or a data range (ObjectAllValuesFrom, DataAllValuesFrom)
cardinality restrictions (ObjectMaxCardinality, ObjectMinCardinality, ObjectExactCardinality, DataMaxCardinality, DataMinCardinality, DataExactCardinality)
disjunction (ObjectUnionOf, DisjointUnion)
property inclusions (SubObjectPropertyOf involving property chains)
functional and inverse-functional properties (FunctionalObjectProperty, InverseFunctionalObjectProperty, and FunctionalDataProperty)
transitive properties (TransitiveObjectProperty)
reflexive properties (ReflexiveObjectProperty)
irreflexive properties (IrreflexiveObjectProperty)
asymmetric properties (AsymmetricObjectProperty)
keys (HasKey)

3.2 Profile Specification

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].

3.2.1 Entities

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:

rdf:text
rdfs:Literal
owl:real
xsd:decimal
xsd:integer
xsd:nonNegativeInteger
xsd:string
xsd:normalizedString
xsd:token
xsd:Name
xsd:NCName
xsd:NMTOKEN
xsd:ID
xsd:IDREF
xsd:ENTITY
xsd:hexBinary
xsd:base64Binary
xsd:anyURI
owl:dateTime

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.

3.2.2 Property Expressions

OWL 2 QL object and data property expressions are the same as in the structural specification [OWL 2 Specification].

3.2.3 Class Expressions

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 } ')'

3.2.4 Data Ranges

A data range expression is restricted in OWL 2 QL to the predefined datatypes.

DataRange := Datatype

3.2.5 Axioms

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.

4 OWL 2 RL

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 rule-based technologies (see Section 4.2), and presenting a partial axiomatization of the OWL 2 RDF-Based Semantics in the form of first-order 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 rule-based 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.

4.1 Feature Overview

Restricting the way in which constructs are used makes it possible to implement reasoning systems using rule-based 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.

Table 2. Syntactic Restrictions on Class Expressions in OWL 2 RL
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) at-most 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]).

4.2 Profile Specification

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].

4.2.1 Entities

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:

rdf:text
rdfs:Literal
owl:real
xsd:decimal
xsd:integer
xsd:nonNegativeInteger
xsd:string
xsd:normalizedString
xsd:token
xsd:Name
xsd:NCName
xsd:NMTOKEN
xsd:ID
xsd:IDREF
xsd:ENTITY
xsd:hexBinary
xsd:base64Binary
xsd:anyURI
owl:dateTime

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.

4.2.2 Property Expressions

Property expressions in OWL 2 RL are identical to the property expressions in the structural specification [OWL 2 Specification].

4.2.3 Class Expressions

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 ')'

4.2.4 Data Ranges

A data range expression is restricted in OWL 2 RL to the predefined datatypes admitted in OWL 2 RL.

DataRange := Datatype

4.2.5 Axioms

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.

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.

All other axioms in OWL 2 RL are defined as in the structural specification [OWL 2 Specification].

4.3 Reasoning in OWL 2 RL and RDF Graphs using Rules

This section presents a partial axiomatization of the OWL 2 RDF-Based Semantics in the form of first-order (material) implications; we will call this axiomatization the OWL 2 RL/RDF rules. These rules provide a useful starting point for practical implementation using rule-based technologies.

The rules are given as universally quantified first-order 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₁, ..., e_n] is used as an abbreviation for the conjunction of triples shown in Table 3, where z₂, ..., z_n are fresh variables that do not occur anywhere where the abbreviation is used.

Table 3. Expansion of LIST[h, e₁, ..., e_n]
T(h, rdf:first, e₁)	T(h, rdf:rest, z₂)
T(z₂, rdf:first, e₂)	T(z₂, rdf:rest, z₃)
...	...
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.

Editor's Note: When the rule set is finalized, rows in the tables will be numbered/named and given HTML anchors.

Table 4. The Semantics of Equality
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₁, ..., ?y_n]	false	for each 1 ≤ i < j ≤ n

Table 5 specifies the semantic conditions on axioms about properties.

Table 5. The Semantics of 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₁) T(?x, ?p, ?y₂)	T(?y₁, owl:sameAs, ?y₂)
T(?p, rdf:type, owl:InverseFunctionalProperty) T(?x₁, ?p, ?y) T(?x₂, ?p, ?y)	T(?x₁, owl:sameAs, ?x₂)
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₁, rdfs:subPropertyOf, ?p₂) T(?x, ?p₁, ?y)	T(?x, ?p₂, ?y)
T(?sc, owl:propertyChain, ?x) LIST[?x, ?p₁, ..., ?p_n] T(?sc, rdfs:subPropertyOf, ?p) T(?u₁, ?p₁, ?u₂) T(?u₂, ?p₂, ?u₃) ... T(?u_n, ?p_n, ?u_n+1)	T(?u₁, ?p, ?u_n+1)
T(?p₁, owl:equivalentProperty, ?p₂) T(?x, ?p₁, ?y)	T(?x, ?p₂, ?y)
T(?p₁, owl:equivalentProperty, ?p₂) T(?x, ?p₂, ?y)	T(?x, ?p₁, ?y)
T(?p₁, owl:propertyDisjointWith, ?p₂) T(?x, ?p₁, ?y) T(?x, ?p₂, ?y)	false
T(?z, rdf:type, owl:AllDisjointProperties) LIST[?z, ?p₁, ..., ?p_n] T(?x, ?p_i, ?y) T(?x, ?p_j, ?y)	false	for each 1 ≤ i < j ≤ n
T(?p₁, owl:inverseOf, ?p₂) T(?x, ?p₁, ?y)	T(?y, ?p₂, ?x)
T(?p₁, owl:inverseOf, ?p₂) T(?x, ?p₂, ?y)	T(?y, ?p₁, ?x)
T(?c, owl:hasKey, ?u) LIST[?u, ?p₁, ..., ?p_n] T(?x, rdf:type, ?c) T(?x, ?p₁, ?z₁) ... T(?x, ?p_n, ?z_n) T(?y, rdf:type, ?c) T(?y, ?p₁, ?z₁) ... T(?y, ?p_n, ?z_n)	T(?x, owl:sameAs, ?y)

Table 6 specifies the semantic conditions on classes.

Table 6. The Semantics of Classes
If	then
T(?c, owl:intersectionOf, ?x) LIST[?x, ?c₁, ..., ?c_n] T(?y, rdf:type, ?c₁) T(?y, rdf:type, ?c₂) ... T(?y, rdf:type, ?c_n)	T(?y, rdf:type, ?c)
T(?c, owl:intersectionOf, ?x) LIST[?x, ?c₁, ..., ?c_n] T(?y, rdf:type, ?c)	T(?y, rdf:type, ?c₁) T(?y, rdf:type, ?c₂) ... T(?y, rdf:type, ?c_n)
T(?c, owl:unionOf, ?x) LIST[?x, ?c₁, ..., ?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₁) T(?u, ?p, ?y₂)	T(?y₁, owl:sameAs, ?y₂)
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₁) T(?y₁, rdf:type, ?c) T(?u, ?p, ?y₂) T(?y₂, rdf:type, ?c)	T(?y₁, owl:sameAs, ?y₂)
T(?c, owl:oneOf, ?x) LIST[?x, ?y₁, ..., ?y_n]	T(?y_i, rdf:type, ?c)	for each 1 ≤ i ≤ n

Table 7 specifies the semantic conditions on class axioms.

Table 7. The Semantics of Class Axioms
If	then
T(?c₁, rdfs:subClassOf, ?c₂) T(?x, rdf:type, ?c₁)	T(?x, rdf:type, ?c₂)
T(?c₁, owl:equivalentClass, ?c₂) T(?x, rdf:type, ?c₁)	T(?x, rdf:type, ?c₂)
T(?c₁, owl:equivalentClass, ?c₂) T(?x, rdf:type, ?c₂)	T(?x, rdf:type, ?c₁)
T(?c₁, owl:disjointWith, ?c₂) T(?x, rdf:type, ?c₁) T(?x, rdf:type, ?c₂)	false
T(?y, rdf:type, owl:AllDisjointClasses) LIST[?y, ?c₁, ..., ?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.

Table 8. 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₁, owl:sameAs, lt₂)	for all literals lt₁ and lt₂ with the same data value
true	T(lt₁, owl:differentFrom, lt₂)	for all literals lt₁ and lt₂ 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.

Table 9. The Semantics of Schema Vocabulary
If	then
T(?c, rdf:type, owl:Class)	T(?c, rdfs:subClassOf, ?c) T(?c, owl:equivalentClass, ?c)
T(?c₁, rdfs:subClassOf, ?c₂) T(?c₂, rdfs:subClassOf, ?c₃)	T(?c₁, rdfs:subClassOf, ?c₃)
T(?c₁, owl:equivalentClass, ?c₂)	T(?c₁, rdfs:subClassOf, ?c₂) T(?c₂, rdfs:subClassOf, ?c₁)
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₁, rdfs:subPropertyOf, ?p₂) T(?p₂, rdfs:subPropertyOf, ?p₃)	T(?p₁, rdfs:subPropertyOf, ?p₃)
T(?p₁, owl:equivalentProperty, ?p₂)	T(?p₁, rdfs:subPropertyOf, ?p₂) T(?p₂, rdfs:subPropertyOf, ?p₁)
T(?p, rdfs:domain, ?c₁) T(?c₁, rdfs:subClassOf, ?c₂)	T(?p, rdfs:domain, ?c₂)
T(?p₂, rdfs:domain, ?c) T(?p₁, rdfs:subPropertyOf, ?p₂)	T(?p₁, rdfs:domain, ?c)
T(?p, rdfs:range, ?c₁) T(?c₁, rdfs:subClassOf, ?c₂)	T(?p, rdfs:range, ?c₂)
T(?p₂, rdfs:range, ?c) T(?p₁, rdfs:subPropertyOf, ?p₂)	T(?p₁, rdfs:range, ?c)
T(?c₁, owl:hasValue, ?i) T(?c₁, owl:onProperty, ?p₁) T(?c₂, owl:hasValue, ?i) T(?c₂, owl:onProperty, ?p₂) T(?p₁, rdfs:subPropertyOf, ?p₂)	T(?c₁, rdfs:subClassOf, ?c₂)
T(?c₁, owl:someValuesFrom, ?y₁) T(?c₁, owl:onProperty, ?p) T(?c₂, owl:someValuesFrom, ?y₂) T(?c₂, owl:onProperty, ?p) T(?y₁, rdfs:subClassOf, ?y₂)	T(?c₁, rdfs:subClassOf, ?c₂)
T(?c₁, owl:someValuesFrom, ?y) T(?c₁, owl:onProperty, ?p₁) T(?c₂, owl:someValuesFrom, ?y) T(?c₂, owl:onProperty, ?p₂) T(?p₁, rdfs:subPropertyOf, ?p₂)	T(?c₁, rdfs:subClassOf, ?c₂)
T(?c₁, owl:allValuesFrom, ?y₁) T(?c₁, owl:onProperty, ?p) T(?c₂, owl:allValuesFrom, ?y₂) T(?c₂, owl:onProperty, ?p) T(?y₁, rdfs:subClassOf, ?y₂)	T(?c₁, rdfs:subClassOf, ?c₂)
T(?c₁, owl:allValuesFrom, ?y) T(?c₁, owl:onProperty, ?p₁) T(?c₂, owl:allValuesFrom, ?y) T(?c₂, owl:onProperty, ?p₂) T(?p₁, rdfs:subPropertyOf, ?p₂)	T(?c₂, rdfs:subClassOf, ?c₁)
T(?c, owl:intersectionOf, ?x) LIST[?x, ?c₁, ..., ?c_n]	T(?c, rdfs:subClassOf, ?c₁) T(?c, rdfs:subClassOf, ?c₂) ... T(?c, rdfs:subClassOf, ?c_n)
T(?c, owl:unionOf, ?x) LIST[?x, ?c₁, ..., ?c_n]	T(?c₁, rdfs:subClassOf, ?c) T(?c₂, 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 RDF-Based 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₁ and O₂ 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₂ are assertions of the following form with a, a₁, ..., a_n named individuals:

ClassAssertion( C a ) where C is a class
PropertyAssertion( P a₁ a₂ ) where P is an object property
PropertyAssertion( P a v ) where P is a data property
SameIndividual( a₁ ... a_n )
DifferentIndividuals( a₁ ... a_n )

Furthermore, let RDF(O₁) and RDF(O₂) be translations of O₁ and O₂, respetively, into RDF graphs as specified in the OWL 2 Mapping to RDF Graphs [OWL 2 RDF Mapping]; and let FO(RDF(O₁)) and FO(RDF(O₂)) be the translation of these graphs into first-order 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₁ entails O₂ under the OWL 2 RDF-Based semantics [OWL 2 RDF-Based Semantics] if and only if FO(RDF(O₁)) ∪ R entails FO(RDF(O₂)) under the standard first-order semantics.

Editor's Note: ToDo: Add proof sketch and/or pointers into the literature.

5 Computational Properties

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:

Data Complexity: the complexity measured with respect to the total size of the assertions in the ontology
Taxonomic Complexity: the complexity measured with respect to the total size of the axioms in the ontology
Query Complexity: the complexity measured with respect to the total size of the query
Combined Complexity: the complexity measured with respect to both the size of the axioms, the size of the assertions, and, in the case of conjunctive query answering, the size of the query as well

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.

Table 10. Complexity of the Profiles
Language	Reasoning Problems	Taxonomic Complexity	Data Complexity	Query Complexity	Combined Complexity
OWL 2 DL	Ontology Consistency, Class Expression Satisfiability, Class Expression Subsumption, Instance Checking	2NEXPTIME-complete	Open (NP-Hard)	Not Applicable	2NEXPTIME-complete
OWL 2 DL	Conjunctive Query Answering	Open*	Open*	Open*	Open*
OWL 1 DL	Ontology Consistency, Class Expression Satisfiability, Class Expression Subsumption, Instance Checking	NEXPTIME-complete	Open (NP-Hard)	Not Applicable	NEXPTIME-complete
OWL 1 DL	Conjunctive Query Answering	Open*	Open*	Open*	Open*
OWL 2 EL	Ontology Consistency, Class Expression Satisfiability, Class Expression Subsumption, Instance Checking	PTIME-complete	PTIME-complete	Not Applicable	PTIME-complete
OWL 2 EL	Conjunctive Query Answering	PTIME-complete	PTIME-complete	NP-complete	PSPACE-complete
OWL 2 QL	Ontology Consistency, Class Expression Satisfiability, Class Expression Subsumption, Instance Checking,	In PTIME	In LOGSPACE	Not Applicable	In PTIME
OWL 2 QL	Conjunctive Query Answering	In PTIME	In LOGSPACE	NP-complete	NP-complete
OWL 2 RL	Ontology Consistency, Class Expression Satisfiability, Class Expression Subsumption, Instance Checking	PTIME-complete	PTIME-complete	Not Applicable	PTIME-complete
OWL 2 RL	Conjunctive Query Answering	PTIME-complete	PTIME-complete	NP-complete	NP-complete

6 References

[OWL 2 Specification]

7 Appendix: Complete Grammars for Profiles

Editor's Note: This appendix will contain the full grammars of each of the profiles. The grammar will be completed when the technical work on each of the profiles has been finished.

OWL 2 Web Ontology Language:Profiles