OWL 1.12 Web Ontology Language:
FragmentsProfiles

W3C Editor's Draft 0208 April 2008

This version:

http://www.w3.org/2007/OWL/draft/ED-owl11-fragments-20080402/http://www.w3.org/2007/OWL/draft/ED-owl2-profiles-20080408/

Latest editor's draft:

http://www.w3.org/2007/OWL/draft/owl11-fragments/http://www.w3.org/2007/OWL/draft/owl2-profiles/

Previous version:

http://www.w3.org/2007/OWL/draft/ED-owl11-fragments-20080326/http://www.w3.org/2007/OWL/draft/ED-owl11-fragments-20080402/ (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

---

Copyright © 2008 W3C^® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.

Abstract

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

Set of Documents

This document is being published as one of a set of 6 documents:

1. Structural Specification and Functional-Style Syntax
2. Model-Theoretic Semantics
3. Mapping to RDF Graphs
4. XML Serialization
5. FragmentsProfiles (this document)
6. Primer

These are snapshots of expectedCompatibility with OWL deliverables, for review by1

The Working Group.OWL Working Group face-to-face starts tomorrow morning.intends to make OWL 2 be a superset of OWL 1, except 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.

Please Comment By 2008-04-032008-05-08

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

No Endorsement

Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

Patents

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

Review comment from SandroHawke 12:46, 26 March 2008 (EDT) Document is not valid HTML -- many repeated use of the same id. Try adding ",validate" to the end of this document URL.]]This document describes three important fragmentsprofiles of OWL 1.1. Most2. In logic, profiles are usually called fragments or sublanguages. Most profiles are defined by placing restrictions on the syntax of OWL 1.1.2. These restrictions have been specified by modifying some of the productions of the functional-style syntax [OWL 1.12 Specification].

Review comment from BijanParsia 13:36, 14 March 2008 (EDT) It will be worth having a larger introduction. It's worth mentioning that there are many possible fragments that might usefully beThe focusgrammar of the profiles is specified in two ways. In each section defining a community, as wellprofile, the grammar is presented as a difference; that implementations ofis, only the fragments might support fragment *families* (DL Lite really comes to mind there). Review commentproductions that differ from BijanParsia 13:36, 14 March 2008 (EDT) Is it[OWL 2 Specification] are presented and the caseproductions that are the grammar for a fragment results from takingsame as in [OWL 2 Specification] are not repeated. In order to make this document self-contained, the full grammar for OWL 1.1 and replacing,each of the fragments is given in the whole grammar, those productions which correspondAppendix.

Editor's Note: See ISSUE-108 The Working Group has not yet comitted itself to the onesnames of different profiles. The names used in this document withare likely to change in future.

Editor's Note: At the onessecond F2F meeting, the Working Group has decided to simplify the vocabulary of OWL ontologies. In future versions of this document? I.e., applyspecification, the patch? Review comment from JeremyCarroll 11:41, 28 March 2008 (EDT) Longer intro should mention eachterminals of the three fragmentsfunctional-style grammar and a one-liner rationale for each in language that is as non-technical as possible. Could also mention: OWL DL as another sensible implementation fragment; that users/implementators MAY use any other fragment that they find helpful; deprecate OWL Lite, see ISSUE-107 2 Core Features Shared by All OWL 1.1 Fragments From a specification perspective,the RDF vocabulary will be significantly smaller.

Most OWL fragmentsprofiles differ from each other in three important ways:

• In terms of allowed OWL entities (e.g. classes, properties, individuals). Entities (grammar production: entity) are fundamental building blocks of OWL 1.12 ontologies. They corresponds primitive terms or names, and are identified by URI.

• Review comment from JeremyCarroll 11:45, 28 March 2008 (EDT) I am not clear that any of the fragments really use this variability, and it just causes additional cognitive load to no good effect - datatype properties and datatypes are awaiting clarification in DL Lite, otherwise unused. I suggest delete, and if this variability is needed in DL Lite then it should be done as a special in that section onlyIn terms of the richness of the expression language (e.g. class expressions: , property expressions) used to describe new entities from existing ones.
• In terms of the set of allowed axioms (axiom).

EL++ [ OWL 1.1 Specification ], the grammarEL++,EL++ Update] is a syntactic profile of anOWL fragment is presented in the standard BNF notation. Nonterminal symbols are written in bold (e.g., owlClassURI ), terminal symbols are written2 that admits sound and complete reasoning in single quotes (e.g. 'ObjectPropertyRange' ), zero or more instances of a symbol is denoted with curly braces (e.g., { description } ), alternative productions are denotedpolynomial time with respect to the vertical bar (e.g., fact | declaration ), and zero or one instancessize of a symbol are denoted with square brackets (e.g., [ description ] ). Regardless of the considered fragment, an ontology consists of a set of axioms and may include axioms from other, imported, ontologies. The following basic syntax of an ontology is shared by all three fragments of OWL 1.1: Review comment from JeremyCarroll 11:45, 28 March 2008 (EDT) I dislikethe way that the same identifiers are multiplied defined with different definitions inontology. Many large-scale biomedical ontologies, such as SNOMED CT, fall within this document andprofile.

The productions for EL++ are defined in the following sections. All the nonstructuralglobal restrictions on axioms are exactly as in Section 10 offrom the structural specification[OWL 1.12 Specification ]. 3.2.1] apply. An additional such restriction is imposed, as detailed below.

The entities of EL++ does not impose any restrictions on OWL 1.1 Entities. Therefore, entities defined hereare exactly as in the sameentire OWL 2 language. Furthermore, EL++ supports the owl:Thing and owl:Nothing predefined classes that are interpreted as specified in [OWL 1.12 Specification ] All entities may have an associated URI.].

EL++ supports the syntax for writing entity URIsfollowing datatypes:

• The unary datatype with URI rdfs:Literal
• xsd:decimal
• xsd:integer
• xsd:nonNegativeInteger
• xsd:positiveInteger
• xsd:dateTime
• xsd:date
• xsd:string
• xsd:normalizedString
• xsd:anyURI
• xsd:token
• xsd:Name
• xsd:NCName
• xsd:hexBinary
• xsd:base64Binary

Furthermore, the following predefined datatypes of full OWL 2 are not available in EL ++ is as follows: Review comment from JeremyCarroll 11:48, 28 March 2008 (EDT) This seems unnecessarily verbose++: xsd:double, xsd:float, 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:gYearMonth, and repetitive datatypeURI := URI owlClassURI := URI objectPropertyURI := URI dataPropertyURI := URI annotationPropertyURI := URI individualURI := URI Entitiesxsd:gMonthDay .

The productions for class constructors are as defined in [OWL 2 Specification], with the exception of objectOneOf which admits only a single individual:

objectPropertyEL++ disallows ObjectUnionOf, ObjectComplementOf, ObjectAllValuesFrom, DataAllValuesFrom, ObjectMaxCardinality, ObjectMinCardinality, ObjectExactCardinality, DataMaxCardinality, DataMinCardinality, and DataExactCardinality.

The set ofproductions for all objects. (In DL literature this is often called the top concept.) Thesupported kinds class axioms are as in the [OWL 2 Specification], with URI owl:Nothing isthe empty set of objects. (In DL literature this is often calleddifference that they use the bottom concept.)new description production. We refer to that document for details.

EL++ supports the unary datatype with URI rdfs:Literal isfollowing object property axioms.

The set ofproductions for all concrete objects. The datatypes with URIssupported kinds of object property axioms are as mentionedin the [OWL 1.1 Semantics2 Specification]. 3.2.2 Class Expressions Class expressions can be thought of as descriptions of sets of individuals, or as descriptions which are true (or false) of particular individuals. The language for defining class expressions inEL++ is much restricted compared to OWL 1.1 DL. EL++disallows ObjectAllValuesFrom , DataAllValuesFromDisjointObjectProperties, ObjectMaxCardinalityIrreflexiveObjectProperty, ObjectMinCardinalityInverseObjectProperties, and ObjectExactCardinality restrictions, ObjectComplementOfFunctionalObjectProperty, DataMaxCardinalitySymmetricObjectProperty, DataMinCardinalityand DataExactCardinalityAsymmetricObjectProperty axioms.

Regarding data property axioms, EL++ provides the same facilities as OWL 2, except DisjointDataProperty. Moreover, ObjectOneOf enumerations in EL++ can contain only one element.Therefore, data property axioms in EL++ descriptionsare defined as follows.

Again, the productions for all class expressionssupported kinds of property axioms are as in EL ++, only objectOneOf is different fromthe one defined in[OWL 1.12 Specification].

EL ++ objectOneOf enumeration contains a single individual: objectOneOf := 'ObjectOneOf' '(' individualURI ')' objectIntersectionOf, which is a conjunction of a set of descriptions, objectSomeValuesFrom (resp. dataSomeValuesFrom), which denotes the set of objects that are connected via the given object (resp. data) property to at least one instance of the given description (resp. at least one literal of the given data range), objectExistsSelf, which denotesThe set of objects thatfacts in EL++ are connected to themselves viathe given object property, objectHasValue (resp. dataHasValue), which denotessame as in OWL 2, with the set of objectsdiffence that are connected via the given object (resp. data) property to the object denoted by the given individual (resp. to the given constant), are unchanged: objectIntersectionOf := 'ObjectIntersectionOf' '(' description description { description } ')' objectSomeValuesFrom := 'ObjectSomeValuesFrom' '(' objectPropertyExpression description ')' objectExistsSelf := 'ObjectExistsSelf' '(' objectPropertyExpression ')' objectHasValue := 'ObjectHasValue' '(' objectPropertyExpression individualURI ')' dataSomeValuesFrom := 'DataSomeValuesFrom' '(' dataPropertyExpression { dataPropertyExpression } dataRange ')' dataHasValue := 'DataHasValue' '(' dataPropertyExpression constant ')' 3.2.3 Property Expressions EL ++ objectdescriptions and dataobject property expressions are restricted to named properties. Inverse properties are not supported in EL ++. Therefore, property expressions are definedas follows: objectPropertyExpression := objectPropertyURI dataPropertyExpression := dataPropertyURI 3.2.4 Data Range Expressions A data range expression defines a range over data values. In EL ++, a data range expression is restricted to named atomic datatypes (e.g.specified previously. Finally, the listaxioms of datatypes supported byEL++ isare the same as the onein [OWL 1.1 Semantics ]), enumerated datatypes consisting of a single constant, and datatype restrictions,2, with the difference that each axiom type is restricted as specified by applying some facets to limitpreviously.

The value spaceaxiom closure Ax of an pre-existing datatype. dataRange := datatypeURI | dataOneOf | datatypeRestriction dataOneOf := 'DataOneOf' '(' constant ')' datatypeRestriction := 'DatatypeRestriction' '(' datatypeURI datatypeFacet restrictionValue { datatypeFacet restrictionValue } ')' datatypeFacet := 'length' | 'minLength' | 'maxLength' | 'pattern' | 'minInclusive' | 'minExclusive' | 'maxInclusive' | 'maxExclusive' | 'totalDigits' | 'fractionDigits' restrictionValue := constant 3.2.5 Axioms EL ++ axioms are as follows: axiom := classAxiom | objectPropertyAxiom | dataPropertyAxiom | fact | declaration | entityAnnotationEL++ disallows DisjointUnion . All other class axioms areontology must obey the same asrestrictions described in OWL 1.1, withSection 10 of the differencestructural specification [OWL 2 Specification]. To obtain polytime reasoning problems, one additional restriction is imposed.

Let CE be a class expression. We say that they use the new description production. classAxiom := subClassOf | equivalentClasses | disjointClasses subClass := description superClass := description subClassOf := 'SubClassOf' '(' { annotation } subClass superClass ')' equivalentClasses := 'EquivalentClasses' '(' { annotation } description description { description } ')' disjointClasses := 'DisjointClasses' '(' { annotation } description description { description } ')' EL++ disallows DisjointObjectProperties , IrreflexiveObjectProperty , InverseObjectProperties , FunctionalObjectProperty , SymmetricObjectProperty , and AsymmetricObjectProperty axioms. Therefore,Ax imposes a range restriction to CE on an object property PE₁ if it contains axioms

    in EL++ are defined as follows. objectPropertyAxiom := equivalentObjectProperties | subObjectPropertyOf | objectPropertyDomain | objectPropertyRange | transitiveObjectProperty | reflexiveObjectProperty Review comment from Achille 15:42, 18 March 2008 (EDT) "objectPropertyRange" is mentioned in* SubObjectPropertyOf(PE1 PE2),...,SubObjectPropertyOf(PE<subk-1</sub> PEk)
   * ObjectPropertyRange(PEk CE) 

We require that if

   * Ax contains SubObjectPropertyOf(SubObjectPropertyChain(PE1 ... PEn) PE) and
   * Ax imposes a range restriction to CE on PE

then Ax imposes a range restriction to CE on PE_n.

Remarks: (1) The list of "objectPropertyAxioms". However,restriction is vacuously true if the paper "PushingSubObjectPropertyOf in the EL envelope", whichfirst item is referenced as the theoretical foundation of EL++,a role inclusion statement -- that is, if it does not havecontain SubObjectPropertyChain. (2) Range as one of the features of EL++. I understand that,restrictions on reflexive and transitive roles are generally allowed, unless they are used in Carsten’s paper "Pushingaxioms following the EL Envelope Further" submitted to OWLED, EL++forbidden pattern above.

Editor's Note: Please note that they use the new description production. For your convenience, their definition is provided below: subDataPropertyOf := 'SubDataPropertyOf' '(' { annotation } dataPropertyExpression dataPropertyExpression ')' equivalentDataProperties := 'EquivalentDataProperties' '(' { annotation } dataPropertyExpression dataPropertyExpression { dataPropertyExpression } ')' disjointDataProperties := 'DisjointDataProperties' '(' { annotation } dataPropertyExpression dataPropertyExpression { dataPropertyExpression } ')' dataPropertyDomain := 'DataPropertyDomain' '(' { annotation } dataPropertyExpression description ')' dataPropertyRange := 'DataPropertyRange' '(' { annotation } dataPropertyExpression dataRange ')' EL++ fact axiomsData Properties are almost the same asnot yet incorporated into DL-Lite in OWL 1.1,this draft, pending consultation with some DL-Lite experts.

Editor's Note: See ISSUE-80 (DL-Lite) This document currently contains the differenceDL-lite_R version of DL-lite. In future versions of this document, however, this language is likely to be extended with additional constructs that they use the new descriptionpreserve its computational properties, such as Data Properties and dataRange productions. Review comment from EvrenSirin 14:32, 26 March 2008 (EDT) I don't think itsuitably restricted Functional Properties.

The productions for DL-Lite are defined in the following sections. No nonstructural restricitons on axioms defined in the structural specification [ OWL 1.1 Specification ] apply to DL-Lite. 4.2.1 Entities Editor's Note: Please note that Data Properties are not yet incorporated into DL-Lite in this draft, pending consultation with some DL-Lite experts . DL Lite supports all OWL 1.1 Entities except datatype and dataProperty. All entities may have an associated URI. The syntax for writing entity URIs in EL ++ is as follows: owlClassURI := URI objectPropertyURI := URI annotationPropertyURI := URI individualURI := URI Entities are written in the following way: entity := owlClass | objectProperty | annotationProperty | individual owlClass := 'OWLClass' '(' owlClassURI ')' objectProperty := 'ObjectProperty' '(' objectPropertyURI ')' annotationProperty := 'AnnotationProperty' '(' annotationPropertyURI ')' individual := 'Individual' '(' individualURI ')' The only well-known entity defined in DL Lite us the class with URI owl:Thing , which corresponds to the set of all objects. (In DL literature this is often called the top concept.) 4.2.2 Class Expressions In DL-Lite, there are two types of class expressions. The subClass production defines the classes that can occur in the antecedents of implications; for example, such classes can occur as subclasses in a SubClassOf axiom. The superClass production defines the classes that can occur in the consequents of implications; for example, such classes can occur as superclasses in a SubClassOf axiom. subClass := owlClassURI other than owl:Thing | 'ObjectSomeValuesFrom' '(' objectPropertyExpression owl:Thing ')' superClass := subClass | 'ObjectComplementOf' '(' subClass ')' Review comment from Achille 15:44, 18 March 2008 (EDT) Adding "objectIntersectionOf" in the production of "superClass" should be harmless. 4.2.3 Property Expressions A DL Lite property expression is either named object property or inverse of an property exxpression: objectPropertyExpression := objectPropertyURI | inverseObjectProperty inverseObjectProperty := 'InverseObjectProperty' '(' objectPropertyExpression ')' 4.2.4 Axioms DL Lite axioms are as follows (dataPropertyAxiom is not supported): axiom := classAxiom | objectPropertyAxiom | fact | declaration | entityAnnotation Furthermore, DL-Lite redefines all axioms from the functional-style syntax [ OWL 1.1 Specification ] that refer to the description production. In particular, it restricts various class axioms to appropriate forms of classes, and it disallows DisjointUnion . DL Lite classAxiom production is as follows: classAxiom := subClassOf | equivalentClasses | disjointClasses subClassOf := 'SubClassOf' '(' subClass superClass ')' equivalentClasses := 'EquivalentClasses' '(' subClass subClass { subClass } ')' disjointClasses := 'DisjointClasses' '(' subClass subClass { subClass } ')' classAxiom := subClassOf | equivalentClasses | disjointClasses DL-Lite disallows the use of property chainsare defined in property inclusion axioms; moreover, it disallowsthe use of transitive, asymmetric, reflexive and irreflexive properties. Finally, it redefinesfollowing sections. The domain and rangeglobal restricitons on axioms to usedefined in the new class productions. objectPropertyAxiom := subObjectPropertyOf | equivalentObjectProperties | disjointObjectProperties | inverseObjectProperties | objectPropertyDomain | objectPropertyRange | symmetricObjectProperty subObjectPropertyOf := 'SubObjectPropertyOf' '(' objectPropertyExpression objectPropertyExpression ')' objectPropertyDomain := 'ObjectPropertyDomain' '(' objectPropertyExpression superClass ')' objectPropertyRange := 'ObjectPropertyRange' '(' objectPropertyExpression superClass ')'structural specification [OWL 2 Specification] are not enforced in DL-Lite.

Editor's Note: I assumePlease note that negativeObjectPropertyAssertion is not supported by DL-Lite Finally, DL-Lite disallows axioms aboutData Properties and negative object property assertion, and class membership assertionsare not yet incorporated into DL-Lite in this draft, pending consultation with some DL-Lite are restricted to only atomic classes. Therefore,experts.

DL-Lite supports all OWL 2 entities apart from data properties. The fact axioms ofentities in DL-Lite are defined as follows: factfollows.

The existence of individuals not explicitly presentonly well-known entity defined in DL-Lite is the knowledge base. This design goal enables a straightforward translation of OWL’s semantic conditions into rules, onclass with URI owl:Thing, which most rule-based reasoning engines terminateis interpreted as specified in a finite amount[OWL 2 Semantics].

Furthermore, DL-Lite redefines all axioms from JeremyCarroll 12:02, 28 March 2008 (EDT) first para could perhaps introduce features of OWL-R, not OWL-R DL: e.g. OWL-R is a fairly expressive fragment ofthe functional-style syntax [OWL 1.1 designed2 Specification] that refer to be implementable with relatively simple technology.the restrictions on the complexity are expresseddescription production. In two different ways: OWL-R DLparticular, it restricts the syntaxvarious class axioms to appropriate forms of classes, and it disallows DisjointUnion. The documents to not use features which are harder to implement; whereas OWL-R Full provides a conformance pointproduction for reasoners which actsaxioms about classes in DL-Lite are defined as a partial implementation offollows.

DL-Lite disallows the OWL Full semantics. OWL-R, although just a fragmentuse of OWL 1.1, is quite expressive. An OWL-R DL ontology can use,property chains in property inclusion axioms (simple property inclusions are just like in a nutshell, mostOWL 1.1 language constructs except owl:cardinality, owl:minCardinality, owl11:NegativeObjectPropertyAssertion, owl11:NegativeDataPropertyAssertion, and owl:complementOf. Not all constructs2), it disallows the use of OWL-R DL can be used freely in all places intransitive, asymmetric, reflexive and irreflexive properties, and it redefines the axioms. For example,domain and range axioms to use the new class productions.

Editor's Note: I assume that negativeObjectPropertyAssertion is not supported by DL-Lite

DL-Lite disallows axioms about data properties and negative object property assertion. Furthermore, class membership assertions in SubClassOf axioms, the usage of the constructs on the left-DL-Lite are restricted to only atomic classes. Equality and right-hand side of the implication must followinequality axioms and property membership assertions are the patterns shown in Table 4.1. Table 1. Syntactic Restriction on Descriptionssame as in SubClassOf Axioms Left-Hand Side Right-Hand Side anOWL class a nominal class ( OneOf ) intersection of classes ( ObjectIntersectionOf ) union2. Therefore, the fact axioms of classes ( ObjectUnionOf ) existential quantification to an OWL class ( ObjectSomeValuesFrom ) existential quantification toDL-Lite are defined as follows.

The semanticsfirst variant of language constructs, however, is weakened inOWL-R, called OWL-R FullDL, is intended to mimic the usage patterns ofbe used by OWL 2 DL users who can trade some expressivity for being able to implement reasoning using rule-based systems. OWL-R DL.DL is defined as a syntactic subset of OWL 2 DL -- that is, it places syntactic restrictions on OWL 2 DL axioms. For example, in OWL 1.1 Full (or DL),this definition, one cannot declare an OWL class C1 isto be a subclass of the union of two classes C2 ifand only ifC3. The extensiondefinition of C1OWL-R DL is a subset of the extension of C2.presented completely in Section 4.2.

The second variant OWL-R, called OWL-R Full, that "if and only if" conditionis weakenedintended to "only if." The principles accordingbe used by RDF(S) users who want to which this weakening has been derivedaugment RDF(S) with additional contructs. OWL-R Full ontologies are presented in Section 4.3.1 .thus RDF graphs that are interpreted under a weakened version of the extensional semantic conditions of OWL 2 Full. An equivalent characterizationaxiomatization of the weakened semantics by means ofusing first-order implications is givenprovided in Section 4.3.2 . Table 2 liststhe language constructsform of entailment rules that operate directly on RDF triples. This set of entailment rules provides a useful starting point for practical inference implementation using 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 and are supportedinterested mainly in OWL-R Full. Table 2.the Constructs Supported insemantic axiomatization of OWL-R Full Equality owl:sameAs owl:differentFrom Property Expressions owl:inverseObjectPropertyExpression Property Axioms rdfs:domain rdfs:range owl:FunctionalProperty owl:InverseFunctionalProperty owl11:ReflexiveProperty owl11:IrreflexiveProperty owl:SymmetricProperty owl11:AsymmetricProperty owl:TransitiveProperty rdfs:subPropertyOf owl11:propertyChain owl:equivalentProperties owl11:disjointObjectProperties owl11: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 5.2using first-order implication may skip directly to Section 4.3.2.

The definitions of OWL-R DL and OWL-R DL is a syntactic fragment of OWL 1.1 DL.Full are independent in the fragmentsense that it is definednot onlynecessary to understand one variant in terms of a set of supported constructs, but it also restrictsorder to be able to understand the placesother. Thus, the readers interested in which these constructs can be used. It is based on Description Logic Programs [ DLP ] -- a logic obtained by intersecting description logics with rule-based languages. 5.2.1 Entities OWL-Rthe DL does not impose any restrictions on OWL 1.1 Entities. Therefore, entities defined here areversion of OWL-R can skip to Section 4.2, whereas the same asreaders interested in [ OWL 1.1 Specification ] All entities may have an associated URI.the syntax for writing entity URIs inFull version of OWL-R can skip to Section 4.3.

The relationship between OWL-R DL is as follows: Review comment from JeremyCarroll 12:08, 28 March 2008 (EDT) This list is superfluousand should be deleted. datatypeURI := URI owlClassURI := URI objectPropertyURI := URI dataPropertyURI := URI annotationPropertyURI := URI individualURI := URI Entities are written in the following way: entity := datatype | owlClass | objectProperty | dataProperty | annotationProperty | individual datatype := 'Datatype' '(' datatypeURI ')' owlClass := 'OWLClass' '(' owlClassURI ')' objectProperty := 'ObjectProperty' '(' objectPropertyURI ')' dataProperty := 'DataProperty' '(' dataPropertyURI ')' annotationProperty := 'AnnotationProperty' '(' annotationPropertyURI ')' individual := 'Individual' '(' individualURI ')'OWL-R definesFull is specified precisely in Section 4.4. This clear relationship allows users to switch between the same settwo versions of well-known entities asOWL-R if necessary.

Editor's Note: There is an open issue concerning entailments that follow in the wholeOWL 1.1 language. These entities are identified byFull, but not in OWL-R.

Unlike OWL-R DL, in OWL-R Full there are no syntactic restrictions on the bottom concept.)way language constructs can be used: any RDF graph constitutes a valid OWL-R Full ontology. The unary datatype with URI rdfs:Literalsemantics of language constructs, however, is weakened in OWL-R Full to mimic the setusage patterns of all concrete objects. The datatypes with URIs as mentionedOWL-R DL. For example, in [OWL 1.1 Semantics ]. 5.2.2 Data Ranges A data range expression defines a range over data values. In OWL-R DL,2 Full (or DL), an OWL class C1 is a data range expressionsubclass of C2 if and only if the extension of C1 is restricted to eithera named atomic datatype (the listsubset of datatypes supported bythe extension of C2. In OWL-R DLFull, that "if and only if" condition is identicalweakened to "only if." The oneprinciples according to which this weakening has been derived are presented in [ OWL 1.1Section 4.3.1. An equivalent characterization of the weakened semantics ]) or a datatype restriction, specifiedby applying some facets to limit the value space of an pre-existing datatype. dataRange := datatypeURI | datatypeRestriction 5.2.3 Classes There are three typesmeans of classesfirst-order implications is given in OWL-R. The subClass production definesSection 4.3.2. Table 2 lists the classeslanguage constructs that can occurare supported in OWL-R Full.

OWL-R DL is a SubClassOf axiom. The superClass production definessyntactic profile of OWL 2 DL. The classes that can occurprofile is defined not only in the consequentsterms of implications; for example, such classes can occur as superclasses ina SubClassOf axiom. Finally, the equivClass production definesset of supported constructs, but it also restricts the classes that can occurplaces in an EquivalentClasses axiom. zeroOrOne := '0' | '1' subClass := owlClassURI other than owl:Thing | 'ObjectOneOf' '(' individualURI { individualURI } ')' 'ObjectIntersectionOf' '(' subClass subClass { subClass } ')' | 'ObjectUnionOf' '(' subClass subClass { subClass } ')' | 'ObjectSomeValuesFrom' '(' objectPropertyExpression subClass ')' | 'DataSomeValuesFrom' '(' dataPropertyExpression { dataPropertyExpression } dataRange ')' | 'ObjectHasValue' '(' objectPropertyExpression individualURI ')' | 'DataHasValue' '(' dataPropertyExpression constant ')' superClass := owlClassURI | 'ObjectIntersectionOf' '(' subClass superClass { superClass } ')' | 'ObjectAllValuesFrom' '(' objectPropertyExpression superClass ')' | 'DataAllValuesFrom' '(' dataPropertyExpression { dataPropertyExpression } dataRange ')' | 'ObjectMaxCardinality' '(' zeroOrOne objectPropertyExpression [ subClass ] ')' | 'DataMaxCardinality' '(' zeroOrOne dataPropertyExpressionwhich these constructs can be used. It is based on Description Logic Programs [ dataRangeDLP] ')' | 'ObjectHasValue' '(' objectPropertyExpression individualURI ')' | 'DataHasValue' '(' dataPropertyExpression constant ')' equivClass := owlClassURI other than owl:Thing | 'ObjectIntersectionOf' '(' equivClass equivClass { equivClass } ')' | 'ObjectHasValue' '(' objectPropertyExpression individualURI ')' | 'DataHasValue' '(' dataPropertyExpression constant ')' 5.2.4 Properties-- a logic obtained by intersecting description logics with rule-based languages.

OWL-R constructs used to build more complex properties from existing onesDL does not impose any restrictions on OWL 2 Entities. Therefore, entities defined here are identical tothe ones definedsame as in [OWL 1.12 Specification ]: objectPropertyExpression := objectPropertyURI | inverseObjectProperty inverseObjectProperty := 'InverseObjectProperty' '(' objectPropertyExpression ')' dataPropertyExpression := dataPropertyURI 5.2.5 Axioms OWL-R axioms are as follows: axiom := classAxiom | objectPropertyAxiom | dataPropertyAxiom | fact | declaration | entityAnnotation]. Furthermore, OWL-R redefines all axioms fromdefines the functional-style syntaxsame set of well-known entities as the entire OWL 1.1 Specification that refer to2 language:

• The description production. In particular, it restricts variousclass axioms to usewith URI owl:Thing is the appropriate formset of all objects. (In DL literature this is often called the top concept.)
• The class expressions (i.e. one of subClass , superClass , or equivClass ), and it disallowswith URI owl:Nothing is the DisjointUnion axiom. classAxiom := subClassOf | equivalentClasses | disjointClasses subClassOf := 'SubClassOf' '(' subClass superClass ')' equivalentClasses := 'EquivalentClasses' '(' equivClass equivClass { equivClass } ')' disjointClasses := 'DisjointClasses' '(' subClass subClass { subClass } ')' OWL-R property expression languageempty set of objects. (In DL literature this is very similar to OWL 1.1.often called the only differencebottom concept.)
• The unary datatype with URI rdfs:Literal is that OWL-R restricts property domain and range axioms tothe appropriate formset of class expressions as follows: objectPropertyDomain := 'ObjectPropertyDomain' '(' objectPropertyExpression superClass ')' objectPropertyRange := 'ObjectPropertyRange' '(' objectPropertyExpression superClass ')' dataPropertyDomain := 'DataPropertyDomain' '(' dataPropertyExpression superClass ')' Therefore, the OWL-R objectPropertyAxiom and dataPropertyAxiom 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 Besides objectPropertyDomain , objectPropertyRange , dataPropertyDomain , and dataPropertyRange ,all concrete objects.
• The other non-terminals appearingdatatypes with URIs as mentioned in [OWL 2 Semantics].