OWL 2 Web Ontology Language:
Profiles

W3C Editor's Draft 22 September 2008

This version:: http://www.w3.org/2007/OWL/draft/ED-owl2-profiles-20080922/
Latest editor's draft:: http://www.w3.org/2007/OWL/draft/owl2-profiles/
Previous version:: http://www.w3.org/2007/OWL/draft/ED-owl2-profiles-20080411/ (color-coded diff)

Authors:: Bernardo Cuenca Grau, Oxford University; Boris Motik, Oxford University; Zhe Wu, Oracle; Achille Fokoue, IBM; Carsten Lutz, Dresden University of Technology

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 8 documents:

Please Comment By ASAP

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 the maximal subset of OWL 2 for which the basic reasoning problems (i.e., consistency, satisfiability, subsumption, classification, and instance checking) can be performed in time that is polynomial with respect to the size of the ontology. 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 relatively simple technology, in particular, rule-based reasoning engines — conjunctive query answering can be implemented by extending a standard relational database system with rules. Such rule-based approaches can be used to perform consistency, satisfiability, subsumption, classification, and instance checking 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 [OWL 2 Specification] are presented and the productions that are the same as in [OWL 2 Specification] are not repeated. In order to make this document self-contained, the full grammar for each of the profiles is given in the Appendix.

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 DL 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 maximal 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.

A main design principle of OWL 2 EL is to focus on the class constructors ObjectIntersectionOf and ObjectSomeValuesFrom, but to provide ObjectAllValuesFrom only in the form of range restrictions. Many biomedical ontologies, such as SNOMED CT, fall within this profile.

2.1 Feature Overview

OWL 2 EL provides the following features:

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)
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)
a subset of the datatypes of OWL 2

The following features of OWL 2 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

The entities of OWL 2 EL are exactly as in OWL 2. Furthermore, OWL 2 EL supports the owl:Thing and owl:Nothing predefined classes, as well as the predefined object and data properties owl:TopObjectProperty, owl:BottomObjectProperty, owl:TopDataProperty, and owl:BottomDataProperty. Finally, it 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 following predefined OWL 2 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 OWL 2.

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 OWL 2 [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 OWL 2, with the exception that DisjointUnion is disallowed. Different class axioms are defined in the same way as in [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 [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 OWL 2 apart from DisjointDataProperty. These axioms are defined in the same way as in [OWL 2 Specification].

DataPropertyAxiom :=
    SubDataPropertyOf |
    EquivalentDataProperties |
    DataPropertyDomain |
    DataPropertyRange |
    FunctionalDataProperty

The assertions in OWL 2 EL, as well as all other axioms, are the same as in OWL 2, 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. 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 object properties OP_i, 2 ≤ i ≤ k, exist such that Ax contains all of the following axioms:

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 SubPropertyOf axiom in which in the first item of the previous definition does not contain a property chain. Range restrictions on reflexive and transitive roles are generally allowed, unless they are used in axioms that are explicitly forbidden using the previous definition.

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 most 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 the 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 restriction 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].

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.

3.1 Feature Overview

The following constructs can be used to define subclass expressions in SubClassOf axioms:

classes
existential quantification (ObjectSomeValuesFrom) where the class is limited to owl:Thing

The following constructs can be used to define superclass expressions in SubClassOf axioms:

classes
existential quantification to a class (ObjectSomeValuesFrom)
negation (ObjectComplementOf)
intersection (ObjectIntersectionOf)

All axioms in OWL 2 QL are constrained in a way that is compliant with these restrictions. Thus, OWL 2 QL supports the following axioms:

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 features of OWL 2 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. The expressive power of OWL 2 QL is such that the global restriction on axioms defined in Section 11 of [OWL 2 Specification] are vacuously satisfied in every DL-lite ontology.

3.2.1 Entities

OWL 2 QL supports all OWL 2 entities, including all predefined classes and properties. Furthermore, the following datatypes are supported in OWL 2 QL:

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 following predefined OWL 2 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 OWL 2.

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 in the antecedents of implications; such class expressions can, for example, occur as subclass expressions in SubClassOf axioms. The superClassExpression production defines the classes that can occur in the consequents of implications; such class expressions can, for example, 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 OWL 2, with the exception that DisjointUnion is disallowed. Different OWL 2 class axioms from the structural specification [OWL 2 Specification] that refer to the ClassExpression production, however, are redefined and restricted them to appropriate forms of class expressions.

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 redefines object property domain and range axioms to use the appropriate class expressions.

ObjectPropertyDomain := 'PropertyDomain' '(' { annotation } ObjectPropertyExpression superClass ')'
ObjectPropertyRange := 'PropertyRange' '(' { annotation } ObjectPropertyExpression superClass ')'
SubObjectPropertyOf := 'SubPropertyOf' '(' { annotation } ObjectPropertyExpression ObjectPropertyExpression ')'
ObjectPropertyAxiom :=
    SubObjectPropertyOf | EquivalentObjectProperties |
    DisjointObjectProperties | InverseObjectProperties |
    ObjectPropertyDomain | ObjectPropertyRange |
    SymmetricObjectProperty

OWL 2 QL disallows the functional data property axioms, and it redefines the object property domain axioms to use the appropriate class expressions.

DataPropertyDomain := 'PropertyDomain' '(' { annotation } DataPropertyExpression superClass ')'
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. Equality and inequality axioms and property assertions are the same as in OWL 2.

ClassAssertion := 'ClassAssertion' '(' { annotation } Class Individual ')'
Assertion := DifferentIndividuals | ClassAssertion | ObjectPropertyAssertion | DataPropertyAssertion

Finally, the axioms in OWL 2 QL are the same as those in OWL 2, 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).

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.4 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 OWL 2 constructs are used makes it possible to implement reasoning systems using relatively simple technology — in particular, 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 OWL 2 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 1.

Table 1. Syntactic Restriction on Class Expressions in SubClassOf Axioms
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)

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 OWL 2 RL Ontologies

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. The idea is based on Description Logic Programs [DLP] — a logic obtained by intersecting description logics with rule-based languages.

4.2.1 Entities

The entities of OWL 2 RL are exactly as in OWL 2. Furthermore, OWL 2 EL 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, it 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 following predefined OWL 2 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 OWL 2 [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 in the antecedents of implications; such class expressions can, for example, occur as subclass expressions in a SubClassOf axiom. The superClassExpressions production defines the classes that can occur in the consequents of implications; such class expressions can, for example, occur as superclass expressions in a SubClassOf axiom. Finally, the equivClassExpressions production defines the classes that can occur in an EquivalentClasses axiom.

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

Review comment from MikeSmith 21:27, 17 September 2008 (UTC)
It seems incorrect that the IntersectionOf terminal for superClassExpression requires a single subClassExpression. Is this a cut and paste error?

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 of [OWL 2 Specification] that refer to ClassExpression. 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 OWL 2, the only difference being that property domain and range axioms are restricted to the appropriate form of class expressions.

ObjectPropertyDomain := 'PropertyDomain' '(' { annotation } ObjectPropertyExpression superClassExpression ')'
ObjectPropertyRange := 'PropertyRange' '(' { annotation } ObjectPropertyExpression superClassExpression ')'
DataPropertyDomain := 'PropertyDomain' '(' { annotation } DataPropertyExpression superClassExpression ')'

OWL 2 RL restricts the positive assertions to a particular type of classes, and it disallows negative property assertions. Equality and inequality between individuals and positive assertions are the same as in OWL 2.

ClassAssertion := 'ClassAssertion' '(' { annotation } Individual superClassExpression ')'
Assertion := SameIndividual | DifferentIndividuals | ClassAssertion | ObjectPropertyAssertion | DataPropertyAssertion

Keys are redefined in OWL 2 RL to allow for correct type of class expression in the axiom.

HasKey := 'HasKey' '(' { annotation } subClassExpression ObjectPropertyExpression | DataPropertyExpression { ObjectPropertyExpression | DataPropertyExpression } ')'

All other axioms in OWL 2 RL are defined as in OWL 2.

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 the 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 2, where z₂, ..., z_n are fresh variables that do not occur anywhere where the abbreviation is used.

Table 2. 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 3 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 3. 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 4 specifies the semantic conditions on axioms about properties.

Table 4. 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:ReflexiveProperty) T(?x, ?y, ?z)	T(?x, ?p, ?x) T(?y, ?p, ?y) T(?z, ?p, ?z)
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 5 specifies the semantic conditions on classes.

Table 5. 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, ?p, ?y) T(?u, rdf:type, ?x)	false
T(?x, owl:maxCardinality, "1"^^xsd:nonNegativeInteger) T(?x, owl:onProperty, ?p) T(?u, ?p, ?y₁) T(?u, ?p, ?y₂) T(?u, rdf:type, ?x)	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

Review comment from IvanHerman 11:39, 19 September 2008 (UTC)
The two rules for qualified max cardinality are missing. They should be added probably before the one on owl:oneOf. They are almost identical to the two rules on maxCardinality, except for the usage of owl:onClass to express the additional constraint.

Table 6 specifies the semantic conditions on class axioms.

Table 6. 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 7 specifies the semantics of datatype literals.

Table 7. 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 8 specifies the semantic restrictions on the vocabulary used to define the schema.

Table 8. 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)

Note that the rules relating to rdfs:domain and rdfs:range reflect the IFF semantic conditions of the OWL 2 RDF-Based semantics [OWL 2 RDF-Based Semantics] rather than the weaker ONLY-IF semantics of RDFS [RDF Semantics].

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 important reasoning problems in the described profiles.

Note that in languages that are propositionally closed (i.e., that provide, either implicitly or explicitly, conjunction, union and negation of class descriptions), such as OWL 2, the problems of ontology consistency, class expression satisfiability, class expression subsumption and instance checking can be reduced to each other in polynomial time. None of the described profiles, however, is propositionally closed, so these reasoning problems thus can have different complexity and require different algorithmic solutions.

This section describes the computational complexity of the most relevant reasoning problems of the languages defined in this document. The reasoning problems considered here are the following:

Ontology Consistency: Check whether a given ontology has at least one model.
Class Expression Satisfiability: Given an ontology O and a class expression CE, verify whether there is a model of O in which the interpretation of CE is not empty.
Class Expression Subsumption: Given an ontology O and class expressions CE₁ and CE₂, verify whether the interpretation of CE₁ is a subset of the interpretation of CE₂ in every model of O
Instance Checking: Given an ontology, an individual a and a class expression CE, verify whether a is an instance of CE in every model of the ontology.
Conjunctive Query Answering: Given an ontology O and a Boolean conjunctive query Q (that is, a closed, existentially quantified conjunction of atoms in which class and property expressions occur as unary and binary atoms), check whether Q is true in every model of O

The problem of computing the class subsumption relationship for all the classes in a given ontology is often called classification.

When evaluating the 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 and the facts. In the case of conjunctive query answering, the combined complexity also includes the size of the query.

Table 8 summarizes the known complexity results for OWL 2, 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 8. 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

A wealth of information about these and other complexity results can be found in the Description Logic Handbook [DL Handbook] and by using the Description Logic Complexity Navigator.

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