Web Ontology Language (OWL) Abstract Syntax and Semantics
Section 4. Mapping to RDF Graphs

Editors:
Peter F. Patel-Schneider, Bell Labs Research, Lucent Technologies
Ian Horrocks, Department of Computer Science, University of Manchester

Contents


4. Mapping to RDF Graphs

The exchange syntax for OWL is RDF/XML [RDF Syntax], as specified in the OWL Reference Description [OWL Reference]. Further, the meaning of an OWL ontology in RDF/XML is determined only from the RDF graph [RDF Concepts] that results from the RDF parsing of the RDF/XML document. Thus one way of translating an OWL ontology in abstract syntax form into the exchange syntax is by giving a transformation of each directive into a collection of triples. As all OWL Lite constructs are special cases of constructs in the full abstract syntax, transformations are only provided for the OWL DL versions.

The syntax for triples used here is the one used in the RDF Model Theory [RDF MT]. In this variant, qualified names are allowed. As detailed in the RDF Model Theory, to turn this syntax into the standard one just expand the qualified names into URI references in the standard RDF manner by concatenating the namespace name with the local name, using the standard OWL namespaces.

4.1. Translation to RDF Graphs

The Transformation Table gives transformation rules that transform the abstract syntax to the OWL exchange syntax. In a few cases, notably for the DifferentIndividuals construct, there are different transformation rules. In such cases either rule can be chosen, resulting in a non-deterministic translation. In a few other cases, notably for class and property axioms, there are triples that may or may not be generated. These triples are indicated by flagging them with [opt]. In a couple of cases one of two triples must be generated. This is indicated by separating the triples with OR. These non-determinisms allow the generation of more RDF Graphs.

The left column of the table gives a piece of syntax (S), the center column gives its transformation (T(S)), and the right column gives an identifier for the main node of the transformation (M(T(S))), but only for syntactic constructs that can occur as pieces of directives. Repeating components are listed using ellipses, as in description1; … descriptionn, this form allows easy specification of the transformation for all values of n allowed in the syntax. Optional portions of the abstract syntax (enclosed in square brackets) are optional portions of the transformation (signified by square brackets). As well, for any of the built-in OWL datatypes, rdfs:Literal, built-in OWL classes, built-in OWL annotation properties, and built-in OWL ontology properties the first rdf:type triple in the translation of it or any axiom for it is optional.

Some transformations in the table are for directives. Other transformations are for parts of directives. The last transformation is for sequences, which are not part of the abstract syntax per se. This last transformation is used to make some of the other transformations more compact and easier to read.

For many directives these transformation rules call for the transformation of components of the directive using other transformation rules. When the transformation of a component is used as the subject or object of a triple, even an optional triple, the transformation of the construct is part of the production (but only once per production) and the main node of that transformation should be used for that node of the triple.

Bnode identifiers here must be taken as local to each transformation, i.e., different identifiers should be used for each invocation of a transformation rule. Ontologies without a name are given a bnode as their main node; ontologies with a name use that name as their main node; this node is referred to as O below.

Transformation to Triples
Abstract Syntax (and sequences) - S Transformation - T(S) Main Node - M(T(S))
Ontology(O directive1 … directiven) O rdf:type owl:Ontology .
T(directive1) … T(directiven)
Ontology(directive1 … directiven) O rdf:type owl:Ontology .
T(directive1) … T(directiven)
Annotation(ontologyPropertyID URIreference) ontologyPropertyID rdf:type owl:OntologyProperty .
O ontologyPropertyID URIreference .
URIreference rdf:type owl:Ontology .
Annotation(annotationPropertyID URIreference) annotationPropertyID rdf:type owl:AnnotationProperty .
O annotationPropertyID URIreference .
Annotation(annotationPropertyID dataLiteral) annotationPropertyID rdf:type owl:AnnotationProperty .
O annotationPropertyID T(dataLiteral) .
Annotation(annotationPropertyID individual) annotationPropertyID rdf:type owl:AnnotationProperty .
O annotationPropertyID T(individual) .
datatypeID datatypeID rdf:type rdfs:Datatype . datatypeID
classID classID rdf:type owl:Class .
classID rdf:type rdfs:Class . [opt]
classID
individualID individualID
datavaluedPropertyID datavaluedPropertyID rdf:type owl:DatatypeProperty .
datavaluedPropertyID rdf:type rdf:Property . [opt]
datavalued-
PropertyID
individualvaluedPropertyID individualvaluedPropertyID rdf:type owl:ObjectProperty .
individualvaluedPropertyID rdf:type rdf:Property . [opt]
individualvalued-
PropertyID
dataLiteral dataLiteral dataLiteral
Individual(iID annotation1 … annotationm
      type(type1)type(typen)
      value(pID1 v1)value(pIDk vk))
iID T(annotation1) . … iID T(annotationm) .
iID rdf:type T(type1) . … iID rdf:type T(typen) .
iID T(pID1) T(v1) . … iID T(pIDk) T(vk) .
iID
Individual(annotation1 … annotationm
      type(type1)type(typen)
      value(pID1 v1)value(pIDk vk))
_:x T(annotation1) . … _:x T(annotationm) .
_:x rdf:type T(type1) . … _:x rdf:type T(typen) .
_:x T(pID1) T(v1) . … _:x T(pIDk) T(vk) .
_:x
SameIndividual(iID1 … iIDn) iIDi owl:sameIndividualAs iIDi+1 . 1≤i<n
iIDi owl:sameIndividualAs iIDj . [opt] 1≤i≠j≤n
DifferentIndividuals(iID1 … iIDn) iIDi owl:differentFrom iIDj . OR
iIDj owl:differentFrom iIDi . 1≤i<j≤n
iIDj owl:differentFrom iIDi . [opt] 1≤i≠j≤n
DifferentIndividuals(iID1 … iIDn) _:x rdf:type owl:AllDifferent .
_:x owl:distinctMembers T(SEQ iID1 … iIDn)
Class(classID [Deprecated] partial
      annotation1 … annotationm
      description1 … descriptionn)
classID rdf:type owl:Class .
classID rdf:type rdfs:Class . [opt]
[classID rdf:type owl:DeprecatedClass .]
classID T(annotation1) . … classID T(annotationm) .
classID rdfs:subClassOf T(description1) . …
classID rdfs:subClassOf T(descriptionn) .
Class(classID [Deprecated] complete
      annotation1 … annotationm
      description1 … descriptionn)
classID rdf:type owl:Class .
classID rdf:type rdfs:Class . [opt]
[classID rdf:type owl:DeprecatedClass .]
classID T(annotation1) . … classID T(annotationm) .
classID owl:intersectionOf T(SEQ description1…descriptionn) .
Class(classID [Deprecated] complete
      annotation1 … annotationm
      description)
classID rdf:type owl:Class .
classID rdf:type rdfs:Class . [opt]
[classID rdf:type owl:DeprecatedClass .]
classID T(annotation1) . … classID T(annotationm) .
classID owl:equivalentClass T(description) .
Class(classID [Deprecated] complete
      annotation1 … annotationm
      unionOf(description1 … descriptionn))
classID rdf:type owl:Class .
classID rdf:type rdfs:Class . [opt]
[classID rdf:type owl:DeprecatedClass .]
classID T(annotation1) . … classID T(annotationm) .
classID owl:unionOf T(SEQ description1…descriptionn) .
Class(classID [Deprecated] complete
      annotation1 … annotationm
      complementOf(description))
classID rdf:type owl:Class .
classID rdf:type rdfs:Class . [opt]
[classID rdf:type owl:DeprecatedClass .]
classID T(annotation1) . … classID T(annotationm) .
classID owl:complementOf T(description) .
EnumeratedClass(classID [Deprecated]
      annotation1 … annotationm
      iID1 … iIDn)
classID rdf:type owl:Class .
classID rdf:type rdfs:Class . [opt]
[classID rdf:type owl:DeprecatedClass .]
classID T(annotation1) . … classID T(annotationm) .
classID owl:oneOf T(SEQ iID1…iIDn) .
DisjointClasses(description1 … descriptionn) T(descriptioni) owl:disjointWith T(descriptionj) . OR
T(descriptionj) owl:disjointWith T(descriptioni) . 1≤i<j≤n
T(descriptioni) owl:disjointWith T(descriptionj) . [opt] 1≤i≠j≤n
EquivalentClasses(description1 … descriptionn) T(descriptioni) owl:equivalentClass T(descriptioni+1) . 1≤i<n
T(descriptioni) owl:equivalentClass T(descriptionj) . [opt] 1≤i,j≤n
SubClassOf(description1 description2) T(description1) rdfs:subClassOf T(description2) .
Datatype(datatypeID [Deprecated]
      annotation1 … annotationm )
datatypeID rdf:type rdfs:Datatype .
datatypeID rdf:type rdfs:Class . [opt]
[datatypeID rdf:type owl:DeprecatedClass .]
datatypeID T(annotation1) . … datatypeID T(annotationm) .
unionOf(description1 … descriptionn) _:x rdf:type owl:Class .
_:x rdf:type rdfs:Class . [opt]
_:x owl:unionOf T(SEQ description1…descriptionn) .
_:x
intersectionOf(description1 … descriptionn) _:x rdf:type owl:Class .
_:x rdf:type rdfs:Class . [opt]
_:x owl:intersectionOf T(SEQ description1…descriptionn) .
_:x
complementOf(description) _:x rdf:type owl:Class .
_:x rdf:type rdfs:Class . [opt]
_:x owl:complementOf T(description) .
_:x
oneOf(iID1 … iIDn) _:x rdf:type owl:Class .
_:x rdf:type rdfs:Class . [opt]
_:x owl:oneOf T(SEQ iID1…iIDn) .
_:x
oneOf(v1 … vn) _:x rdf:type owl:DataRange .
_:x rdf:type rdfs:Class . [opt]
_:x owl:oneOf T(SEQ v1 … vn) .
_:x
restriction(ID component1 … componentn)
(With at least two components)
_:x rdf:type owl:Class .
_:x rdf:type rdfs:Class . [opt]
_:x owl:intersectionOf
  T(SEQ(restriction(ID component1) … restriction(ID componentn))) .
_:x
restriction(ID allValuesFrom(range)) _:x rdf:type owl:Restriction .
_:x rdf:type owl:Class . [opt]
_:x rdf:type rdfs:Class . [opt]
_:x owl:onProperty T(ID) .
_:x owl:allValuesFrom T(range) .
_:x
restriction(ID someValuesFrom(required)) _:x rdf:type owl:Restriction .
_:x rdf:type owl:Class . [opt]
_:x rdf:type rdfs:Class . [opt]
_:x owl:onProperty T(ID) .
_:x owl:someValuesFrom T(required) .
_:x
restriction(ID value(value)) _:x rdf:type owl:Restriction .
_:x rdf:type owl:Class . [opt]
_:x rdf:type rdfs:Class . [opt]
_:x owl:onProperty T(ID) .
_:x owl:hasValue T(value) .
_:x
restriction(ID minCardinality(min)) _:x rdf:type owl:Restriction .
_:x rdf:type owl:Class . [opt]
_:x rdf:type rdfs:Class . [opt]
_:x owl:onProperty T(ID) .
_:x owl:minCardinality "min"^^xsd:nonNegativeInteger .
_:x
restriction(ID maxCardinality(max)) _:x rdf:type owl:Restriction .
_:x rdf:type owl:Class . [opt]
_:x rdf:type rdfs:Class . [opt]
_:x owl:onProperty T(ID) .
_:x owl:maxCardinality "max"^^xsd:nonNegativeInteger .
_:x
restriction(ID cardinality(card)) _:x rdf:type owl:Restriction .
_:x rdf:type owl:Class . [opt]
_:x rdf:type rdfs:Class . [opt]
_:x owl:onProperty T(ID) .
_:x owl:cardinality "card"^^xsd:nonNegativeInteger .
_:x
DatatypeProperty(ID [Deprecated]
      annotation1 … annotationm
      super(super1)super(supern)
      domain(domain1)
      domain(domaink)
      range(range1)
      range(rangeh)
      [Functional])
ID rdf:type owl:DatatypeProperty .
ID rdf:type rdf:Property . [opt]
[ID rdf:type owl:DeprecatedProperty .]
ID T(annotation1) . … ID T(annotationm) .
ID rdfs:subPropertyOf T(super1) . …
ID rdfs:subPropertyOf T(supern) .
ID rdfs:domain T(domain1) . …
ID rdfs:domain T(domaink) .
ID rdfs:range T(range1) . …
ID rdfs:range T(rangeh) .
[ID rdf:type owl:FunctionalProperty . ]
ObjectProperty(ID [Deprecated]
      annotation1 … annotationm
      super(super1)super(supern)
      domain(domain1)
      domain(domaink)
      range(range1)
      range(rangeh)
      [inverseOf(inverse)]
      [Functional |
       InverseFunctional |
       Transitive])
      [Symmetric]
ID rdf:type owl:ObjectProperty .
    [opt if one of the last three triples is included]
ID rdf:type rdf:Property . [opt]
[ID rdf:type owl:DeprecatedProperty .]
ID T(annotation1) . … ID T(annotationm) .
ID rdfs:subPropertyOf T(super1) . …
ID rdfs:subPropertyOf T(supern) .
ID rdfs:domain T(domain1) . …
ID rdfs:domain T(domaink) .
ID rdfs:range T(range1) . …
ID rdfs:range T(rangeh) .
[ID owl:inverseOf T(inverse) .]
[ID rdf:type owl:FunctionalProperty . ]
[ID rdf:type owl:InverseFunctionalProperty . ]
[ID rdf:type owl:TransitiveProperty . ]
[ID rdf:type owl:SymmetricProperty . ]
AnnotationProperty(ID
      annotation1 … annotationm)
ID rdf:type owl:AnnotationProperty .
ID T(annotation1) . … ID T(annotationm) .
EquivalentProperties(dvpID1 … dvpIDn) T(dvpIDi) owl:equivalentProperty T(dvpIDi+1) . 1≤i<n
SubPropertyOf(dvpID1 dvpID2) T(dvpID1) rdfs:subPropertyOf T(dvpID2) .
EquivalentProperties(ivpID1 … ivpIDn) T(ivpIDi) owl:equivalentProperty T(ivpIDi+1) . 1≤i<n
SubPropertyOf(ivpID1 ivpID2) T(ivpID1) rdfs:subPropertyOf T(ivpID2) .
annotation(annotationPropertyID URIreference) annotationPropertyID URIreference .
annotationPropertyID rdf:type owl:AnnotationProperty .
annotation(annotationPropertyID dataLiteral) annotationPropertyID T(dataLiteral)
annotationPropertyID rdf:type owl:AnnotationProperty .
annotation(annotationPropertyID individual) annotationPropertyID T(individual)
annotationPropertyID rdf:type owl:AnnotationProperty .
SEQ rdf:nil
SEQ item1…itemn _:l1 rdf:type rdf:List .
_:l1 rdf:first T(item1) . _:l1 rdf:rest _:l2 .

_:ln rdf:type rdf:List .
_:ln rdf:first T(itemn) . _:ln rdf:rest rdf:nil .
_:l1

This transformation is not injective, as several OWL abstract ontologies that do not use the above reserved vocabulary can map into equal RDF graphs. However, the only cases where this can happen is with constructs that have the same meaning, such as several DisjointClasses axioms having the same effect as one larger one. It would be possible to define a canonical inverse transformation, if desired.

4.2. Definition of OWL DL and OWL Lite Ontologies in RDF Graph Form

When considering OWL Lite and DL ontologies in RDF graph form, care must be taken to prevent the use of certain vocabulary as OWL classes, properties, or individuals. If this is not done the built-in definitions or use of this vocabulary (in the RDF or OWL specification) would augment the information in the OWL ontology. Only some of the RDF vocabulary fits in this category, as some of the RDF vocabulary, such as rdf:subject, is given little or no meaning by the RDF specifications and its use does not present problems, as long as the use is consistent with any meaning given by the RDF specifications.

Definition: The disallowed vocabulary from RDF is rdf:type, rdf:Property, rdf:nil, rdf:List, rdf:XMLLiteral, rdf:first, rdf:rest, rdfs:domain, rdfs:range, rdfs:Resource, rdfs:Datatype, rdfs:Class, rdfs:subClassOf, rdfs:subPropertyOf, rdfs:member, rdfs:Container and rdfs:ContainerMembershipProperty. The disallowed vocabulary from OWL is owl:AllDifferent, owl:allValuesFrom, owl:AnnotationProperty, owl:cardinality, owl:Class, owl:complementOf, owl:DataRange, owl:DatatypeProperty, owl:DeprecatedClass, owl:DeprecatedProperty, owl:differentFrom, owl:disjointWith, owl:distinctMembers, owl:equivalentClass, owl:equivalentProperty, owl:FunctionalProperty, owl:hasValue, owl:intersectionOf, owl:InverseFunctionalProperty, owl:inverseOf, owl:maxCardinality, owl:minCardinality, owl:ObjectProperty, owl:oneOf, owl:onProperty, owl:Ontology, owl:Property, owl:Restriction, owl:sameAs, owl:sameIndividualAs, owl:someValuesFrom, owl:SymmetricProperty, owl:TransitiveProperty, and owl:unionOf. The disallowed vocabulary is the union of the disallowed vocabulary from RDF and the disallowed vocabulary from OWL.

Definition: The class-only vocabulary is rdf:Statement, rdf:Seq, rdf:Bag, and rdf:Alt. The datatype-only vocabulary is the built-in OWL datatypes and rdfs:Literal. The property-only vocabulary is rdf:subject, rdf:predicate, rdf:object, and all the container membership properties, i.e., rdf:_1, rdf:_2, ….

Definition: A collection of OWL DL ontologies in abstract syntax form, O, has a separated vocabulary if

  1. the ontologies in O, taken together, do not use any URI reference as more than one of a class ID, a datatype ID, an individual ID, an individual-valued property ID, a data-valued property ID, an annotation property ID, ontology property ID, or an ontology ID;
  2. the ontologies in O, taken together, provide a type for every individual ID;
  3. the ontologies in O only use the class-only vocabulary as class IDs; only use the datatype-only vocabulary as datatype IDs; only use the property-only vocabulary as datavaluedProperty IDs, individualvaluedProperty IDs, or annotationProperty IDs; and do not mention any disallowed vocabulary.

Definition: An RDF graph is an OWL DL ontology in RDF graph form if it is equal (see below for a slight relaxation) to a result of the transformation to triples above of a collection of OWL DL ontologies in abstract syntax form that has a separated vocabulary. For the purposes of determining whether an RDF graph is an OWL DL ontology in RDF graph form, cardinality restrictions are explicitly allowed to use constructions like "1"^^xsd:decimal so long as the data value so encoded is a non-negative integer.

Definition: An RDF graph is an OWL Lite ontology in RDF graph form if it is as above except that the ontologies in O are OWL Lite ontologies in abstract syntax form.

Direct Formulation of OWL DL and OWL Lite Ontologies in RDF Graph Form

A finite RDF graph is an OWL DL or OWL Lite ontology in RDF graph form if and only if it meets the following conditions:

  1. For every node of the graph and every URI reference used as a property or datatype at least one of the following holds:
  2. Every blank node with explicit type rdf:List or [DL only] owl:DataRange is the object of exactly one triple.
  3. Any uriref which is a built-in OWL datatype or in the datatype-only vocabulary or rdfs:Literal is assigned to the category datatypeID. Any uriref which is a built-in OWL class or in the class-only vocabulary is assigned to the category classID. Any uriref which is a built-in OWL annotation property is assigned to the category annotationPropID. Any uriref which is a built-in OWL ontology property is assigned to the category ontologyPropertyID. Any uriref which is in the property-only vocabulary is assigned to one of the categories annotationPropID, dataPropID objectPropID or transitivePropID. Every uriref in the disallowed vocabulary is assigned to itself.
  4. Every other uriref is assigned to one of the following categories:
  5. Every blank node is assigned to one of the following categories:
  6. With the given category assignments every triple in the graph appears in one of the following tables:
  7. Every blank node is either of category unnamedIndividual or meets the structural requirements listed below, in the appropriate table.
  8. A blank node which occurs as the object of more than one triple must be of category restriction or [DL only] description.
  9. Directed cycles of blank nodes may not occur in OWL Lite and in OWL DL must contain at least one triple with property owl:disjointWith or owl:equivalentClass.

Such an RDF graph which does not use any of the cases marked as DL only, is in OWL Lite.

A directed cycle of blank nodes is a sequence of triples t0, t1, ... tn, in which tn = t0, and in which the subjects and objects of all the triples are blank, and in which the object of ti is the subject of ti+1, for i from 0 to n-1.

Main Lite Table

SubjectPredicateObject
annotationPropID or
classID or
dataPropID or
datatypeID or
individualID or
objectPropID or
ontologyID or
transitivePropID or
unnamedIndividual
annotationPropIDannotationPropID or
classID or
dataPropID or
datatypeID or
individualID or
literal or
objectPropID or
ontologyID or
ontologyPropertyID or
transitivePropID or
unnamedIndividual
individualID or
unnamedIndividual
objectPropID or
transitivePropID
individualID or
unnamedIndividual
objectPropID or
transitivePropID
rdf:typeowl:DeprecatedProperty or
owl:ObjectProperty or
owl:SymmetricProperty or
rdf:Property
classIDowl:equivalentClass or
rdfs:subClassOf
classID or
restriction
individualID or
unnamedIndividual
rdf:typeclassID or
restriction
objectPropID or
transitivePropID
rdfs:domain or
rdfs:range
classID
annotationPropID rdf:typeowl:AnnotationProperty
annotationPropIDrdf:typerdf:Property
classIDowl:intersectionOflistOfDescription
classIDowl:intersectionOfrdf:nil
classIDrdf:typeowl:Class
classIDrdf:typeowl:DeprecatedClass
classIDrdf:typerdfs:Class
dataPropIDowl:equivalentPropertydataPropID
dataPropIDrdf:typeowl:DatatypeProperty
dataPropIDrdf:typeowl:DeprecatedProperty
dataPropIDrdf:typeowl:FunctionalProperty
dataPropIDrdf:typerdf:Property
dataPropIDrdfs:domainclassID
dataPropIDrdfs:rangedatatypeID
dataPropIDrdfs:subPropertyOfdataPropID
datatypeIDrdf:typerdfs:Datatype
individualIDdataPropIDliteral
individualIDowl:differentFromindividualID
individualIDowl:sameIndividualAsindividualID
objectPropIDowl:equivalentPropertyobjectPropID
objectPropIDowl:inverseOfobjectPropID
objectPropIDrdf:typeowl:FunctionalProperty
objectPropIDrdf:typeowl:InverseFunctionalProperty
objectPropIDrdfs:subPropertyOfobjectPropID
objectPropIDrdfs:subPropertyOftransitivePropID
ontologyIDontologyPropertyIDontologyID
ontologyIDrdf:typeowl:Ontology
restrictionrdf:typerdfs:Class
transitivePropIDowl:equivalentPropertytransitivePropID
transitivePropIDowl:inverseOftransitivePropID
transitivePropIDrdf:typeowl:TransitiveProperty
transitivePropIDrdfs:subPropertyOftransitivePropID
unnamedIndividualdataPropIDliteral

Main DL Table

SubjectPredicateObject
description or
restriction
owl:disjointWith or
owl:equivalentClass or
rdfs:subClassOf
classID or
description or
restriction
objectPropID or
transitivePropID
rdfs:domain or
rdfs:range
description or
restriction
classIDowl:complementOf or
owl:disjointWith
classID or
description or
restriction
classIDowl:equivalentClassdescription
classIDowl:oneOflistOfIndividualID
classIDowl:oneOfrdf:nil
classIDowl:unionOflistOfDescription
classIDowl:unionOfrdf:nil
classIDrdfs:subClassOfdescription
dataPropIDrdfs:domaindescription
dataPropIDrdfs:domainrestriction
dataPropIDrdfs:rangeunnamedDataRange
descriptionrdf:typerdfs:Class
individualIDrdf:typedescription
unnamedDataRangerdf:typerdfs:Class
unnamedIndividualrdf:typedescription

Rules for Blank Nodes of Category allDifferent

Every node of category allDifferent must fit the following pattern. For each such node, exactly one instance of each triple in the pattern must be present in the graph. There are no other triples in the graph in which such nodes are subjects.

SubjectPredicateObject
allDifferentrdf:typeowl:AllDifferent
allDifferentowl:distinctMemberslistOfIndividualID or
rdf:nil

Rules for Blank Nodes of Category listOfDescription

Every node of category listOfDescription must fit the following pattern. For each such node, exactly one instance of each triple in the pattern must be present in the graph. There are no other triples in the graph in which such nodes are subjects.

SubjectPredicateObject
listOfDescriptionrdf:typerdf:List
listOfDescriptionrdf:firstclassID or
restriction or
description [DL only]
listOfDescriptionrdf:restlistOfDescription or
rdf:nil

Rules for Blank Nodes of Category listOfIndividualID

Every node of category listOfIndividualID must fit the following pattern. For each such node, exactly one instance of each triple in the pattern must be present in the graph. There are no other triples in the graph in which such nodes are subjects.

SubjectPredicateObject
listOfIndividualIDrdf:typerdf:List
listOfIndividualIDrdf:firstindividualID
listOfIndividualIDrdf:restlistOfIndividualID or
rdf:nil

Rules for Blank Nodes of Category restriction

Every node of category restriction must fit one of these patterns. For each such node, exactly one instance of each triple in the pattern must be present in the graph. There may be additional triples in which such nodes are subjects as listed in the main triple tables.

SubjectPredicateObject
Either:
restrictionrdf:typeowl:Restriction
restrictionowl:allValuesFrom or
owl:someValuesFrom
classID or
description [DL only] or
restriction [DL only]
restrictionowl:onPropertyobjectPropID or
transitivePropID
Or:
restrictionrdf:typeowl:Restriction
restrictionowl:allValuesFrom or
owl:someValuesFrom
datatypeID
restrictionowl:onPropertydataPropID
Or:
restrictionrdf:typeowl:Restriction
restrictionowl:maxCardinality or
owl:minCardinality or
owl:cardinality
0^^ (xsd:nonNegativeInteger) or
1^^ (xsd:nonNegativeInteger) or
nonNegativeInteger [DL only]
restrictionowl:onPropertyobjectPropID or
dataPropID
Or: [DL only]
restrictionrdf:typeowl:Restriction
restrictionowl:hasValueindividualID
restrictionowl:onPropertyobjectPropID or
transitivePropID
Or: [DL only]
restrictionrdf:typeowl:Restriction
restrictionowl:hasValueliteral
restrictionowl:onPropertydataPropID

[DL only] Rules for Blank Nodes of Category description

Every node of category description must fit one of these patterns. For each such node, exactly one instance of each triple in the pattern must be present in the graph. There may be additional triples in which such nodes are subjects as listed in the main triple tables.

SubjectPredicateObject
Either:
descriptionrdf:typeowl:Class
descriptionowl:complementOfclassID or
description or
restriction
Or:
descriptionrdf:typeowl:Class
descriptionowl:intersectionOf or
owl:unionOf
listOfDescription or
rdf:nil
Or:
descriptionrdf:typeowl:Class
descriptionowl:oneOflistOfIndividualID or
rdf:nil

[DL only] Rules for Blank Nodes of Category listOfDataLiteral

Every node of category listOfDataLiteral must fit the following pattern. For each such node, exactly one instance of each triple in the pattern must be present in the graph. There are no other triples in the graph in which such nodes are subjects.

SubjectPredicateObject
listOfDataLiteralrdf:typerdf:List
listOfDataLiteralrdf:firstliteral
listOfDataLiteralrdf:restlistOfDataLiteral or
rdf:nil

[DL only] Rules for Blank Nodes of Category unnamedDataRange

Every node of category unnamedDataRange must fit the following pattern. For each such node, exactly one instance of each triple in the pattern must be present in the graph. There may be additional triples in which such nodes are subjects as listed in the main triple tables.

SubjectPredicateObject
unnamedDataRangerdf:typeowl:DataRange
unnamedDataRangeowl:oneOflistOfDataLiteral or
rdf:nil