OWL LD
Entailment Ruleset and Implementational Notes

Editorial Draft

Editors (in alphabetical order):
Birte Glimm, Ulm University
Aidan Hogan, DERI Galway
Markus Krötzsch, Oxford
Axel Polleres, Siemens

This document—including stylesheets and formatting—is based on the complete OWL 2 Web Ontology Language Profiles document (currently without permission).


Abstract

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.

Status of this Document

Draft

This is an initial informative editors' draft.

Table of Contents

1 Introduction

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):

Conversely, being a terse profile, OWL LD drops support for:

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

1.1 Purpose of This Document

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.

2 Entailment 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:

Table 1. The Semantics of Equality
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

Table 2. The Semantics of Axioms about Properties
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)

Table 3. The Semantics of Classes
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

Table 4. The Semantics of Class Axioms
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

Table 5. The Semantics of Schema Vocabulary
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)

2.1 Rules for Datatype Support

To support datatype reasoning, the following OWL 2 RL/RDF rules can be used.

Table 6. The Semantics of Datatypes
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.

Table 7 Canonicalisation of Literals
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

2.2 Correspondence between RDF-Based and Direct Semantics

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

3 OWL LD Rules in Different Syntaxes (Informative)

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.

Table 8. OWL LD Rules in Different 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

4 Appendix: Grammar for OWL LD

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

5 References

[Linked Data]
Linked Data: Evolving the Web into a Global Data Space Tom Heath, Christian Bizer. Synthesis Lectures on the Semantic Web: Theory and Technology, 1:1, 1-136. Morgan & Claypool, 2011.
[RDFS 3.0]
RDFS 3.0 Jim Hendler. W3C Workshop — RDF Next Steps, 2010.
[Working Ontologist]
Semantic Web for the working ontologist Dean Allemang, Jim Hendler. Morgan-Kaufmann, 2008.
[L2]
Towards a Scalable, Pragmatic Knowledge Representation Language for the Web Florian Fischer, Gulay Ünel, Barry Bishop, Dieter Fensel. Ershov Memorial Conference 2009, pp 124–134.
[OWL 2 Primer]
OWL 2 Web Ontology Language: Direct Semantics Pascal Hitzler, Markus Krötzsch, Bijan Parsia, Peter F. Patel-Schneider, Sebastian Rudolph, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-primer-20091027/. Latest version available at http://www.w3.org/TR/owl-primer/.
[OWL 2 Direct Semantics]
OWL 2 Web Ontology Language: Direct Semantics Boris Motik, Peter F. Patel-Schneider, Bernardo Cuenca Grau, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-direct-semantics-20091027/. Latest version available at http://www.w3.org/TR/owl2-direct-semantics/.
[OWL 2 Profiles]
OWL 2 Web Ontology Language: Profiles Boris Motik, Bernardo Cuenca Grau, Ian Horrocks, Zhe Wu, Achille Fokoue, Carsten Lutz, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-profiles-20091027/. Latest version available at http://www.w3.org/TR/owl2-profiles/.
[OWL 2 RDF Mapping]
OWL 2 Web Ontology Language: Mapping to RDF Graphs Peter F. Patel-Schneider, Boris Motik, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-mapping-to-rdf-20091027/. Latest version available at http://www.w3.org/TR/owl2-mapping-to-rdf/.
[OWL 2 RDF-Based Semantics]
OWL 2 Web Ontology Language: RDF-Based Semantics Michael Schneider, editor. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-rdf-based-semantics-20091027/. Latest version available at http://www.w3.org/TR/owl2-rdf-based-semantics/.
[OWL 2 Specification]
OWL 2 Web Ontology Language: Structural Specification and Functional-Style Syntax Boris Motik, Peter F. Patel-Schneider, Bijan Parsia, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-syntax-20091027/. Latest version available at http://www.w3.org/TR/owl2-syntax/.
[RDF Semantics]
RDF Semantics. Patrick Hayes, ed., W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/. Latest version available as http://www.w3.org/TR/rdf-mt/.
[Turtle Syntax]
Turtle – Terse RDF Triple Language. David Beckett and Tim Berners-Lee, 14 January 2008