Copyright © 2008 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document is being published as one of a set of 68 documents:
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.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
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].
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.
EL++OWL 2 EL provides the following features:
The following features of OWL 2 are missingnot supported in EL++:OWL 2
EL:
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.
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.
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
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 ')'
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 ')'
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.
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.
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.
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:
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.
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.
OWL 2 QL object and data property expressions are the same as in OWL 2.
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 } ')'
A data range expression is restricted in OWL 2 QL to the predefined datatypes.
DataRange := Datatype
The class axioms of OWL 2 QL are the same as in 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
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.
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.
|
Superclass Expressions |
---|---|
a class a nominal class (OneOf) intersection of union of existential quantification to existential quantification to |
intersection of classes (ObjectIntersectionOf) universal quantification to a class expressions (ObjectAllValuesFrom) at-most 1 cardinality restrictions (ObjectMaxCardinality 1) existential quantification to |
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).
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.
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.
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].
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 ')'
A data range expression is restricted in OWL 2 RL to the
ones definedpredefined datatypes admitted in [OWL 2 Specification ].RL.
DataRange := Datatype
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.
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.
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.
|
then | |
---|---|---|
|
T(?s, owl:sameAs, ?s) T(?p, owl:sameAs, ?p) T(?o, owl:sameAs, ?o) |
|
|
T(?y, owl:sameAs, ?x) | |
T(?y, owl:sameAs, ?z) |
T(?x, owl:sameAs, ?z) | |
T(?s, ?p, ?o) |
T(?s', ?p, ?o) | |
T(?s, ?p, ?o) |
T(?s, ?p', ?o) | |
T(?s, ?p, ?o) |
T(?s, ?p, ?o') | |
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.
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, T(?x, ?y, ?z) |
T(?x, ?p, ?x) T(?y, ?p, ?y) T(?z, ?p, ?z) |
|
T(?p, rdf:type, T(?x, ?p, ?x) |
false | |
T(?p, rdf:type, owl:SymmetricProperty) T(?x, ?p, ?y) |
T(?y, ?p, ?x) | |
T(?p, rdf:type, 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) | |
LIST[?x, ?p1, 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,
T(?x, ?p1, ?y) T(?x, ?p2, ?y) |
false | |
LIST[?z, ?p1, T(?x, ?p T(?x, ?p |
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) | |
LIST[?u, ?p1, T(?x, rdf:type, ?c) T(?x, ?p1 ... T(?x, ?p T(?y, rdf:type, ?c) T(?y, ?p1 ... T(?y, ?pn, ?zn) |
T(?x, owl:sameAs, ?y) |
Table 35 specifies the semantic conditions on classes.
If | |
|
---|---|---|
T(?c, LIST[?x, ?c1 T(?y, rdf:type, ?c1) T(?y, rdf:type, ?c2) ... T(?y, rdf:type, ?cn) |
T(?y, rdf:type, ?c) | |
LIST[?x, ?c1, T(?y, rdf:type, ?c) |
T(?y,
rdf:type, ?c1) T(?y, rdf:type, ?c2) ... T(?y, rdf:type, ?cn) |
|
LIST[?x, ?c1, T(?y, rdf:type, ?c |
T(?y, rdf:type, ?c) | |
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 |
Table 46 specifies the semantic conditions on class axioms.
If | then | |
---|---|---|
T(?c1,
rdfs:subClassOf, ?c2) T(?x, rdf:type, ?c1) |
T(?x,
rdf:type, ?c2 |
|
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.
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, |
|
true | T(lt1, |
|
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.
If | then |
---|---|
T(?c, rdf:type, owl:Class) | T(?c, rdfs:subClassOf, ?c) T(?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) |
LIST[?x, ?c1, |
T(?c, rdfs:subClassOf, ?c1) T(?c, rdfs:subClassOf, ?c2) ... T(?c, rdfs:subClassOf, ?cn) |
LIST[?x, ?c1, |
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.
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.
Language | Reasoning Problems | Taxonomic Complexity | Data Complexity | Query Complexity | Combined Complexity |
---|---|---|---|---|---|
OWL 2 DL | Ontology Consistency, |
2NEXPTIME-complete | Open (NP-Hard) |
Not Applicable | 2NEXPTIME-complete |
Conjunctive Query Answering | Open* | Open* | Open* | Open* | |
OWL 1 DL | Ontology Consistency, |
NEXPTIME-complete | Open (NP-Hard) |
Not Applicable | NEXPTIME-complete |
Conjunctive Query Answering | Open* | Open* | Open* | Open* | |
Ontology Consistency, |
PTIME-complete | PTIME-complete | Not Applicable | PTIME-complete | |
Conjunctive Query Answering | PTIME-complete | PTIME-complete | NP-complete | PSPACE-complete | |
Ontology Consistency, |
In PTIME | In LOGSPACE | Not Applicable | In PTIME | |
Conjunctive Query Answering | In PTIME | In LOGSPACE | NP-complete | NP-complete | |
Ontology Consistency, |
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.