Copyright © 2011
This document—including stylesheets and formatting—is based on the complete OWL 2 Web Ontology Language Profiles document (currently without permission).
This document briefly outlines the OWL LD profile and ruleset, which is a terse version of OWL 2 RL whose features are motivated by a survey of prominently used terms in Linked Data vocabularies.
This is an initial informative editors' draft.
Table of Contents |
OWL LD targets Linked Data practitioners [Linked Data] who are looking for a terse, easy-to-publish, easy-to-implement profile of OWL [OWL 2 Primer] which supports the features commonly used in prominent Web vocabularies.
OWL LD is a select syntactic subset of OWL 2 RL [OWL 2 Profiles] , and thus is amenable to rule-based implementation through a subset of the OWL 2 RL/RDF rules (the subset is enumerated later).
In the spirit of terseness, OWL LD omits support for OWL 2 RL features which require blank-nodes in their translation to RDF [OWL 2 RDF Mapping]. Alternatively, one may think of these features as those requiring multiple triples to express in RDF. These omissions are motivated by our survey of Linked Data which indicates that the features of OWL which require blank-nodes to express in RDF are not widely used in prominent Web vocabularies.
In particular, OWL LD offers support for the following RDFS and OWL features (with OWL 2 features in italics):
rdfs:subClassOf ✓rdfs:subPropertyOf ✓rdfs:domain ✓rdfs:range ✓owl:sameAs ✓owl:differentFrom ✓owl:FunctionalProperty ✓owl:InverseFunctionalProperty ✓owl:IrreflexiveProperty ✓owl:SymmetricProperty ✓owl:AsymmetricProperty ✓owl:TransitiveProperty ✓owl:equivalentProperty ✓owl:propertyDisjointWith ✓owl:inverseOf ✓owl:equivalentClass ✓owl:disjointWith ✓Conversely, being a terse profile, OWL LD drops support for:
owl:complementOfowl:disjointUnionOfowl:intersectionOfowl:unionOfowl:oneOfowl:allValuesFromowl:hasSelfowl:hasValueowl:someValuesFromowl:cardinalityowl:maxCardinalityowl:minCardinalityowl:qualifiedMaxCardinalityowl:qualifiedMinCardinalityowl:qualifiedCardinalityowl:hasKeyowl:propertyChainAxiomowl:AllDifferentowl:AllDisjointClassesowl:AllDisjointPropertiesowl:sourceIndiviual, owl:assertionProperty, owl:targetIndividual/owl:targetValueowl:ReflexivePropertyDatatype entailment is included in OWL LD, and we give some pointers on how OWL LD can be extended in that direction.
This selection is motivated by a recent empirical survey of the adoption of OWL features in current Linked Data vocabularies, which showed that OWL features expressible with a single RDF triple are the most widely adopted.
This gives us a clean cut-off for
inclusion/exclusion from OWL LD: we do not drop any other features
of OWL 2 RL. Notably, OWL LD includes some new (blank-node free)
features of OWL 2—viz., owl:AsymmetricProperty,
owl:IrreflexiveProperty, and
owl:propertyDisjointWith—for which we found little
or no adoption in Linked Data, but which meet the other criteria for the profile.
As per our survey, we believe that OWL LD still has good competency with respect to the lightweight subset of OWL (implicitly) recommended for use within the Linked Data community [Linked Data]. By dropping the features of OWL which are not so prominently used, we arrive at a much simpler profile of OWL, with lower costs for implementing, and supporting.
Having only single-triple expressible OWL features makes OWL LD ontologies easier to parse, validate and process (e.g., using line-based processing tools). Systems need no longer perform (conjunctive) graph pattern matching to extract axioms, or to support variable length lists.
Further, by dropping the aforementioned features of OWL, we forego many of
the difficulties current rule-based engines would encounter if supporting the
full OWL 2 RL/RDF ruleset. For implementing the corresponding ruleset OWL LD/RDF,
engines no longer need special support for lists (as otherwise required by, e.g.,
owl:unionOf, owl:intersectionOf, etc.), or
for quaterary atoms or the creation of blank-nodes (as otherwise required by
owl:hasKey and owl:propertyChainAxiom).
In summary, with the exception of datatypes, OWL LD can be supported as a set of
"simple RDF rules" in the spirit of RDFS or N3. We thus provide versions of
the entire entailment ruleset for RIF, Jena Rules, SPIN and N3; with the exception
of datatypes, these documents enable compliant OWL LD support for any off-the-shelf
engine which understands one of these rule syntaxes.
Finally, we provide the OWL LD syntax. Ontologies which abide by the outlined syntax are also valid OWL 2 DL and OWL 2 RL ontologies, where we provide a known correspondence between entailments for OWL LD ontologies under the RDF-Based Semantics of OWL 2 and the Direct Semantics. However, as per OWL 2 RL, the OWL LD/RDF ruleset is applicable for arbitrary RDF graphs.
We note that the OWL LD profile is similar in principle to earlier proposals including RDFS-Plus [Working Ontologist], RDFS 3.0 [RDFS 3.0] and L2 [L2]; albeit arrived at from different selection criteria.
This document provides the entailment rules for the OWL LD profile. The rules are a subset of the OWL 2 RL/RDF ruleset. Herein, we follow the conventions and preliminaries set out in the OWL 2 Profile document which outlines the OWL 2 RL profile and the OWL 2 RL/RDF rules.
This section presents the OWL LD entailment ruleset, which is a subset of the OWL 2 RL/RDF entailment rules. We refer the interested reader to the OWL 2 RL Profile specification [OWL 2 Profiles] for extended preliminaries referring to the formal properties of the ruleset; here, we instead summarise the most important aspects:
if") apply for an empty graph, such that they essentially represent "axiomatic triples" which always hold true;false is used to indicate an inconsistency, where the facts satisfying the condition of the rule form a logical contradiction.| If | then | |
|---|---|---|
| eq-ref | T(?s, ?p, ?o) | T(?s, owl:sameAs, ?s) T(?p, owl:sameAs, ?p) T(?o, owl:sameAs, ?o) |
| eq-sym | T(?x, owl:sameAs, ?y) | T(?y, owl:sameAs, ?x) |
| eq-trans | T(?x, owl:sameAs, ?y) T(?y, owl:sameAs, ?z) | T(?x, owl:sameAs, ?z) |
| eq-rep-s | T(?s, owl:sameAs, ?s') T(?s, ?p, ?o) | T(?s', ?p, ?o) |
| eq-rep-p | T(?p, owl:sameAs, ?p') T(?s, ?p, ?o) | T(?s, ?p', ?o) |
| eq-rep-o | T(?o, owl:sameAs, ?o') T(?s, ?p, ?o) | T(?s, ?p, ?o') |
| eq-diff1 | T(?x, owl:sameAs, ?y) T(?x, owl:differentFrom, ?y) | false |
| If | then | ||
|---|---|---|---|
| prp-ap | T(ap, rdf:type, owl:AnnotationProperty) | for each built-in annotation property of OWL 2 RL | |
| prp-dom | T(?p, rdfs:domain, ?c) T(?x, ?p, ?y) | T(?x, rdf:type, ?c) | |
| prp-rng | T(?p, rdfs:range, ?c) T(?x, ?p, ?y) | T(?y, rdf:type, ?c) | |
| prp-fp | T(?p, rdf:type, owl:FunctionalProperty) T(?x, ?p, ?y1) T(?x, ?p, ?y2) | T(?y1, owl:sameAs, ?y2) | |
| prp-ifp | T(?p, rdf:type, owl:InverseFunctionalProperty) T(?x1, ?p, ?y) T(?x2, ?p, ?y) | T(?x1, owl:sameAs, ?x2) | |
| prp-irp | T(?p, rdf:type, owl:IrreflexiveProperty) T(?x, ?p, ?x) | false | |
| prp-symp | T(?p, rdf:type, owl:SymmetricProperty) T(?x, ?p, ?y) | T(?y, ?p, ?x) | |
| prp-asyp | T(?p, rdf:type, owl:AsymmetricProperty) T(?x, ?p, ?y) T(?y, ?p, ?x) | false | |
| prp-trp | T(?p, rdf:type, owl:TransitiveProperty) T(?x, ?p, ?y) T(?y, ?p, ?z) | T(?x, ?p, ?z) | |
| prp-spo1 | T(?p1, rdfs:subPropertyOf, ?p2) T(?x, ?p1, ?y) | T(?x, ?p2, ?y) | |
| prp-eqp1 | T(?p1, owl:equivalentProperty, ?p2) T(?x, ?p1, ?y) | T(?x, ?p2, ?y) | |
| prp-eqp2 | T(?p1, owl:equivalentProperty, ?p2) T(?x, ?p2, ?y) | T(?x, ?p1, ?y) | |
| prp-pdw | T(?p1, owl:propertyDisjointWith, ?p2) T(?x, ?p1, ?y) T(?x, ?p2, ?y) | false | |
| prp-inv1 | T(?p1, owl:inverseOf, ?p2) T(?x, ?p1, ?y) | T(?y, ?p2, ?x) | |
| prp-inv2 | T(?p1, owl:inverseOf, ?p2) T(?x, ?p2, ?y) | T(?y, ?p1, ?x) |
| If | then | |
|---|---|---|
| cls-thing | T(owl:Thing, rdf:type, owl:Class) | |
| cls-nothing1 | T(owl:Nothing, rdf:type, owl:Class) | |
| cls-nothing2 | T(?x, rdf:type, owl:Nothing) | false |
| If | then | |
|---|---|---|
| cax-sco | T(?c1, rdfs:subClassOf, ?c2) T(?x, rdf:type, ?c1) | T(?x, rdf:type, ?c2) |
| cax-eqc1 | T(?c1, owl:equivalentClass, ?c2) T(?x, rdf:type, ?c1) | T(?x, rdf:type, ?c2) |
| cax-eqc2 | T(?c1, owl:equivalentClass, ?c2) T(?x, rdf:type, ?c2) | T(?x, rdf:type, ?c1) |
| cax-dw | T(?c1, owl:disjointWith, ?c2) T(?x, rdf:type, ?c1) T(?x, rdf:type, ?c2) | false |
| If | then | |
|---|---|---|
| scm-cls | T(?c, rdf:type, owl:Class) | T(?c, rdfs:subClassOf, ?c) T(?c, owl:equivalentClass, ?c) T(?c, rdfs:subClassOf, owl:Thing) T(owl:Nothing, rdfs:subClassOf, ?c) |
| scm-sco | T(?c1, rdfs:subClassOf, ?c2) T(?c2, rdfs:subClassOf, ?c3) | T(?c1, rdfs:subClassOf, ?c3) |
| scm-eqc1 | T(?c1, owl:equivalentClass, ?c2) | T(?c1, rdfs:subClassOf, ?c2) T(?c2, rdfs:subClassOf, ?c1) |
| scm-eqc2 | T(?c1, rdfs:subClassOf, ?c2) T(?c2, rdfs:subClassOf, ?c1) | T(?c1, owl:equivalentClass, ?c2) |
| scm-op | T(?p, rdf:type, owl:ObjectProperty) | T(?p, rdfs:subPropertyOf, ?p) T(?p, owl:equivalentProperty, ?p) |
| scm-dp | T(?p, rdf:type, owl:DatatypeProperty) | T(?p, rdfs:subPropertyOf, ?p) T(?p, owl:equivalentProperty, ?p) |
| scm-spo | T(?p1, rdfs:subPropertyOf, ?p2) T(?p2, rdfs:subPropertyOf, ?p3) | T(?p1, rdfs:subPropertyOf, ?p3) |
| scm-eqp1 | T(?p1, owl:equivalentProperty, ?p2) | T(?p1, rdfs:subPropertyOf, ?p2) T(?p2, rdfs:subPropertyOf, ?p1) |
| scm-eqp2 | T(?p1, rdfs:subPropertyOf, ?p2) T(?p2, rdfs:subPropertyOf, ?p1) | T(?p1, owl:equivalentProperty, ?p2) |
| scm-dom1 | T(?p, rdfs:domain, ?c1) T(?c1, rdfs:subClassOf, ?c2) | T(?p, rdfs:domain, ?c2) |
| scm-dom2 | T(?p2, rdfs:domain, ?c) T(?p1, rdfs:subPropertyOf, ?p2) | T(?p1, rdfs:domain, ?c) |
| scm-rng1 | T(?p, rdfs:range, ?c1) T(?c1, rdfs:subClassOf, ?c2) | T(?p, rdfs:range, ?c2) |
| scm-rng2 | T(?p2, rdfs:range, ?c) T(?p1, rdfs:subPropertyOf, ?p2) | T(?p1, rdfs:range, ?c) |
To support datatype reasoning, the following OWL 2 RL/RDF rules can be used.
| If | then | ||
|---|---|---|---|
| dt-type1 | T(dt, rdf:type, rdfs:Datatype) | for each datatype dt supported in OWL 2 RL | |
| dt-type2 | 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 | |
| dt-eq | T(lt1, owl:sameAs, lt2) | for all literals lt1 and lt2 with the same data value | |
| dt-diff | T(lt1, owl:differentFrom, lt2) | for all literals lt1 and lt2 with different data values | |
| dt-not-type | 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 |
An other alternative for supporting datatype entailment in OWL LD is to canonicalise all literals when the ontology is
loaded. Once all literals are normalised, the rules in Table 6 can be replaced
by a single rule that derives a
contradiction when T(lt1, owl:sameAs,
lt2) is derived but lt1 is not
equal to lt2 under string comparison.
The canonicalisation of literals can be performed according to Table 7.
| Literal | Canonicalised Literal | Comment |
|---|---|---|
| "lit" | "lit" | |
| "lit"@lt | "lit"@lt' | lt' is like lt but all lowercase
|
| "lit"^^xsd:string | "lit" | |
| "lit"^^xsd:decimal "lit"^^xsd:integer "lit"^^xsd:nonPositiveInteger "lit"^^xsd:negativeInteger "lit"^^xsd:long "lit"^^xsd:int "lit"^^xsd:short "lit"^^xsd:byte "lit"^^xsd:nonNegativeInteger "lit"^^xsd:unsignedLong "lit"^^xsd:unsignedInt "lit"^^xsd:unsignedShort "lit"^^xsd:unsignedByte "lit"^^xsd:unsignedInteger | "lit'"^^xsd:decimal | lit' is like lit but all leading and
trailing zeros removed and decimal point omitted if the fractional part is zero
|
| "lit"^^xsd:float | "lit'"^^xsd:float | lit' is concat("mantissa", "E", "exponent")
(e.g., "100.3"^^xsd:float becomes "1.00300003E2"^^xsd:float)
|
| "lit"^^xsd:double | "lit'"^^xsd:double | lit' is concat("mantissa", "E", "exponent")
|
| "lit"^^xsd:dateTime | "lit'"^^xsd:dateTime | lit' like lit but normalised to
Z timezone if timezone is given and the time portion allows at most 9 fractional seconds, which are rounded to 6 fractional seconds with trailing zeros removed
|
| "lit"^^xsd:time | "lit'"^^xsd:time | lit' like lit but normalised to
Z timezone if timezone is given and the time portion allows at most 9 fractional seconds, which are rounded to 6 fractional seconds with trailing zeros removed
|
| "lit"^^xsd:boolean | "lit'"^^xsd:boolean | lit' is lit normalised to all
lowercase true or false
|
As for the OWL 2 RL profile, one can show that under certain restrictions the above rules materialise consequences that hold under both the OWL 2 Direct and the OWL 2 RDF-Based Semantics.
Theorem OS1. Let R contain the rules from Table 1 to Table 6. Furthermore, let O1 and O2 be OWL 2 ontologies that satisfy the OWL LD grammar and, additionally, the following properties:
Furthermore, let RDF(O1) and RDF(O2) be translations of O1 and O2, respectively, into RDF graphs as specified in the OWL 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 — that is, T(s, p, o) represents an RDF triple with the subject s, predicate p, and the object o. Then, O1 entails O2 under the OWL 2 Direct Semantics [OWL 2 Direct Semantics] if and only if FO(RDF(O1)) ∪ R entails FO(RDF(O2)) under the standard first-order semantics.
Proof Sketch. The OWL LD grammar implies that O1 does not contain complex class expressions. Thus, all axioms in O1 are fully normalised — that is, that all class expressions in the axioms are of depth at most one. Let DLP(O1) be the set of rules obtained by translating O1 into a set of rules as in Description Logic Programs [DLP].
Consider now each assertion A ∈ O2 that is entailed by DLP(O1) (or, equivalently, by O1). Let dt be a derivation tree for A from DLP(O1). By examining the set of OWL LD constructs, it is possible to see that each such tree can be transformed to a derivation tree dt' for FO(RDF(A)) from FO(RDF(O1)) ∪ R. Each assertion B occurring in dt is of the form as specified in the theorem. The tree dt' can, roughly speaking, be obtained from dt by replacing each assertion B with FO(RDF(B)) and by replacing each rule from DLP(O1) with a corresponding rule from Tables 1–6. Consequently, FO(RDF(O1)) ∪ R entails FO(RDF(A)).
Since no IRI in O1 is used as both an
individual and a class or a property, FO(RDF(O1)) ∪
R does not entail a triple of the form T(a:i1, owl:sameAs, a:i2) where either a:i1
or a:i2 is used in O1 as a class or a
property. This allows for transforming a derivation tree for FO(RDF(A)) from FO(RDF(O1)) ∪ R to a derivation tree for A from DLP(O1) in a way that is analogous to the previous case. QED.
Although the OWL LD grammar is very restrictive, the above theorem no longer holds when we omit the datatype rules. This is because without datatype support, we miss, for example, the entailment of data property assertion that use different literals to represent the same data value. Consider an ontology O1 containing the triple:
ex:a ed:dp "42"^^xsd:int .
The ontology entails an ontology O2 consisting of the triple:
ex:a ed:dp "42"^^xsd:integer .
With the rules from Table 6 the entailment is derived as follows:
dt-type2: "42"^^xsd:int a xsd:int .
dt-type2: "42"^^xsd:int a xsd:integer .
dt-eq: "42"^^xsd:int owl:sameAs "42"^^xsd:integer .
One can now apply the rule eq-rep-o to the triple from
O1 and the above triple to derive the triple in
O2.
Apart from not recognizing different form that a data value can have, one further misses contradictions due to datatype resoning. For example, let O1 contain the triples:
ex:a ex:dp "42"^^xsd:integer . ex:dp rdfs:range xsd:string .
The following (relevant) datatype rules apply:
dt-type2: "42"^^xsd:integer a xsd:integer .
prp-rng: "42"^^xsd:integer a xsd:string .
dt-not-type: false
If datatype entailment is not supported, we can only show a weaker form of correspondence that only holds for ontologies that do not contain literals. In the following, note the additional condition that the "correspondence ontology" does not contain DataPropertyAssertion axioms.
Theorem OS2. Let R contain the rules from Tables 1–5. Furthermore, let O1 and O2 be OWL 2 ontologies that satisfy the OWL LD grammar and, additionally, the following properties:
Furthermore, let RDF(O1) and RDF(O2) be translations of O1 and O2, respectively, into RDF graphs as specified in the OWL 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 — that is, T(s, p, o) represents an RDF triple with the subject s, predicate p, and the object o. Then, O1 entails O2 under the OWL 2 Direct Semantics [OWL 2 Direct Semantics] if and only if FO(RDF(O1)) ∪ R entails FO(RDF(O2)) under the standard first-order semantics.
A proof is now analogous to the proof of Theorem OS1.
Herein, we provide the OWL LD/RDF rules expressed using popular RDF-based rule syntaxes. These documents enable reasoning (with the exception of datatype support) for the OWL LD profile to be used in engines which support one of the given syntaxes.
| Syntax | Support for false
| Status | File | Implementations |
|---|---|---|---|---|
| Notation3 (N3) | Individuals in body typed owl:Nothing
| draft/untested
| owl-ld.n3 | N3 Resources |
| SPARQL Inferencing Notation (SPIN) | Uses built-in SPIN representation | draft/untested
| owl-ld.xml | TopBraid SPIN API |
| Jena Rules | Individuals in body typed owl:Nothing
| draft/untested
| owl-ld.jr | Jena homepage |
| Rule Interchange Format (RIF) | Uses rif:error
| draft/untested
| owl-ld.rif (Presentation syntax) | RIF implementations page |
The OWL LD/RDF entailment ruleset outlined herein is applicable for arbtirary RDF graphs. Rule-based support for OWL LD thus requires no restrictions on use of the vocabulary. However, tools supporting OWL LD documents under the Direct Semantics require that certain restrictions are placed on the use of OWL LD. These restrictions are specified in terms of a grammar. The grammar outlined herein also allows for the correspondence theorems outlined earlier.
The grammar of OWL LD consists of the general definitions from Section 13.1 of the OWL 2 Specification [OWL 2 Specification], as well as the following productions.
Class := IRI
Datatype := IRI
ObjectProperty := IRI
DataProperty := IRI
AnnotationProperty := IRI
Individual := NamedIndividual | AnonymousIndividual
NamedIndividual := IRI
AnonymousIndividual := nodeID
Literal := typedLiteral | stringLiteralNoLanguage | stringLiteralWithLanguage
typedLiteral := lexicalForm '^^' Datatype
lexicalForm := quotedString
stringLiteralNoLanguage := quotedString
stringLiteralWithLanguage := quotedString languageTag
ObjectPropertyExpression :=
ObjectProperty other than
owl:topObjectProperty and owl:bottomObjectProperty
DataPropertyExpression := DataProperty other than
owl:topDataProperty and owl:bottomDataProperty
ClassExpression := Class other than owl:Thing
Axiom := Declaration | ClassAxiom | ObjectPropertyAxiom | DataPropertyAxiom | Assertion | AnnotationAxiom
ClassAxiom := SubClassOf | EquivalentClasses | DisjointClasses
SubClassOf := 'SubClassOf' '(' axiomAnnotations ClassExpression ClassExpression ')'
EquivalentClasses :=
'EquivalentClasses' '(' axiomAnnotations ClassExpression ClassExpression { ClassExpression } ')'
DisjointClasses := 'DisjointClasses' '(' axiomAnnotations ClassExpression ClassExpression ')'
ObjectPropertyAxiom :=
SubObjectPropertyOf | EquivalentObjectProperties |
DisjointObjectProperties | InverseObjectProperties |
ObjectPropertyDomain | ObjectPropertyRange |
FunctionalObjectProperty | InverseFunctionalObjectProperty |
IrreflexiveObjectProperty |
SymmetricObjectProperty | AsymmetricObjectProperty
TransitiveObjectProperty
SubObjectPropertyOf := 'SubObjectPropertyOf' '(' axiomAnnotations ObjectPropertyExpression ObjectPropertyExpression ')'
EquivalentObjectProperties := 'EquivalentObjectProperties' '(' axiomAnnotations ObjectPropertyExpression ObjectPropertyExpression { ObjectPropertyExpression } ')'
DisjointObjectProperties := 'DisjointObjectProperties' '(' axiomAnnotations ObjectPropertyExpression ObjectPropertyExpression ')'
InverseObjectProperties := 'InverseObjectProperties' '(' axiomAnnotations ObjectPropertyExpression ObjectPropertyExpression ')'
ObjectPropertyDomain := 'ObjectPropertyDomain' '(' axiomAnnotations ObjectPropertyExpression ClassExpression ')'
ObjectPropertyRange := 'ObjectPropertyRange' '(' axiomAnnotations ObjectPropertyExpression ClassExpression ')'
FunctionalObjectProperty := 'FunctionalObjectProperty' '(' axiomAnnotations ObjectPropertyExpression ')'
InverseFunctionalObjectProperty := 'InverseFunctionalObjectProperty' '(' axiomAnnotations ObjectPropertyExpression ')'
ReflexiveObjectProperty := 'ReflexiveObjectProperty' '(' axiomAnnotations ObjectPropertyExpression ')'
IrreflexiveObjectProperty := 'IrreflexiveObjectProperty' '(' axiomAnnotations ObjectPropertyExpression ')'
SymmetricObjectProperty := 'SymmetricObjectProperty' '(' axiomAnnotations ObjectPropertyExpression ')'
AsymmetricObjectProperty := 'AsymmetricObjectProperty' '(' axiomAnnotations ObjectPropertyExpression ')'
TransitiveObjectProperty := 'TransitiveObjectProperty' '(' axiomAnnotations ObjectPropertyExpression ')'
DataPropertyAxiom :=
SubDataPropertyOf | EquivalentDataProperties | DisjointDataProperties |
DataPropertyDomain | DataPropertyRange | FunctionalDataProperty
SubDataPropertyOf := 'SubDataPropertyOf' '(' axiomAnnotations DataPropertyExpression DataPropertyExpression ')'
EquivalentDataProperties := 'EquivalentDataProperties' '(' axiomAnnotations DataPropertyExpression DataPropertyExpression { DataPropertyExpression } ')'
DisjointDataProperties := 'DisjointDataProperties' '(' axiomAnnotations DataPropertyExpression DataPropertyExpression ')'
DataPropertyDomain := 'DataPropertyDomain' '(' axiomAnnotations DataPropertyExpression ClassExpression ')'
DataPropertyRange := 'DataPropertyRange' '(' axiomAnnotations DataPropertyExpression DataRange ')'
FunctionalDataProperty := 'FunctionalDataProperty' '(' axiomAnnotations DataPropertyExpression ')'
Assertion :=
SameIndividual | DifferentIndividuals | ClassAssertion |
ObjectPropertyAssertion | DataPropertyAssertion
SameIndividual := 'SameIndividual' '(' axiomAnnotations Individual Individual { Individual } ')'
DifferentIndividuals := 'DifferentIndividuals' '(' axiomAnnotations Individual Individual ')'
ClassAssertion := 'ClassAssertion' '(' axiomAnnotations ClassExpression Individual ')'
ObjectPropertyAssertion := 'ObjectPropertyAssertion' '(' axiomAnnotations ObjectPropertyExpression Individual Individual ')'
DataPropertyAssertion := 'DataPropertyAssertion' '(' axiomAnnotations DataPropertyExpression Individual Literal ')'