W3C

OWL 2 Web Ontology Language:
Profiles

W3C Editor's Draft 11 April22 September 2008

This version:
http://www.w3.org/2007/OWL/draft/ED-owl2-profiles-20080411/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-20080408/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 68 documents:

  1. Structural Specification and Functional-Style Syntax
  2. Model-Theoretic Semantics
  3. RDF-Based Semantics
  4. Mapping to RDF Graphs
  5. XML Serialization
  6. Profiles (this document)
  7. Primer Compatibility with OWL 1 The OWL Working Group intends to make OWL 2 beConformance and Test Cases
  8. A superset of OWL 1, exceptDatatype for some small bug fixes and changes to the formal semantics of annotations. 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.Internationalized Text

Please Comment By 11 May 2008ASAP

The OWL Working Group seeks public feedback on this First Publicthese Working Draft.Drafts. Please send your comments to public-owl-comments@w3.org (public archive). If possible, please offer specific changes to the text that would address your concern. You may also wish to check the Wiki Version of this document for internal-review comments and changes being drafted which may address your concerns.

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.


Contents


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 of OWL 2,profiles, each of them achievingwhich achieves efficiency in a different way and is useful in different application scenarios:scenarios.

The EL++choice of profile enables polynomial time algorithms forwill depend on the reasoning tasks consistency, classification,structure of the ontologies used in the application and instance checking. Dedicatedon the reasoning algorithms for this profile are available and have been demonstratedtasks to be implementable in a highly scalable way. In the DL-Lite profile,performed, for example (ontology) consistency, (class) satisfiability, (class) subsumption, classification and conjunctive query answeringanswering. Precise definitions of these tasks can be implemented using conventional relational database systems (after rewriting the query).found in particular, this requires that conjunctive query answeringSection 5.

OWL 2 profiles are defined by placing restrictions on the OWL 2 syntax. Syntactic restrictions can be specified by modifying the grammar of the functional-style syntax [OWL 2 Specification], and (possibly) giving additional non-structuralglobal restrictions. In this document, the modified grammars are specified in two ways. In each section defining a profile,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 fragmentsprofiles is given in the Appendix.

The reasoning tasks mentioned in the description of the profiles are defined as follows. consistency: given an ontology, decide whether it is contradictory (i.e., has any models); classification: given an ontology, compute the subclass relation between all its classes; instance checking: given an individual a and a class C in an ontology, decide whether a is an instance of C; conjunctive query answering: given an ontology O and a conjunctive query q, return all tuples of individuals in O that match q.Apart from the ones specified here, there are many other possible profiles of OWL 2.2 there are, for example, the OWL Lite versiona whole family of profiles that extend OWL 12 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. Since its computational properties have turned out to be less good than suspected when the OWL 1 recommendation was passed (e.g., satisifiability and subsumption are ExpTime-complete), OWL 1 Lite is not treated explicitly in this document.OWL 1 DL can also be viewed as a profile of OWL 2.

Editor's Note: See ISSUE-108The Working Group hasitalicized keywords MUST, MUST NOT yet comitted itself to the names, SHOULD, SHOULD NOT, and MAY specify certain aspects of different profiles.the names used in this document are likely to change in future. Editor's Note: At the second F2F meeting, the Working Group has decided to simplify the vocabularynormative behavior of OWL ontologies. In future versions of this specification, the terminals of the functional-style grammar2 tools, and the RDF vocabulary will be significantly smaller.are interpreted as specified in RFC 2119 [RFC 2119].

2 EL++OWL 2 EL

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

A main design principle of EL++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

EL++OWL 2 EL provides the following features:

The following features of OWL 2 are missingnot supported in EL++:OWL 2 EL:

2.2 Profile Specification

The productions for EL++ are defined in thefollowing sections. All global restrictions on axioms fromsections specify the [structure of OWL 2 Specification ] apply. An additional such restriction is imposed, as detailed below .EL ontologies.

2.2.1 Entities

The entities of EL++OWL 2 EL are exactly as in the entireOWL 2 language.2. Furthermore, EL++OWL 2 EL supports the owl:Thing and owl:Nothing predefined classes that are interpretedclasses, as specified in [ OWL 2 Specification ]. EL++well as the predefined object and data properties owl:TopObjectProperty, owl:BottomObjectProperty, owl:TopDataProperty, and owl:BottomDataProperty. Finally, it supports the following datatypes:

The following predefined datatypes of fullOWL 2 aredatatypes MUST NOT availablebe used in EL++:OWL 2 EL: owl:realPlus, xsd:double, xsd:float, xsd:nonPositiveInteger, xsd:positiveInteger, xsd:negativeInteger, xsd:long, xsd:int, xsd:short, xsd:byte, xsd:nonPositiveInteger , xsd:negativeInteger ,xsd:unsignedLong, xsd:unsignedInt, xsd:unsignedShort, xsd:unsignedByte, xsd:time , xsd:gYear , xsd:gMonth , xsd:gDay , xsd:gYearMonthxsd:language, and xsd:gMonthDayxsd:boolean.

2.2.2 ClassProperty 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 design principle of EL++ issame way as in OWL 2.

ObjectPropertyExpression := ObjectProperty

2.2.3 Class Expressions

In order to focus onallow for efficient reasoning, OWL 2 EL restricts the set of supported class constructorsexpressions to ObjectIntersectionOf and, ObjectSomeValuesFrom, which are used extensively in many large-scale ontologies. It additionally provides forObjectExistsSelf, ObjectHasValue, DataSomeValuesFrom, DataHasValue, and objectOneOf enumerations that containcontaining a single individual (called nominals in the DL literature). Thus, EL++ class descriptions are defined according to the following production: descriptionindividual.

ClassExpression :=
owlClassURI    Class | ObjectIntersectionOf | ObjectOneOf |
    ObjectSomeValuesFrom | ObjectExistsSelf | ObjectHasValue |
    DataSomeValuesFrom | DataHasValue

The productions forclass constructorsexpressions 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:individual.

ObjectOneOf := 'ObjectOneOf''OneOf' '(' individualURIIndividual ')'

EL++ disallows ObjectUnionOf , ObjectComplementOf , ObjectAllValuesFrom , DataAllValuesFrom , ObjectMaxCardinality , ObjectMinCardinality , ObjectExactCardinality , DataMaxCardinality , DataMinCardinality , and DataExactCardinality . 2.2.3 Property Expressions Inverse properties are not supported in EL++, and thus object property expressions are restricted to named properties. Data property expressions are as in OWL 2. objectPropertyExpression  := objectPropertyURI2.2.4 Data Range ExpressionsRanges

A data range expression is restricted in EL++OWL 2 EL to the predefined datatypes admitted in EL++OWL 2 EL and to enumerated datatypes consisting of a single constant.literal.

DataRange := datatypeURIDatatype | DataOneOf
DataOneOf := 'DataOneOf''OneOf' '(' constantLiteral ')'

EL++ does not support DataComplementOf and DatatypeRestriction (i.e., no facet is admitted).2.2.5 Axioms

The class axioms of EL++OWL 2 EL are the same as in fullOWL 2, exceptwith the exception that DisjointUnion is not allowed.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 productions for all supported kinds class axiomsfollowing object property axioms, which are defined in the same way as in the [OWL 2 Specification], with the difference that they use the new description production. We refer to that document for details. EL++ supports the following object property axioms.definition of ObjectPropertyExpression.

ObjectPropertyAxiom :=
    EquivalentObjectProperties | SubObjectPropertyOf |
    ObjectPropertyDomain | ObjectPropertyRange |
    TransitiveObjectProperty | ReflexiveObjectProperty

The productions for all supported kinds of object property axioms are as in the [OWL 2 Specification ]. EL++ disallows DisjointObjectProperties , IrreflexiveObjectProperty , InverseObjectProperties , FunctionalObjectProperty , SymmetricObjectProperty , and AsymmetricObjectProperty axioms. Regarding data property axioms, EL++EL provides the same facilitiesaxioms about data properties as OWL 2, except2 apart from DisjointDataProperty. Therefore, data propertyThese axioms in EL++are defined in the same way as follows.in [OWL 2 Specification].

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

Again,The productions for all supported kinds of property axioms are asassertions in the [OWL 2 Specification ]. The facts in EL++EL, as well as all other axioms, are the same as in OWL 2, with the diffencedifference that descriptions andclass object property expressions are restricted as specified previously. Finally, the axioms of EL++ are the same asdefined in OWL 2, withthe difference that each axiom type is restricted as specified previously.previous sections.

2.2.6 Global Restriction The axiom closure Ax of an EL++ ontology must obeyRestrictions

OWL 2 EL extends the global restrictions described inon axioms from Section 1011 of the structural specification [OWL 2 Specification ]. To obtain polytime reasoning problems, one] with an additional restrictioncondition. In order to define this condition, the following notion is imposed.used.

Let CE be a class expression. We say that Ax imposes a range restriction to CE on an object property PEOP1 if itobject properties OPi, 2 i k, exist such that Ax contains axioms SubObjectPropertyOf(PEall of the following axioms:

The axiom closure Ax of an OWL 2 EL ontology MUST obey the restrictions described in Section 11 of the structural specification [OWL 2 Specification] and, in addition, if

then Ax imposesMUST impose a range restriction to CE on PEOPn.

Remarks: (1) TheThis additional restriction is vacuously true if the SubObjectPropertyOffor each SubPropertyOf axiom in which in the first item is a role inclusion statement -- that is, if itof the previous definition does not contain SubObjectPropertyChain . (2)a property chain. Range restrictions on reflexive and transitive roles are generally allowed, unless they are used in axioms following thethat are explicitly forbidden pattern above.using the previous definition.

3 DL-Lite DL-Lite is a syntactic profile ofOWL 2 thatQL

The OWL 2 QL profile admits sound and complete reasoning in LOGSPACE with respect to the size of the data (facts). DL-Lite(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. The variant presented hereliterature [DL-Lite]. OWL 2 QL is calledbased on the DL-LiteR since it allows for property inclusion axioms; it therefore contains an expressive DL containing the intersection betweenof RDFS and OWL 2 DL. Other2. DL-LiteR does not require the unique name assumption (UNA), since making this assumption would have no impact on the semantic consequences of a DL-LiteR ontology. More expressive variants trade property inclusion axiomsof DL-Lite, such as DL-LiteA, extend DL-LiteR with functional properties, and these can also be extended with keys; however, for functionalityquery answering to remain in LOGSPACE, these extensions require UNA and inverse-functionalityneed to impose certain global restriction on the interaction between properties used in different types of object properties. Note thataxiom. Basing OWL 2 QL on DL-LiteR avoids practical problems involved in the profile presented here is asymmetric: itexplicit 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 can be used. Editor's Note: Please note that Data Propertiesare not yet incorporated into DL-Lite in this draft, pending consultation with some DL-Lite experts . Editor's Note: See ISSUE-80 (DL-Lite) This document currently contains the DL-lite R version of DL-lite. In future versions of this document, however, this language is likelyallowed to be extended with additional constructs that preserve its computational properties, such as Data Properties and suitably restricted Functional Properties.occur.

3.1 Feature Overview

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

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

All classaxioms in DL-LiteOWL 2 QL are constrained in a way that is compliant with these restrictions. For example,Thus, OWL 2 QL supports the property domain and range axioms are allowed to refer only to the superclasses mentioned above: class inclusionfollowing axioms:

The following features of OWL 2 are missingnot supported in DL-Lite:OWL 2 QL:

3.2 Profile Specification

The productions for DL-LiteOWL 2 QL are defined in the following sections. The expressive power of OWL 2 QL is such that the global restricitonsrestriction on axioms defined in the structural specificationSection 11 of [OWL 2 Specification] are not enforcedvacuously satisfied in DL-Lite.every DL-lite ontology.

3.2.1 Entities

DL-LiteOWL 2 QL supports all OWL 2 entities apart from dataentities, including all predefined classes and properties. Furthermore, the entities in DL-Litefollowing datatypes are defined as follows. entity  := owlClass | objectProperty | annotationProperty | individual The only well-known entity definedsupported in DL-Lite isOWL 2 QL:

The class with URI owl:Thing , which is interpreted as specified in [following predefined OWL 2 Semantics ]. 3.2.2 Class Expressionsdatatypes MUST NOT be used in DL-Lite, there are two types of class expressions. The subClassOWL 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 classesclass expressions that can occur in the antecedents of implications; such class expressions can, for example, such classes canoccur as subclassessubclass expressions in aSubClassOf axiom.axioms. The superClasssuperClassExpression production defines the classes that can occur in the consequents of implications; such class expressions can, for example, such classescan occur as superclassessuperclass expressions in aSubClassOf axiom. subClassaxioms.

subClassExpression :=
    owlClassURI other than owl:ThingClass |
    'ObjectSomeValuesFrom''SomeValuesFrom' '(' ObjectPropertyExpression owl:Thing ')'
superClasssuperClassExpression :=
    subClassClass |
    'ObjectComplementOf''SomeValuesFrom' '(' subClassObjectPropertyExpression Class ')'
3.2.3 Property Expressions DL-Lite object property expressions    '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 DL. 3.2.4 Axioms DL-Lite axioms are defined to exclude membership assertions on data properties. axiom  := classAxiom | objectPropertyAxiom | fact | declaration | entityAnnotation Furthermore, DL-Lite redefines allclass axioms from the functional-style syntaxstructural specification [OWL 2 Specification] that refer to the description production. In particular, it restricts various class axiomsClassExpression production, however, are redefined and restricted them to appropriate forms of classes, and it disallows DisjointUnion . The production for axioms about classes in DL-Lite are defined as follows.class expressions.

SubClassOf := 'SubClassOf' '(' subClass superClass{ annotation } subClassExpression superClassExpression ')'
EquivalentClasses := 'EquivalentClasses' '(' subClass subClass{ subClassannotation } subClassExpression subClassExpression { subClassExpression } ')'
DisjointClasses := 'DisjointClasses' '(' subClass subClass{ subClassannotation } subClassExpression subClassExpression { subClassExpression } ')'
ClassAxiom := SubClassOf | EquivalentClasses | DisjointClasses

DL-LiteOWL 2 QL disallows the use of property chains in property inclusion axioms (simpleaxioms; however, simple property inclusions are just like insupported. Furthermore, OWL 2), it2 QL disallows the use of functional, transitive, asymmetric, reflexive and irreflexive object properties, and it redefines theobject property domain and range axioms to use the newappropriate class productions.expressions.

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

Editor's Note: I assume that negativeObjectPropertyAssertion is not supported by DL-Lite DL-LiteOWL 2 QL disallows axioms aboutthe functional data propertiesproperty 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 assertion.assertions and equality axioms. Furthermore, class membershipassertions in DL-Lite are restricted toOWL 2 QL can involve only atomic classes. Equality and inequality axioms and property membershipassertions are the same as in OWL 2.

Therefore, the fact axioms of DL-Lite are defined as follows.ClassAssertion := 'ClassAssertion' '(' individualURI classURI{ annotation } Class Individual ')'
factAssertion := sameIndividual |DifferentIndividuals | ClassAssertion | ObjectPropertyAssertion 4 OWL-R OWL-R is a profile of| DataPropertyAssertion

Finally, the axioms in OWL 2 that allows for scalable reasoning using rule-based technologies.QL are the profile has been designed sosame as to avoid the need to inferthose in OWL 2, with the existence of individualsexception that keys are not explicitly present inallowed.

Axiom := Declaration | ClassAxiom | ObjectPropertyAxiom | DataPropertyAxiom | Assertion | EntityAnnotation | AnonymousIndividualAnnotation

4 OWL 2 RL

The knowledge base. This design goal enables a straightforward translation of OWL’s semantic conditions into rules, on which most rule-basedOWL 2 RL profile is aimed at applications that require scalable reasoning engines terminate in a finite amount of time. Another design goal for OWL-Rwithout sacrificing too much expressive power. It is flexibility. On the one hand, OWL-R candesigned to accommodate both OWL 2 DLapplications that can trade the full expressivity of the language for efficiency; on the other hand, OWL-R can also accommodateefficiency, and RDF(S) applications that need some added expressivity from OWL. For this purpose,OWL 2. This document provides two variants of OWL-R. The first variant of OWL-R, called OWL-R DL,is intended to be usedachieved by defining a syntactic subset of OWL 2 DL users who can trade some expressivity for being ablewhich is amenable to implement reasoningimplementation using rule-based systems. OWL-R DL is defined astechnologies (see Section 4.2), and presenting a syntactic subsetpartial axiomatization of the OWL 2 DL -- that is, it places syntactic restrictions on OWL 2 DL axioms. For example,RDF-Based Semantics in this definition, one cannot declare an OWL class C1 to be a subclass ofthe unionform of two classes C2 and C3.first-order implications that can be used as the definition of OWL-R DL is presented completelybasis 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 second variant OWL-R, called OWL-R Full, is intendedcorrect answers to certain kinds of query (see Section 4.4 and Conformance). Such an implementation can also be used by RDF(S) users who want to augment RDF(S)with additional contructs. OWL-R Full ontologies are thusarbitrary RDF graphsgraphs. In this case, however, these properties no longer hold in particular, it is no longer possible to guarantee that are interpreted under a weakened version ofall correct answers can be returned.

4.1 Feature Overview

Restricting the extensional semantic conditions ofway in which OWL 2 Full. An axiomatization of the weakened semanticsconstructs are used makes it possible to implement reasoning systems using first-order implications is providedrelatively simple technology in the form of entailment rules that operate directly on RDF triples. This set of entailment rules provides a useful starting point for practical inference implementation usingparticular, rule-based technologies. The definition of OWL-R Full is presented completely in Section 4.3 . Readers who are familiar with RDF(S) triple-oriented technology andreasoning engines while still providing desirable computational guarantees. These restrictions are interested mainly indesigned so as to avoid the semantic axiomatization of OWL-R Full using first-order implication may skip directlyneed to Section 4.3.2 .infer the definitionsexistence of OWL-R DL and OWL-R Full are independent in the sense that it isindividuals not necessary to understand one variantexplicitly present in order to be able to understandthe other. Thus,knowledge base, and to avoid the readers interested inneed for nondeterministic reasoning. This is achieved by restricting the DL versionuse of OWL-R can skipOWL 2 constructs to Section 4.2 , whereas the readers interestedcertain syntactic positions. For example in SubClassOf axioms, the Full version of OWL-R can skip to Section 4.3 .constructs in the relationship between OWL-R DL and OWL-R Full is specified precisely in Section 4.4 . This clear relationship allows users to switch between the two versions of OWL-R if necessary. Editor's Note: There is an open issue concerning entailments that follow in the OWL Full, but not in OWL-R. 4.1 Feature Overview OWL-R, although just a profile of OWL 2, is quite expressive. An OWL-R DL ontology can use, in a nutshell, most OWL 2 language constructs except owl:cardinality, owl:minCardinality, owl2:NegativeObjectPropertyAssertion, owl2:NegativeDataPropertyAssertion, and owl:complementOf. Not all constructs of OWL-R DL can be used freely in all places in the axioms. For example, in SubClassOf axioms, the usage of the constructs on the left-subclass and right-hand side of the implicationsuperclass expressions must follow the usage patterns shown in Table 4.1.1.

Table 1. Syntactic Restriction on DescriptionsClass Expressions in SubClassOf Axioms
Left-Hand Side Right-Hand Side an OWLSubclass Expressions Superclass Expressions
a class
a nominal class (OneOf)
intersection of classesclass expressions (ObjectIntersectionOf)
union of classesclass expressions (ObjectUnionOf)
existential quantification to an OWLa class expressions (ObjectSomeValuesFrom)
existential quantification to a nominalan individual (ObjectHasValue)
an OWLa class
intersection of classes (ObjectIntersectionOf)
universal quantification to a class expressions (ObjectAllValuesFrom)
at-most 1 cardinality restrictions (ObjectMaxCardinality 1)
existential quantification to a nominalan individual (ObjectHasValue)

Unlike OWL-R DL, in OWL-R Full there are no syntactic restrictionsImplementations based on the way language constructspartial axiomatization (presented in Section 4.3) can also be used: anyused with arbitrary RDF graph constitutes a valid OWL-R Full ontology. The semantics of language constructs, however, is weakenedgraphs, but in OWL-R Fullthis case it is no longer possible to mimicprovide the usage patterns of OWL-R DL.above mentioned computational guarantees. Such implementations will, however, still produce only correct entailments (see Conformance).

4.2 OWL 2 RL Ontologies

The productions for example, inOWL 2 Full (or DL), anRL are defined in the following sections. OWL class C12 RL is a subclass of C2 if anddefined not only if the extension of C1 is a subsetin terms of the extensionset of C2. In OWL-R Full, that "if and only if" condition is weakened to "only if."supported constructs, but it also restricts the principles according to which this weakening has been derived are presentedplaces in Section 4.3.1 . An equivalent characterization ofwhich these constructs can be used. The weakened semantics by means of first-order implications is given in Section 4.3.2 . Table 2 lists the language constructs that are supported in OWL-R Full. Table 2. The Constructs Supported in OWL-R Full Equality owl:sameAs owl:differentFrom Property Expressions owl:inverseObjectPropertyExpression Property Axioms rdfs:domain rdfs:range owl:FunctionalProperty owl:InverseFunctionalProperty owl2:ReflexiveProperty owl2:IrreflexiveProperty owl:SymmetricProperty owl2:AsymmetricProperty owl:TransitiveProperty rdfs:subPropertyOf owl2:propertyChain owl:equivalentProperty owl2:propertyDisjointWith owl2:disjointDataProperties owl:inverseOf Class Constructs owl:intersectionOf owl:unionOf owl:someValuesFrom owl:allValuesFrom owl:hasValue owl:maxCardinality 1 Class Axioms rdfs:subClassOf owl:equivalentClass owl:disjointClasses 4.2 OWL-R DL OWL-R DL is a syntactic profile of OWL 2 DL. The profile is defined not only in terms of a set of supported constructs, but it also restricts the places in which these constructs can be used. Itidea is based on Description Logic Programs [DLP] -- a logic obtained by intersecting description logics with rule-based languages.

4.2.1 Entities

OWL-R DL does not impose any restrictions onThe entities of OWL 2 Entities. Therefore, entities defined hereRL are the sameexactly as in [OWL 2 Specification ].2. Furthermore, OWL-R defines the same set of well-known entities as the entireOWL 2 language:EL supports the class with URIowl:Thing is the set of all objects. (In DL literature this is often called the top concept.) The class with URIand owl:Nothing is the empty set of objects. (In DL literature this is often calledpredefined classes; however, it does not support the bottom concept.)predefined object and data properties owl:TopObjectProperty, owl:BottomObjectProperty, owl:TopDataProperty, and owl:BottomDataProperty. Finally, it supports the unary datatype with URIfollowing datatypes:

The following predefined OWL 2 datatypes with URIs as mentionedMUST NOT be used in [OWL 2 Semantics ].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 Data Ranges A data range expression defines a range over data values.Property Expressions

Property expressions in OWL-R DL, a data range expression is restricted to either a named atomic datatype (the list of datatypes supported by OWL-R DL isOWL 2 RL are identical to the oneproperty expressions in OWL 2 [OWL 2 Semantics ]) or a datatype restriction, specified by applying some facets to limit the value space of an pre-existing datatype. dataRange  := datatypeURI | datatypeRestrictionSpecification].

4.2.3 ClassesClass Expressions

There are three types of classesclass expressions in OWL-R.OWL 2 RL. The subClasssubClassExpression production defines the classesclass expressions that can occur in the antecedents of implications; such class expressions can, for example, such classes canoccur as subclassessubclass expressions in a SubClassOf axiom. The superClasssuperClassExpressions production defines the classes that can occur in the consequents of implications; such class expressions can, for example, such classes canoccur as superclassessuperclass expressions in a SubClassOf axiom. Finally, the equivClassequivClassExpressions production defines the classes that can occur in an EquivalentClasses axiom.

zeroOrOne  := '0' | '1'
subClasssubClassExpression :=
    owlClassURIClass other than owl:Thing |
    'ObjectOneOf''OneOf' '(' individualURIIndividual { individualURIIndividual } ')'
    'ObjectIntersectionOf''IntersectionOf' '(' subClass subClasssubClassExpression subClassExpression { subClasssubClassExpression } ')' |
    'ObjectUnionOf''UnionOf' '(' subClass subClasssubClassExpression subClassExpression { subClasssubClassExpression } ')' |
    'ObjectSomeValuesFrom''SomeValuesFrom' '(' ObjectPropertyExpression subClasssubClassExpression ')' |
    'DataSomeValuesFrom''SomeValuesFrom' '(' DataPropertyExpression { DataPropertyExpression } DataRange ')' |
    'ObjectHasValue''HasValue' '(' ObjectPropertyExpression individualURIIndividual ')' |
    'DataHasValue''HasValue' '(' DataPropertyExpression constantLiteral ')'
superClasssuperClassExpression :=
    owlClassURIClass |
    'ObjectIntersectionOf''IntersectionOf' '(' subClass superClasssubClassExpression superClassExpression { superClasssuperClassExpression } ')' |
    'ObjectAllValuesFrom''AllValuesFrom' '(' ObjectPropertyExpression superClasssuperClassExpression ')' |
    'DataAllValuesFrom''AllValuesFrom' '(' DataPropertyExpression { DataPropertyExpression } DataRange ')' |
    'ObjectMaxCardinality''MaxCardinality' '(' zeroOrOne ObjectPropertyExpression [ subClasssubClassExpression ] ')' |
    'DataMaxCardinality''MaxCardinality' '(' zeroOrOne DataPropertyExpression [ DataRange ] ')' |
    'ObjectHasValue''HasValue' '(' ObjectPropertyExpression individualURIIndividual ')' |
    'DataHasValue''HasValue' '(' DataPropertyExpression constantLiteral ')'
equivClassequivClassExpression :=
    owlClassURIClass other than owl:Thing |
    'ObjectIntersectionOf''IntersectionOf' '(' equivClass equivClassequivClassExpression equivClassExpression { equivClassequivClassExpression } ')' |
    'ObjectHasValue''HasValue' '(' ObjectPropertyExpression individualURIIndividual ')' |
    'DataHasValue''HasValue' '(' DataPropertyExpression constantLiteral ')'

4.2.4 Properties OWL-R constructs used to build more complex propertiesReview comment from existing ones are identicalMikeSmith 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 ones definedpredefined datatypes admitted in [OWL 2 Specification ].RL.

DataRange := Datatype

4.2.5 Axioms

OWL-ROWL 2 RL redefines all axioms from the functional-style syntaxof [OWL 2 Specification] that refer to the description production.ClassExpression. In particular, it restricts various class axioms to use the appropriate form of class expressions (i.e.(i.e., one of subClasssubClassExpression, superClasssuperClassExpression, or equivClassequivClassExpression), and it disallows the DisjointUnion axiom.

ClassAxiom := SubClassOf | EquivalentClasses | DisjointClasses
SubClassOf := 'SubClassOf' '(' subClass superClass{ annotation } subClassExpression superClassExpression ')'
EquivalentClasses := 'EquivalentClasses' '(' equivClass equivClass{ equivClassannotation } equivClassExpression equivClassExpression { equivClassExpression } ')'
DisjointClasses := 'DisjointClasses' '(' subClass subClass{ subClassannotation } subClassExpression subClassExpression { subClassExpression } ')'

OWL-ROWL 2 RL axioms about property expression language is very similar toexpressions are as in OWL 2.2, the only difference isbeing that OWL-R restrictsproperty domain and range axioms are restricted to the appropriate form of class expressions as follows:expressions.

ObjectPropertyDomain := 'ObjectPropertyDomain''PropertyDomain' '(' { annotation } ObjectPropertyExpression superClasssuperClassExpression ')'
ObjectPropertyRange := 'ObjectPropertyRange''PropertyRange' '(' { annotation } ObjectPropertyExpression superClasssuperClassExpression ')'
DataPropertyDomain := 'DataPropertyDomain''PropertyDomain' '(' { annotation } DataPropertyExpression superClass ')' Therefore, axioms about object and data properties in OWL-R are defined as follows. objectPropertyAxiom  :=     objectPropertyDomain | objectPropertyRange |     subObjectPropertyOf | equivalentObjectProperties |     disjointObjectProperties | inverseObjectProperties |     functionalObjectProperty | inverseFunctionalObjectProperty |     reflexiveObjectProperty | irreflexiveObjectProperty |     symmetricObjectProperty | asymmetricObjectProperty |     transitiveObjectProperty dataPropertyAxiom  :=     dataPropertyDomain | dataPropertyRange |     subDataPropertyOf | equivalentDataProperties | disjointDataProperties |     functionalDataProperty OWL-R restricts the positive facts to a particular type of classes, and it disallows negative property assertions. Equality and inequality between individuals and positive facts are the same as in the entire OWL 2. Therefore, facts in OWL-R are defined as follows. classAssertion  := 'ClassAssertion' '(' individualURI superClass ')' fact  :=     sameIndividual | differentIndividuals | classAssertion |     objectPropertyAssertion | dataPropertyAssertion Finally, the axioms in OWL-R are defined as follows. axiom  := classAxiom | objectPropertyAxiom | dataPropertyAxiom | fact | declaration | entityAnnotation 4.3 OWL-R Full OWL-R Full is defined by weakening the semantic conditions on an interpretation from OWL 2 Full. An equivalent definition is also provided in terms of an "axiomatization" using first order implications. The latter definition should provide a useful starting point for practical implementation using rule-based technologies. It is based on [ pD* ]. 4.3.1 Weakened OWL 2 Full Semantic Conditions This section defines OWL-R Full by weakening the OWL 2 Full semantic conditions on an interpretation. Editor's Note: We need to add a reference of OWL 2 Full Semantics 4.3.1.1 Main elements of OWL 2 Full Semantics Before specifying in more details how the semantic weakining is performed for various features of OWL-R Full, we briefly present here the main elements of OWL 2 Full semantics. First, a datatype map D is a partial mapping from URI references to datatypes that maps xsd:string and xsd:integer to the appropriate XML Schema datatypes. Next, the OWL 2 Full model-theoretic semantics defines an interpretation as follows. From OWL 2 Full Semantics, for V a set of URI references and literals containing the RDF, RDFS and OWL vocabulary and D a datatype map, a D-interpretation of V is a tuple I = < R I , P I , EXT I , S I , L I , LV I >. R I is the domain of discourse or universe, i.e., a nonempty set that contains the denotations of URI references and literals in V. P I is a subset of R I consisting of the properties of I. EXT I is used to give meaning to properties, and is a mapping from P I to P(R I × R I ). S I is a mapping from URI references in V to their denotations in R I . L I is a mapping from typed literals in V to their denotations in R I . LV I is a subset of R I that contains at least the set of Unicode strings, the set of pairs of Unicode strings and language tags, and the value spaces for each datatype in D. The set of all classes in R I is C I , and the mapping CEXT I from C I to P(R I ) is defined as CEXT I (c) = { x∈RI | <x,c>∈EXT I (S I (rdf:type)) }. CEXT I (c) maps a class c to its extension. D-interpretations must meet several other conditions, as detailed in the OWL 2 Full semantics. Finally, the following important sets are used in the definitions of OWL 2 Full semantic conditions. IOOP denotes the set of OWL object properties, and IODP the set of OWL datatype properties. Both are subsets of P I . IOC, a subset of C I , denotes the set of OWL classes, and IDC is the set of OWL datatypes. IOR represents the set of OWL restrictions. IOT is the set of OWL individuals. 4.3.1.2 Restrictions defining OWL-R Full In OWL-R Full, the weakening of the OWL 2 Full semantic conditions on an interpretation is mainly done by weakening some equivalences in the OWL Full semantics to implications. For example, the semantics of the owl:someValuesFrom restriction is defined in OWL Full using the following restrictions on the RDF interpretation: If < x,y > EXT I (S I ( owl:someValuesFrom )) < x,p > EXT I (S I ( owl:onProperty )) then x IOR, y IOC IDC, p IOOP IODP, and CEXT I (x) = { u IOT | < u,v > EXT I (p) such that v∈ CEXT I (y) } In a simplified form, these conditions can be understood as the following two implications: If < x,y > EXT I (S I ( owl:someValuesFrom )) < x,p > EXT I (S I ( owl:onProperty )) < u,v > EXT I (p) < v,y > EXT I (S I ( rdf:type )) then < u,x > EXT I (S I ( rdf:type )). If < x,y > EXT I (S I ( owl:someValuesFrom )) < x,p > EXT I (S I ( owl:onProperty )) < u,x > EXT I (S I ( rdf:type )) then v such that < u,v > EXT I (p) < v,y > EXT I (S I ( rdf:type )). The first implication captures the notion of existential restrictions occurring in the antecedents of implications, while the second implication captures the notion of existential restrictions occurring in the consequents of implications. In OWL-R Full, the second implication is discarded. Note the parallel with OWL-R DL, where syntactic restrictions prevent existential restrictions occurring in the consequents of implications. Next, the restrictions that define OWL-R Full are listed. Instead of repeating all the intricate definitions of OWL Full, this section just specifies the difference to the definitions in the OWL Full document. For readers less familiar with OWL Full semantics, the next section provides a more self-contained axiomatization of OWL-R. The conditions in the table defining the characteristics of OWL classes, datatypes, and properties are changed as follows: The conditions defining the sets IOT , LV I , and IX are dropped. The if-and-only-if in the definition of the semantics of owl:FunctionalProperty , owl:InverseFunctionalProperty , owl:SymmetricProperty , and owl:TransitiveProperty is changed into only-if . In the table defining the semantics of rdfs:subClassOf , rdfs:subPropertyOf , rdfs:domain , and rdfs:range , the if-and-only-if condition in the third column of the table header is changed into only-if . In the table defining the characteristics of OWL vocabulary related to equivalence, the if-and-only-if condition in the second column of the table header is changed into only-if . In the table defining the conditions onsuperClassExpression ')'

OWL vocabulary related2 RL restricts the positive assertions to boolean combinationsa particular type of classes, and sets, the conditions for owl:complementOfit disallows negative property assertions. Equality and owl:oneOf are dropped,inequality between individuals and positive assertions are the condition for owl:unionOf is changed into only-if . The condition for owl:intersectionOf is left unchanged. The table defining the conditions on OWL restrictions is modifiedsame as follows. The condifion for owl:allValuesFrom is changed into CEXT I (x) {u IOT | < u,v > EXT I (p) implies v CEXT I (y)in OWL 2.

ClassAssertion := 'ClassAssertion' '(' { annotation } . The condifion for owl:someValuesFrom is changed into CEXT I (x) {u IOTIndividual superClassExpression ')'
Assertion := SameIndividual | < u,v > EXT I (p) implies v CEXT I (y) } . The conditionDifferentIndividuals | ClassAssertion | ObjectPropertyAssertion | DataPropertyAssertion

Keys are redefined in OWL 2 RL to allow for owl:hasValue is let unchanged.correct type of class expression in the conditions for cardinality restrictionsaxiom.

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

All other axioms in OWL 2 RL are changed such that y must be 1,defined as in OWL 2.

4.3 Reasoning in OWL 2 RL and CEXT I (x) = ... is changed into CEXT I (x) ... . The comprehension principles are dropped. 4.3.2 AxiomatizationRDF Graphs using First-Order ImplicationsRules

This section defines OWL-R Fullpresents a partial axiomatization of the OWL 2 RDF-Based Semantics in termsthe form of first-order (material) implications.implications; we will call this definition is intended to be equivalent to the one fromaxiomatization the previous section. This definition shouldOWL 2 RL/RDF rules. These rules provide a useful starting point for thepractical implementation using rule-based technologies.

The implicationsrules 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;triples in RIF [RIF]); thus, T(s, p, o) represents a generalized RDF triple with the subject s , predicate psubject 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, e1, and..., en] is used as an abbreviation for the object o . Variablesconjunction of triples shown in the implicationsTable 2, where z2, ..., zn are preceeded withfresh variables that do not occur anywhere where the question mark.abbreviation is used.

Table 2. Expansion of LIST[h, e1, ..., en]
T(h, rdf:first, e1) T(h, rdf:rest, z2)
T(z2, rdf:first, e2) T(z2, rdf:rest, z3)
... ...
T(zn, rdf:first, en) T(zn, rdf:rest, rdf:nil)

The semantic conditions areaxiomatization is split into several tables for easier navigation. These tables are exhaustive: they specify exactly all the semantic conditions that must hold.Table 13 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 1.3. The Semantics of Equality
Rule nameIf then
RE1T(?s, ?p, ?o)
T(?s, owl:sameAs, ?s)
T(?p, owl:sameAs, ?p)
T(?o, owl:sameAs, ?o)
RE2T(?x, owl:sameAs, ?y) T(?y, owl:sameAs, ?x)
RE3T(?x, owl:sameAs, ?y)
T(?y, owl:sameAs, ?z)
T(?x, owl:sameAs, ?z)
RE4T(?s, owl:sameAs, ?s')
T(?s, ?p, ?o)
T(?s', ?p, ?o)
RE5T(?p, owl:sameAs, ?p')
T(?s, ?p, ?o)
T(?s, ?p', ?o)
RE6T(?o, owl:sameAs, ?o')
T(?s, ?p, ?o)
T(?s, ?p, ?o')
RE7T(?x, owl:sameAs, ?y)
T(?x, owl:differentFrom, ?y)
false
T(?yi, owl:sameAs, ?yj)
T(?x, rdf:type, owl:AllDifferent)
LIST[?x, ?y1, ..., ?yn]
false for each 1 i < j n

Table 24 specifies the semantic conditions on axioms about properties.

Table 2.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, ?y1)
T(?x, ?p, ?y2)
T(?y1, owl:sameAs, ?y2)
T(?p, rdf:type, owl:InverseFunctionalProperty)
T(?x1, ?p, ?y)
T(?x2, ?p, ?y)
T(?x1, owl:sameAs, ?x2)
T(?p, rdf:type, owl2:ReflexiveProperty)owl:ReflexiveProperty)
T(?x, ?y, ?z)
T(?x, ?p, ?x)
T(?y, ?p, ?y)
T(?z, ?p, ?z)
T(?p, rdf:type, owl2:IrreflexiveProperty)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, owl2:AsymmetricProperty)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(?p1, rdfs:subPropertyOf, ?p2)
T(?x, ?p1, ?y)
T(?x, ?p2, ?y)
T(?x 1 , rdf:first, ?p 1 )   T(?xT(?sc, owl:propertyChain, ?x)
LIST[?x, ?p1, rdf:rest, ?x 2 ) T(?x 2 , rdf:first, ?p 2 )   T(?x 2 , rdf:rest, ?x 3 ) ... T(?x n , rdf:first, ?p n )   T(?x..., ?pn , rdf:rest, rdf:nil) T(?sc, owl2:propertyChain, ?x 1 )]
T(?sc, rdfs:subPropertyOf, ?p)
T(?u1, ?p1, ?u2)
T(?u2, ?p2, ?u3)
...
T(?un, ?pn, ?un+1)
T(?u1, ?p, ?un+1)
T(?p1, owl:equivalentProperty, ?p2)
T(?x, ?p1, ?y)
T(?x, ?p2, ?y)
T(?p1, owl:equivalentProperty, ?p2)
T(?x, ?p2, ?y)
T(?x, ?p1, ?y)
T(?p1, owl2:propertyDisjointWith, ?powl:propertyDisjointWith, ?p2)
T(?x, ?p1, ?y)
T(?x, ?p2, ?y)
false
T(?pT(?z, rdf:type, owl:AllDisjointProperties)
LIST[?z, ?p1, owl2:disjointDataProperties, ?p 2 )..., ?pn]
T(?x, ?p 1i, ?y)
T(?x, ?p 2j, ?y)
false for each 1 i < j n
T(?p1, owl:inverseOf, ?p2)
T(?x, ?p1, ?y)
T(?y, ?p2, ?x)
T(?p1, owl:inverseOf, ?p2)
T(?x, ?p2, ?y)
T(?y, ?p1, ?x)
T(?pT(?c, owl:hasKey, ?u)
LIST[?u, ?p1, owl2:inverseObjectPropertyExpression, ?p 2 )..., ?pn]
T(?x, rdf:type, ?c)
T(?x, ?p1 , ?y) T(?y, ?p 2 , ?x) T(?p, ?z1 , owl2:inverseObjectPropertyExpression, ?p 2)
...
T(?x, ?p 2 , ?y)n, ?zn)
T(?y, rdf:type, ?c)
T(?y, ?p1 , ?x), ?z1)
...
T(?y, ?pn, ?zn)
T(?x, owl:sameAs, ?y)

Table 35 specifies the semantic conditions on classes.

Table 3.5. The Semantics of Classes
If then T(?x 1 , rdf:first, ?c 1 )   T(?x 1 , rdf:rest, ?x 2 ) T(?x 2 , rdf:first, ?c 2 )   T(?x 2 , rdf:rest, ?x 3 ) ... T(?x n , rdf:first, ?c n )   T(?x n , rdf:rest, rdf:nil)then
T(?c, owl:intersectionOf, ?xowl:intersectionOf, ?x)
LIST[?x, ?c1 ), ..., ?cn]
T(?y, rdf:type, ?c1)
T(?y, rdf:type, ?c2)
...
T(?y, rdf:type, ?cn)
T(?y, rdf:type, ?c)
T(?x 1 , rdf:first, ?c 1 )   T(?xT(?c, owl:intersectionOf, ?x)
LIST[?x, ?c1, rdf:rest, ?x 2 ) T(?x 2 , rdf:first, ?c 2 )   T(?x 2 , rdf:rest, ?x 3 ) ... T(?x n , rdf:first, ?c..., ?cn )   T(?x n , rdf:rest, rdf:nil) T(?c, owl:intersectionOf, ?x 1 )]
T(?y, rdf:type, ?c)
T(?y, rdf:type, ?c1)
T(?y, rdf:type, ?c2)
...
T(?y, rdf:type, ?cn)
T(?x 1 , rdf:first, ?c 1 )   T(?xT(?c, owl:unionOf, ?x)
LIST[?x, ?c1, rdf:rest, ?x 2 ) T(?x 2 , rdf:first, ?c 2 )   T(?x 2 , rdf:rest, ?x 3 ) ... T(?x n , rdf:first, ?c n )   T(?x..., ?cn , rdf:rest, rdf:nil) T(?c, owl:unionOf, ?x 1 )]
T(?y, rdf:type, ?c 1i)
T(?y, rdf:type, ?c) ... ... T(?x 1 , rdf:first, ?c 1 )   T(?x 1 , rdf:rest, ?x 2 ) T(?x 2 , rdf:first, ?c 2 )   T(?x 2 , rdf:rest, ?x 3 ) ... T(?x n , rdf:first, ?c n )   T(?x n , rdf:rest, rdf:nil) T(?c, owl:unionOf, ?xfor each 1 ) T(?y, rdf:type, ?c i n
) T(?y, rdf:type, ?c)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, ?y1)
T(?u, ?p, ?y2)
T(?u, rdf:type, ?x)
T(?y1, owl:sameAs, ?y2)
T(?c, owl:oneOf, ?x)
LIST[?x, ?y1, ..., ?yn]
T(?yi, 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 46 specifies the semantic conditions on class axioms.

Table 4.6. The Semantics of Class Axioms
If then
T(?c1, rdfs:subClassOf, ?c2)
T(?x, rdf:type, ?c1)
T(?x, rdf:type, ?c2 ) T(?c)
T(?c1, owl:equivalentClass, ?c2)
T(?x, rdf:type, ?c1)
T(?x, rdf:type, ?c2)
T(?c1, owl:equivalentClass, ?c2)
T(?x, rdf:type, ?c2)
T(?x, rdf:type, ?c1)
T(?c1, owl:disjointWith, ?c2)
T(?x, rdf:type, ?c1)
T(?x, rdf:type, ?c2)
false
T(?y, rdf:type, owl:AllDisjointClasses)
LIST[?y, ?c1, ..., ?cn]
T(?x, rdf:type, ?ci)
T(?x, rdf:type, ?cj)
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(lt1, owl:equivalentClass, ?c 2 ) T(?x, rdf:type, ?c 1 ) T(?x, rdf:type, ?cowl:sameAs, lt2) T(?cfor all literals lt1 , owl:equivalentClass, ?c 2 ) T(?x, rdf:type, ?cand lt2 ) T(?x, rdf:type, ?c 1 ) T(?cwith the same data value
true T(lt1, owl:disjointClasses, ?cowl:differentFrom, lt2) T(?x, rdf:type, ?cfor all literals lt1 ) T(?x, rdf:type, ?cand lt2 )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 58 specifies the semantic restrictions on the vocabulary used to define the schema.

Table 5.8. The Semantics of Schema Vocabulary
If then
T(?c, rdf:type, owl:Class) T(?c, rdfs:subClassOf, ?c)
T(?c, owl:equivalentClasses, ?c)owl:equivalentClass, ?c)
T(?c1, rdfs:subClassOf, ?c2)
T(?c2, rdfs:subClassOf, ?c3)
T(?c1, rdfs:subClassOf, ?c3)
T(?c1, owl:equivalentClass, ?c2) T(?c1, rdfs:subClassOf, ?c2)
T(?c2, rdfs:subClassOf, ?c1)
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(?p1, rdfs:subPropertyOf, ?p2)
T(?p2, rdfs:subPropertyOf, ?p3)
T(?p1, rdfs:subPropertyOf, ?p3)
T(?p1, owl:equivalentProperty, ?p2) T(?p1, rdfs:subPropertyOf, ?p2)
T(?p2, rdfs:subPropertyOf, ?p1)
T(?p, rdfs:domain, ?c1)
T(?c1, rdfs:subClassOf, ?c2)
T(?p, rdfs:domain, ?c2)
T(?p2, rdfs:domain, ?c)
T(?p1, rdfs:subPropertyOf, ?p2)
T(?p1, rdfs:domain, ?c)
T(?p, rdfs:range, ?c1)
T(?c1, rdfs:subClassOf, ?c2)
T(?p, rdfs:range, ?c2)
T(?p2, rdfs:range, ?c)
T(?p1, rdfs:subPropertyOf, ?p2)
T(?p1, rdfs:range, ?c)
T(?c1, owl:hasValue, ?i)
T(?c1, owl:onProperty, ?p1)
T(?c2, owl:hasValue, ?i)
T(?c2, owl:onProperty, ?p2)
T(?p1, rdfs:subPropertyOf, ?p2)
T(?c1, rdfs:subClassOf, ?c2)
T(?c1, owl:someValuesFrom, ?y1)
T(?c1, owl:onProperty, ?p)
T(?c2, owl:someValuesFrom, ?y2)
T(?c2, owl:onProperty, ?p)
T(?y1, rdfs:subClassOf, ?y2)
T(?c1, rdfs:subClassOf, ?c2)
T(?c1, owl:someValuesFrom, ?y)
T(?c1, owl:onProperty, ?p1)
T(?c2, owl:someValuesFrom, ?y)
T(?c2, owl:onProperty, ?p2)
T(?p1, rdfs:subPropertyOf, ?p2)
T(?c1, rdfs:subClassOf, ?c2)
T(?c1, owl:allValuesFrom, ?y1)
T(?c1, owl:onProperty, ?p)
T(?c2, owl:allValuesFrom, ?y2)
T(?c2, owl:onProperty, ?p)
T(?y1, rdfs:subClassOf, ?y2)
T(?c1, rdfs:subClassOf, ?c2)
T(?c1, owl:allValuesFrom, ?y)
T(?c1, owl:onProperty, ?p1)
T(?c2, owl:allValuesFrom, ?y)
T(?c2, owl:onProperty, ?p2)
T(?p1, rdfs:subPropertyOf, ?p2)
T(?c2, rdfs:subClassOf, ?c1)
T(?x 1 , rdf:first, ?c 1 )   T(?xT(?c, owl:intersectionOf, ?x)
LIST[?x, ?c1, rdf:rest, ?x 2 ) T(?x 2 , rdf:first, ?c 2 )   T(?x 2 , rdf:rest, ?x 3 ) ... T(?x n , rdf:first, ?c n )   T(?x..., ?cn , rdf:rest, rdf:nil) T(?c, owl:intersectionOf, ?x 1 )]
T(?c, rdfs:subClassOf, ?c1)
T(?c, rdfs:subClassOf, ?c2)
...
T(?c, rdfs:subClassOf, ?cn)
T(?x 1 , rdf:first, ?c 1 )   T(?xT(?c, owl:unionOf, ?x)
LIST[?x, ?c1, rdf:rest, ?x 2 ) T(?x 2 , rdf:first, ?c 2 )   T(?x 2 , rdf:rest, ?x 3 ) ... T(?x n , rdf:first, ?c n )   T(?x..., ?cn , rdf:rest, rdf:nil) T(?c, owl:unionOf, ?x 1 )]
T(?c1, rdfs:subClassOf, ?c)
T(?c2, rdfs:subClassOf, ?c)
...
T(?cn, rdfs:subClassOf, ?c)

4.4 Relationship between OWL-R DLNote that the rules relating to rdfs:domain and OWL-R Fullrdfs: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 AXIOMSR be a set containing allthe implications listed in Section 4.3.2;OWL 2 RL/RDF rules as defined above; and let O1 and O2 be an OWL-R DL ontologyOWL 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 asas, say, a class and an objectindividual), and a data property; let F be a set ofwhere all axioms in O2 are assertions of the following form:form with a, a1, ..., an named individuals:

Furthermore, let RDF(O)RDF(O1) and RDF(F)RDF(O2) be thetranslations of O1 and FO2, respetively, into RDF graphs as specified in the RDFOWL 2 Mapping to RDF Graphs [OWL 2 RDF Mapping ]]; and let FO(RDF(O1)) and FO(RDF(O2)) be the translation of these graphs into first-order theories in which triples are represented using the T predicate. Then,predicate that is, T(s, p, o) represents an RDF triple with the following relationship between consequences in OWL-R DLsubject s, predicate p, and OWL-R Full holds: F is a consequence ofthe object o. Then, O1 entails O2 under the OWL 2 DLRDF-Based semantics [OWL 2 RDF-Based Semantics] if and only if RDF(F) is a consequence of RDF(O)FO(RDF(O1)) AXIOMSR entails FO(RDF(O2)) 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.(i.e., that provide, either implicitly or explicitly, conjunction, union and negation of class descriptions), such as OWL 2 DL and OWL 2 Full,2, the problems of ontology consistency, conceptclass expression satisfiability, conceptclass expression subsumption and instance checking can be reduced to each other in polynomial time. However,None of the described profilesprofiles, however, is propositionally closed, andso these reasoning problems maythus can have different complexity and require diferentdifferent algorithmic solutions.

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

and a conjunctive query q, returnThe answersproblem of computing the query with respect to O.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:

Table 68 summarizes the known complexity results for OWL 2 DL,2, OWL 1 DL, EL++ , DL-Lite,OWL 2 EL, OWL 2 QL, and OWL-R.OWL 2 RL. Whenever the complexity for a given problem is described as Open, with a star, (*), it is meant"Open", * denotes that itsthe problem's decidability is still an open question; if the star (*)* is omitted, then the problem is known to be decidable but precise complexity bounds have not yet been established.

Table 6.8. Complexity of the Profiles
Language Reasoning Problems Taxonomic Complexity Data Complexity Query Complexity Combined Complexity
OWL 2 DL Ontology Consistency, ConceptClass Expression Satisfiability,
ConceptClass Expression Subsumption, Instance Checking
2NEXPTIME-complete Open
(NP-Hard)
Not Applicable 2NEXPTIME-complete
Conjunctive Query Answering Open* Open* Open* Open*
OWL 1 DL Ontology Consistency, ConceptClass Expression Satisfiability,
ConceptClass Expression Subsumption, Instance Checking
NEXPTIME-complete Open
(NP-Hard)
Not Applicable NEXPTIME-complete
Conjunctive Query Answering Open* Open* Open* Open*

EL++OWL 2 EL

Ontology Consistency, ConceptClass Expression Satisfiability,
ConceptClass Expression Subsumption, Instance Checking
PTIME-complete PTIME-complete Not Applicable PTIME-complete
Conjunctive Query Answering PTIME-complete PTIME-complete NP-complete PSPACE-complete

DL-LiteOWL 2 QL

Ontology Consistency, ConceptClass Expression Satisfiability,
ConceptClass Expression Subsumption, Instance Checking,
In PTIME In LOGSPACE Not Applicable In PTIME
Conjunctive Query Answering In PTIME In LOGSPACE NP-complete NP-complete

OWL-ROWL 2 RL

Ontology Consistency, ConceptClass Expression Satisfiability,
ConceptClass Expression Subsumption, Instance Checking
PTIME-complete PTIME-complete Not Applicable PTIME-complete
Conjunctive Query Answering PTIME-complete PTIME-complete NP-complete NP-complete

In DL-Lite, instance checkingA wealth of information about these and conjunctive query evaluationother complexity results can be performed by exploiting relational database technology, i.e., through a translation to SQL queries.found in the fact that data complexity goes beyond LOGSPACE means that query answeringDescription Logic Handbook [DL Handbook] and instance checking require more powerful engines than the ones providedby relational database technologies. PTIME-hardness essentially requires Datalog technologies. Forusing the CoNP cases, Disjunctive Datalog technologies could be adopted.Description Logic Complexity Navigator.

6 References

[OWL 2 Specification]
OWL 2 Web Ontology Language:Structural Specification and Functional-Style Syntax Boris Motik, Peter F. Patel-Schneider, Ian Horrocks. W3C Editor's Draft, 11 April22 September 2008, http://www.w3.org/2007/OWL/draft/ED-owl2-syntax-20080411/http://www.w3.org/2007/OWL/draft/ED-owl2-syntax-20080922/. Latest version available at http://www.w3.org/2007/OWL/draft/owl2-syntax/.
[OWL 2 Semantics]
OWL 2 Web Ontology Language:Model-Theoretic Semantics Bernardo Cuenca Grau, Boris Motik. W3C Editor's Draft, 11 April22 September 2008, http://www.w3.org/2007/OWL/draft/ED-owl2-semantics-20080411/http://www.w3.org/2007/OWL/draft/ED-owl2-semantics-20080922/. Latest version available at http://www.w3.org/2007/OWL/draft/owl2-semantics/.
[OWL 2 RDF Mapping]
OWL 2 Web Ontology Language: MappingLanguage:Mapping to RDF Graphs .Bernardo Cuenca Grau andGrau, Boris Motik, eds., 2006.Peter F. Patel-Schneider. W3C Editor's Draft, 22 September 2008, http://www.w3.org/2007/OWL/draft/ED-owl2-mapping-to-rdf-20080922/. Latest version available at http://www.w3.org/2007/OWL/draft/owl2-mapping-to-rdf/.
[OWL 2 RDF-Based Semantics]
OWL 2 Web Ontology Language:RDF-Based Semantics Michael Schneider. W3C Editor's Draft, 22 September 2008, http://www.w3.org/2007/OWL/draft/ED-owl2-rdf-based-semantics-20080922/. Latest version available at http://www.w3.org/2007/OWL/draft/owl2-rdf-based-semantics/.
[OWL 1 Reference]
OWL Web Ontology Language Reference. Sean Bechhofer, Frank van Harmelen, Jim Hendler, Ian Horrocks,Mike Dean and Guus Screiber, eds., 2004.
[Conformance]
Conformance. Details to be filled in when the document is finished.
[RDF Semantics]
RDF Semantics. Patrick Hayes, ed., 2004.
[DL Handbook]
The Description Logic Handbook. Franz Baader, Diego Calvanese, Deborah L. McGuinness, Daniele Nardi, Peter F. Patel-Schneider, Lynn Andrea Stein,eds., 2004.2007
[EL++]
Pushing the EL Envelope. Franz Baader, Sebastian Brandt, and Carsten Lutz. In Proc. of the 19th Joint Int. Conf. on Artificial Intelligence (IJCAI 2005), 2005.
[EL++ Update]
Pushing the EL Envelope Further. Franz Baader, Sebastian Brandt, and Carsten Lutz. In Proc. of the Washington DC workshop on OWL: Experiences and Directions (OWLED08DC), 2008.
[DL-Lite]
Tractable Reasoning and Efficient Query Answering in Description Logics: The DL-Lite Family. Diego Calvanese, Giuseppe de Giacomo, Domenico Lembo, Maurizio Lenzerini, Riccardo Rosati. J. of Automated Reasoning 39(3):385--429,39(3):385–429, 2007.
[Complexity]
Complexity Results and Practical Algorithms for Logics in Knowledge Representation. Stephan Tobies. Ph.D Dissertation, 2002
[DLP]
Description Logic Programs: Combining Logic Programs with Description Logic. Benjamin N. Grosof, Ian Horrocks, Raphael Volz, and Stefan Decker. in Proc. of the 12th Int. World Wide Web Conference (WWW 2008),2003), Budapest, Hungary, 2003. pp.: 48--5748–57
[pD*]
Completeness, decidability and complexity of entailment for RDF Schema and a semantic extension involving the OWL vocabulary. Herman J. ter Horst. J. of Web Semantics 3(2--3):79--115,3(2–3):79–115, 2005.
[RIF]
RIF RDF and OWL Compatibility. Jos de Bruijn, ed. W3C Working Draft 30 July 2008
[XML Schema Datatypes]
XML Schema Part 2: Datatypes Second Edition. Paul V. Biron and Ashok Malhotra, eds. W3C Recommendation 28 October 2004.
[RFC 2119]
RFC 2119: Key words for use in RFCs to Indicate Requirement Levels. Network Working Group, S. Bradner. Internet Best Current Practice, March 1997.

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.

7.1 EL++OWL 2 EL

7.2 DL-LiteOWL 2 QL

7.3 OWL-ROWL 2 RL