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

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

Contents


4. Mapping to RDF Graphs

The exchange syntax for OWL is RDF/XML, as specified in the OWL Reference Description [OWL Reference]. Further, the meaning of an OWL document base in RDF/XML is determined only from the RDF graph 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 N-Triples.

The N-Triples syntax used here is the one used in the RDF Model Theory [RDF MT]. In this variant, QNames are allowed. To turn this syntax into the standard one, just turn the QName into the obvious URI reference. The only prefixes used in the transformation are rdf, rdfs, xsd, and owl, which should be expanded into http://www.w3.org/1999/02/22-rdf-syntax-ns#, http://www.w3.org/2000/01/rdf-schema#, http://www.w3.org/2001/XMLSchema#, and http://www.w3.org/2002/07/owl#, respectively.

As all OWL Lite constructs are special cases of constructs in the full abstract syntax, transformations are only provided for the full versions.

Each type of directive is translated via one of the transformation rules below. In the transformation rules nonterminals are enclosed in angle brackets. Repeating nonterminals are listed using ellipses, as in <description1> … <descriptionn>, this form allows easy specification of the transformation for all values of n, including 0. Optional portions of the abstract syntax (enclosed in square brackets) are optional portions of the transformation (signified by square brackets).

The table below gives the transformation rules that transform the abstract syntax to the OWL exchange syntax. The left column gives a piece of syntax (S), the center column gives its transformation (T(S)), and the right column gives a node identifier that is the main node of the transformation (M(T(S))), but only for syntactic constructs that can occur as pieces of directives. 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 in a node position of an N-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 N-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. Also, some of the transformations require a URI for the current ontology. It is assumed that ontologies that are subject to this sort of transformation will be placed into a web-accessible document; the URI of this document is given as #.

Abstract Syntax (and sequences) - S Transformation - T(S) Main Node - M(T(S))
Ontology(<directive1> … <directiven> # rdf:type owl:Ontology .
T(<directive1>) … T(<directiven>)
<datatypeID> <datatypeID> rdf:type rdfs:Datatype . <datatypeID>
<classID> <classID> rdf:type owl:Class . <classID>
<individualID> <individualID> rdf:type owl:Thing . <individualID>
<datavaluedPropertyID> <datavaluedPropertyID> rdf:type owl:DatatypeProperty . <datavalued-
PropertyID>
<individualvaluedPropertyID> <individualvaluedPropertyID> rdf:type owl:ObjectProperty . <individualvalued-
PropertyID>
<datatypeID> <literal> "<literal>"^^<datatypeID>
<datatypeID> rdf:type rdfs:Datatype >
"<literal>"^^
<datatypeID>
Annotation( <URI reference> <URI reference> ) # <URI reference> <URI reference> .
Annotation( <URI reference> <lexical-form> ) # <URI reference> <lexical-form> .
Imports(<URI>) # owl:imports <URI> .
Individual(<iID>
      <annotation1> … <annotationn>
      type(<type1>)…type(<typen>)
      (<pID1> <value1>) … (<pIDn> <valuen>))
<iID> rdf:type owl:Thing .
<iID> T(<annotation1>) . … <iID> T(<annotationn>) .
<iID> rdf:type T(<type1>) . … <iID> rdf:type T(<typen>) .
<iID> <pID1> T(<value1>) . … <iID> <pIDn> T(<valuen>) .
<iID>
Individual(
      <annotation1> … <annotationn>
      type(<type1>)…type(<typen>)
      (<pID1> <value1>) … (<pIDn> <valuen>))
_:x rdf:type owl:Thing .
_:x T(<annotation1>) . … _:x T(<annotationn>) .
_:x rdf:type T(<type1>) . … _:x rdf:type T(<typen>) .
_:x <pID1> T(<value1>) . … _:x <pIDn> T(<valuen>) .
_:x
SameIndividual( <individualID1> … <individualIDn>) <individualIDi> owl:sameAs <individualIDj> . 1≤i<j≤n
DifferentIndividuals(<individualID1> … <individualIDn>) <individualIDi> owl:differentFrom <individualIDj> . 1≤i<j≤n
Class(<classID>
      [partial | complete]
      <annotation1> … <annotationn>)
      <description1> … <descriptionn>)
<classID> rdf:type owl:Class .
<classID> [ rdfs:subClassOf | owl:sameClassAs ] _:x .
_:x T(<annotation1>) . … _:x T(<annotationn>) .
_:x owl:intersectionOf T(SEQ <description1>…<descriptionn>) .
EnumeratedClass(<classID>
      <annotation1> … <annotationn>)
      <individualID1> … <individualIDn>)
<classID> rdf:type owl:Class .
<classID> owl:sameClassAs _:x .
_:x T(<annotation1>) . … _:x T(<annotationn>) .
_:x owl:oneOf T(SEQ <individualID1>…<individualIDn>) .
DisjointClasses( <description1> … <descriptionn> ) T(<descriptioni>) owl:disjointWith T(<descriptionj>) . 1≤i<j≤n
EquivalentClasses( <description1> … <descriptionn>) T(<descriptioni>) owl:sameClassAs T(<descriptionj>) . 1≤i<j≤n
SubClassOf( <description1> <description2>) T(<description1>) rdfs:subClassOf T(<description2>) .
unionOf( <description1> … <descriptionn>) _:x owl:unionOf T(SEQ <description1>…<descriptionn>) . _:x
intersectionOf( <description1> … <descriptionn>) _:x owl:intersectionOf T(SEQ <description1>…<descriptionn>) . _:x
complementOf(<description>) _:x owl:complementOf T(<description>) . _:x
oneOf( <individualID1> … <individualIDn>) _:x rdf:type owl:Class .
_:x owl:oneOf T(SEQ <individualID1>…<individualIDn>) .
_:x
oneOf( <datatypeID1> <value1> … <datatypeIDn> <valuen>) _:x rdf:type rdfs:Datatype .
_:x owl:oneOf
T(SEQ <datatypeID1> <value1>… <datatypeIDn> <valuen>) .
_:x
restriction( <ID> <component1> … <componentn>) _:x owl:intersectionOf
  T(SEQ(restriction(<ID> <component1>)…
   restriction(<ID> <componentn>))) .
_:x
restriction( <ID> allValuesFrom(<range>)) _:x rdf:type owl:Restriction .
_:x owl:onProperty T(<ID>) .
_:x owl:allValuesFrom T(<range>) .
_:x
restriction( <ID> someValuesFrom(<required>)) _:x rdf:type owl:Restriction .
_:x owl:onProperty T(<ID>) .
_:x owl:someValuesFrom T(<required>) .
_:x
restriction( <ID> value(<value>)) _:x rdf:type owl:Restriction .
_:x owl:onProperty T(<ID>) .
_:x owl:hasValue T(<value>) .
_:x
restriction( <ID> minCardinality(<min>)) _:x rdf:type owl:Restriction .
_:x owl:onProperty T(<ID>) .
_:x owl:minCardinality "<min>"^^xsd:decimal .
_:x
restriction( <ID> maxCardinality(<max>)) _:x rdf:type owl:Restriction .
_:x owl:onProperty T(<ID>) .
_:x owl:maxCardinality "<max>"^^xsd:decimal .
_:x
restriction( <ID> cardinality(<card>)) _:x rdf:type owl:Restriction .
_:x owl:onProperty T(<ID>) .
_:x owl:cardinality "<card>"^^xsd:decimal .
_:x
DatatypeProperty( <name>
      <annotation1> … <annotationn>)       super(<super1>)…
      super(<supern>)
      domain(<domain1>)…
      domain(<domainn>)
      range(<range1>)…
      range(<rangen>)
      [Functional])
<name> rdf:type owl:DatatypeProperty .
<name> T(<annotation1>) . … <name> T(<annotationn>) .
<name> rdfs:subPropertyOf T(<super1>) . …
<name> rdfs:subPropertyOf T(<supern>) .
<name> rdfs:domain T(<domain1>) . …
<name> rdfs:domain T(<domainn>) .
<name> rdfs:range T(<range1>) . …
<name> rdfs:range T(<rangen>) .
[<name> rdf:type owl:FunctionalProperty . ]
ObjectProperty( <name>
      <annotation1> … <annotationn>)
      super(<super1>)…
      super(<supern>)
      domain(<domain1>)…
      domain(<domainn>)
      range(<range1>)…
      range(<rangen>)
      [inverseOf(<inverse>)]
      [Symmetric]
      [Functional |
       InverseFunctional |
       Transitive])
<name> rdf:type owl:ObjectProperty .
<name> T(<annotation1>) . … <name> T(<annotationn>) .
<name> rdfs:subPropertyOf T(<super1>) . …
<name> rdfs:subPropertyOf T(<supern>) .
<name> rdfs:domain T(<domain1>) . …
<name> rdfs:domain T(<domainn>) .
<name> rdfs:range T(<range1>) . …
<name> rdfs:range T(<rangen>) .
[<name> owl:inverseOf T(<inverse>) .]
[<name> rdf:type owl:SymmetricProperty . ]
[<name> rdf:type owl:FunctionalProperty . ]
[<name> rdf:type owl:InverseFunctionalProperty . ]
[<name> rdf:type owl:TransitiveProperty . ]
EquivalentProperties( <datavaluedPropertyID1> … <datavaluedPropertyIDn>) T(<datavaluedPropertyIDi>) owl:samePropertyAs T(<datavaluedPropertyIDj>) . 1≤i<j≤n
SubPropertyOf( <datavaluedPropertyID1> <datavaluedPropertyID2>) T(<datavaluedPropertyID1>) rdfs:subPropertyOf T(<datavaluedPropertyID2>) .
EquivalentProperties( <individualvaluedPropertyID1> … <individualvaluedPropertyIDn>) T(<individualvaluedPropertyIDi>) owl:samePropertyAs T(<individualvaluedPropertyIDj>) . 1≤i<j≤n
SubPropertyOf( <individualvaluedPropertyID1> <individualvaluedPropertyID2>) T(<individualvaluedPropertyID1>) rdfs:subPropertyOf T(<individualvaluedPropertyID2>) .
annotation ( <URI reference> <URI reference> ) <URI reference> <URI reference>
annotation ( <URI reference> <lexical-form> ) <URI reference> "<lexical-form>"
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

4.1. Definition of OWL/DL Ontologies in RDF Graph Form

An RDF graph is an OWL/DL ontology in RDF graph form if it is equal to the result of the above transformation of an OWL ontology in abstract syntax form and, moreover,

  1. the abstract syntax form does not use any URI reference as more than one of a classID, a datatypeID, an individualID, a datavaluedPropertyID, or an individualvaluedPropertyID;
  2. the abstract syntax form does not use the URI of the document itself as a URI reference;
  3. the abstract syntax form does not use any URI reference that is the first or second argument of an Annotation directive or an annotation portion of a directive as a classID, a datatypeID, an individualID, or a datavaluedPropertyID, nor does it use any URI reference that is the first argument of an Annotation directive or an annotation portion of a directive as an individualvaluedPropertyID; and
  4. the abstract syntax form does not mention any of the URI references from the RDF, RDFS, or OWL namespaces except rdfs:Literal, owl:Thing, and owl:Nothing.

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.