W3C

OWL 2 Web Ontology Language:
Mapping to RDF Graphs

W3C Editor's Draft 11 April 2008

This version:
http://www.w3.org/2007/OWL/draft/ED-owl2-mapping-to-rdf-20080411/
Latest editor's draft:
http://www.w3.org/2007/OWL/draft/owl2-mapping-to-rdf/
Previous version:
http://www.w3.org/2007/OWL/draft/WD-owl11-mapping-to-rdf-20080108/ (color-coded diff)
Authors:
Bernardo Cuenca Grau, Oxford University
Boris Motik, Oxford University
Contributors:
Ian Horrocks, Oxford University
Bijan Parsia, The University of Manchester

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

Abstract

OWL 2 extends the W3C OWL Web Ontology Language with a small but useful set of features that have been requested by users, for which effective reasoning algorithms are now available, and that OWL tool developers are willing to support. The new features include extra syntactic sugar, additional property and qualified cardinality constructors, extended datatype support, simple metamodelling, and extended annotations. This document provides a mapping from the functional-style syntax of OWL 2 to the RDF exchange syntax for OWL 2, and vice versa.

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

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 (this document)
  4. XML Serialization
  5. Profiles
  6. Primer

Summary of Changes

Since the previous Working Draft (dated 8 January 2008), the only change is the name of the language, from "OWL 1.1" to "OWL 2". Since the group is publishing three new Working Drafts, and the name has changed, it decided to publish the complete set with consistent names.

Please Comment By 11 May 2008

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.

Contents


1 Introduction

Editor's Note: See Issue-66 (mapping inconsistencies).

This document provides a mapping from the functional-style syntax of OWL 2 as given in [OWL 2 Specification] to the RDF exchange syntax for OWL 2 and vice versa. Every OWL 2 ontology can be serialized in RDF, so every OWL 2 ontology in RDF is a valid OWL Full ontology. The RDF syntax of OWL 2 is backwards-compatible with OWL DL, this is, every OWL DL ontology in RDF is a valid OWL 2 ontology. The semantics OWL 2 is defined for ontologies in the functional-style syntax. OWL 2 ontologies serialized in RDF/XML are interpreted by translating them into the functional-style syntax and applying the OWL 2 semantics [OWL 2 Semantics]. The syntax for triples used here is the one used in the RDF Semantics document. Full URIs are abbreviated using namespaces as usual.


Editor's Note: The actual namespaces used in the specification are subject to discussion and might change in future.

The following notation is used throughout this document:

Table 1. Transformation of Sequences to Triples
Sequence S Transformation T(S) Main Node of T(S)
SEQ rdf:nil
SEQ y1 ... yn _:x rdf:type rdf:List
_:x rdf:first T(y1)
_:x rdf:rest T(SEQ y2 ... yn)
 _:x

2 Translation from Functional-Style Syntax to RDF Graphs

Editor's Note: See Issue-2 (allDisjoint-RDF), Issue-68 (nonmonotonic mapping) and Issue-81 (reification, negative assertions).

As explained in [OWL 2 Specification], OWL 2 syntax is fully typed -- that is, from the syntax, one can immediately see what is the intendend usage of some symbol. OWL 1.0 syntax is not typed; rather, OWL 1.0 relies on explicit statements that determine the type of each URI. For backwards compatibility, OWL 2 uses OWL 1.0 vocabulary whenever there is no ambiguity. This is made precise using the following definition.

The type of a symbol S in an ontology O (in functional-style syntax), written Type(S,O), is defined as the smallest set such that

The above definition refers to a parse tree only for the axioms from O, and not from the axioms from some ontology that O imports. A symbol S in punned in an ontology O if Type(S,O) contains more than one element. Based on that, the following two conditions are defined:

The following shortcuts are used in the translation of OWL 2 ontologies into RDF:

Table 2 presents the operator T that translates an OWL 2 ontology in functional-style syntax into a set of RDF triples. This table does not consider axioms with annotations: the translation of such axioms is described in Section 2.1.

Table 2. Transformation to Triples
Functional-Style Syntax S Transformation T(S) Main Node of T(S)
Ontology(ontologyURI
Import(oID1) ... Import(oIDk)
Annotation(apID1 ct1) ... Annotation(apIDn ctn)
axiom1 ... axiomm)		 ontologyURI rdf:type owl:Ontology
ontologyURI owl:imports oIDi 1 ≤ i ≤ k
ontologyURI T(apIDi) T(cti) 1 ≤ i ≤ n
T(axiomi) 1 ≤ i ≤ m		 ontologyURI
datatypeURI datatypeURI rdf:type rdfs:Datatype datatypeURI
owlClassURI owlClassURI rdf:type owl:Class owlClassURI
objectPropertyURI objectPropertyURI rdf:type owl:ObjectProperty objectPropertyURI
dataPropertyURI dataPropertyURI rdf:type owl:DatatypeProperty dataPropertyURI
annotationURI annotationURI rdf:type owl:AnnotationProperty annotationURI
individualURI individualURI
constant constant
DataComplementOf(dr) _:x rdf:type owl:DataRange
_:x owl:complementOf T(dr)		 _:x
DataOneOf(ct1 ... ctn) _:x rdf:type owl:DataRange
_:x owl:oneOf T(SEQ ct1 ... ctn)		 _:x
DatatypeRestriction(dr facet1 ct1 ... facetn ctn) _:x rdf:type owl:DataRange
_:x owl11:onDataRange T(dr)
_:x owl11:withRestrictions T(SEQ _:x1 ... _:xn)
_:xi owl11:faceti cti 1 ≤ i ≤ n		 _:x
InverseObjectProperty(op) _:x owl11:inverseObjectPropertyExpression T(op) _:x
ObjectUnionOf(c1 ... cn) _:x rdf:type owl:Class
_:x owl:unionOf T(SEQ c1 ... cn)		 _:x
ObjectIntersectionOf(c1 ... cn) _:x rdf:type owl:Class
_:x owl:intersectionOf T(SEQ c1 ... cn)		 _:x
ObjectComplementOf(c) _:x rdf:type owl:Class
_:x owl:complementOf T(c)		 _:x
ObjectOneOf(iID1 ... iIDn) _:x rdf:type owl:Class
_:x owl:oneOf T(SEQ iID1 ... iIDn)		 _:x
ObjectSomeValuesFrom(op c) _:x rdf:type RESTRICTION[op]
_:x owl:onProperty T(op)
_:x owl:someValuesFrom T(c)		 _:x
ObjectAllValuesFrom(op c) _:x rdf:type RESTRICTION[op]
_:x owl:onProperty T(op)
_:x owl:allValuesFrom T(c)		 _:x
ObjectExistsSelf(op) _:x rdf:type owl11:SelfRestriction
_:x owl:onProperty T(op)
 _:x
ObjectHasValue(op iID) _:x rdf:type RESTRICTION[op]
_:x owl:onProperty T(op)
_:x owl:hasValue T(iID)		 _:x
ObjectMinCardinality(n op c) _:x rdf:type RESTRICTION[op]
_:x owl:minCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(op)
_:x owl11:onClass T(c)		 _:x
ObjectMaxCardinality(n op c) _:x rdf:type RESTRICTION[op]
_:x owl:maxCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(op)
_:x owl11:onClass T(c)		 _:x
ObjectExactCardinality(n op c) _:x rdf:type RESTRICTION[op]
_:x owl:cardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(op)
_:x owl11:onClass T(c)		 _:x
ObjectMinCardinality(n op) _:x rdf:type RESTRICTION[op]
_:x owl:minCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(op)		 _:x
ObjectMaxCardinality(n op) _:x rdf:type RESTRICTION[op]
_:x owl:maxCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(op)		 _:x
ObjectExactCardinality(n op) _:x rdf:type RESTRICTION[op]
_:x owl:cardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(op)		 _:x
DataSomeValuesFrom(dp dr) _:x rdf:type RESTRICTION[dp]
_:x owl:onProperty T(dp)
_:x owl:someValuesFrom T(dr)		 _:x
DataSomeValuesFrom(dp1 ... dpn dr) _:x rdf:type RESTRICTION[dp]
_:x owl:onProperty T(SEQ dp1 ... dpn)
_:x owl:someValuesFrom T(dr)		 _:x
DataAllValuesFrom(dp dr) _:x rdf:type RESTRICTION[dp]
_:x owl:onProperty T(dp)
_:x owl:allValuesFrom T(dr)		 _:x
DataAllValuesFrom(dp1 ... dpn dr) _:x rdf:type RESTRICTION[dp]
_:x owl:onProperty T(SEQ dp1 ... dpn)
_:x owl:allValuesFrom T(dr)		 _:x
DataHasValue(dp ct) _:x rdf:type RESTRICTION[dp]
_:x owl:onProperty T(dp)
_:x owl:hasValue T(ct)		 _:x
DataMinCardinality(n dp dr) _:x rdf:type RESTRICTION[dp]
_:x owl:minCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(dp)
_:x owl11:onDataRange T(dr)		 _:x
DataMaxCardinality(n dp dr) _:x rdf:type RESTRICTION[dp]
_:x owl:maxCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(dp)
_:x owl11:onDataRange T(dr)		 _:x
DataExactCardinality(n dp dr) _:x rdf:type RESTRICTION[dp]
_:x owl:cardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(dp)
_:x owl11:onDataRange T(dr)		 _:x
DataMinCardinality(n dp) _:x rdf:type RESTRICTION[dp]
_:x owl:minCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(dp)		 _:x
DataMaxCardinality(n dp) _:x rdf:type RESTRICTION[dp]
_:x owl:maxCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(dp)		 _:x
DataExactCardinality(n dp) _:x rdf:type RESTRICTION[dp]
_:x owl:cardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty T(dp)		 _:x
EntityAnnotation(Datatype(dID)
Annotation(apID1 ct1) ... Annotation(apIDn ctn))		 T(dID) T(apIDi) T(cti) 1 ≤ i ≤ n
EntityAnnotation(OWLClass(cID)
Annotation(apID1 ct1) ... Annotation(apIDn ctn))		 T(cID) T(apIDi) T(cti) 1 ≤ i ≤ n
EntityAnnotation(ObjectProperty(opID)
Annotation(apID1 ct1) ... Annotation(apIDn ctn))		 T(opID) T(apIDi) T(cti) 1 ≤ i ≤ n
EntityAnnotation(DataProperty(dpID)
Annotation(apID1 ct1) ... Annotation(apIDn ctn))		 T(dpID) T(apIDi) T(cti) 1 ≤ i ≤ n
EntityAnnotation(Individual(iID)
Annotation(apID1 ct1) ... Annotation(apIDn ctn))		 T(iID) T(apIDi) T(cti) 1 ≤ i ≤ n
SubClassOf(c1 c2) T(c1) rdfs:subClassOf T(c2)
EquivalentClasses(c1 ... cn) T(ci) owl:equivalentClass T(ci+1) 1 ≤ i ≤ n-1
DisjointClasses(c1 ... cn) T(ci) owl:disjointWith T(cj) 1 ≤ i, j ≤ n, i ≠ j
DisjointUnion(cID c1 ... cn) T(cID) owl11:disjointUnionOf T(SEQ c1 ... cn)
SubObjectPropertyOf(op1 op2) T(op1) SUBPROPERTYOF[op1,op2] T(op2)
SubObjectPropertyOf(
subObjectPropertyChain(op1 ... opn) op)		 _:x SUBPROPERTYOF[op1,...,opn,op] T(op)
_:x owl11: propertyChain T(SEQ op1 ... opn)
EquivalentObjectProperties(op1 ... opn) T(opi) EQUIVALENTPROPERTY[op1,...,opn] T(opi+1) 1 ≤ i ≤ n-1
DisjointObjectProperties(op1 ... opn) T(opi) owl11:disjointObjectProperties T(opj) 1 ≤ i, j ≤ n, i ≠ j
ObjectPropertyDomain(op c) T(op) DOMAIN[op] T(c)
ObjectPropertyRange(op c) T(op) RANGE[op] T(c)
InverseObjectProperties(op1 op2) T(op1) owl:inverseOf T(op2)
TransitiveObjectProperty(op) T(op) rdf:type owl:TransitiveProperty
FunctionalObjectProperty(op) T(op) rdf:type FUNCTIONALPROPERTY[op]
InverseFunctionalObjectProperty(op) T(op) rdf:type owl:InverseFunctionalProperty
ReflexiveObjectProperty(op) T(op) rdf:type owl11:ReflexiveProperty
IrreflexiveObjectProperty(op) T(op) rdf:type owl11:IrreflexiveProperty
SymmetricObjectProperty(op) T(op) rdf:type owl:SymmetricProperty
AsymmetricObjectProperty(op) T(op) rdf:type owl11:AsymmetricProperty
SubDataPropertyOf(dp1 dp2) T(dp1) SUBPROPERTYOF[dp1,dp2] T(dp2)
EquivalentDataProperties(dp1 ... dpn) T(dpi) EQUIVALENTPROPERTY[dp1,...,dpn] T(dpi+1) 1 ≤ i ≤ n-1
DisjointDataProperties(dp1 ... dpn) T(dpi) owl11:disjointDataProperties T(dpj) 1 ≤ i, j ≤ n, i ≠ j
DataPropertyDomain(dp c) T(dp) DOMAIN[dp] T(c)
DataPropertyRange(dp dr) T(op) RANGE[dp] T(dr)
FunctionalDataProperty(dp) T(dp) rdf:type FUNCTIONALPROPERTY[dp]
SameIndividual(iID1 ... iIDn) T(iIDi) owl:sameAs T(iIDi+1) 1 ≤ i ≤ n-1
DifferentIndividuals(iID1 ... iIDn) T(iIDi) owl:differentFrom T(iIDj) 1 ≤ i, j ≤ n, i ≠ j
ClassAssertion(iID c) T(iID) rdf:type T(c)
ObjectPropertyAssertion(op iID1 iID2) T(iID1) T(op) T(iID2)
NegativeObjectPropertyAssertion(op iID1 iID2) _:x rdf:type owl11:NegativeObjectPropertyAssertion
_:x rdf:subject T(iID1)
_:x rdf:predicate T(op)
_:x rdf:object T(iID2)
DataPropertyAssertion(dp iID ct) T(iID) T(dp) T(ct)
NegativeDataPropertyAssertion(op iID ct) _:x rdf:type owl11:NegativeDataPropertyAssertion
_:x rdf:subject T(iID)
_:x rdf:predicate T(dp)
_:x rdf:object T(ct)
Declaration(Datatype(dID)) T(dID) owl11:declaredAs rdfs:Datatype
Declaration(OWLClass(cID)) T(cID) owl11:declaredAs owl:Class
Declaration(ObjectProperty(opID)) T(opID) owl11:declaredAs owl:ObjectProperty
Declaration(DataProperty(dpID)) T(dpID) owl11:declaredAs owl:DatatypeProperty
Declaration(Individual(iID)) T(iID) owl11:declaredAs owl11:Individual

2.1 Annotated Axioms

Editor's Note: See Issue-12 (multi-triple annotations) and Issue-67 (reification).

Axioms with annotations are reified. If s p o is the RDF serialization of the corresponding axiom without annotations given in Table 2 and the axiom contains annotations Annotation(apIDi cti), 1 ≤ i ≤ n, then, instead of being serialized as s p o, the axiom is serialized as follows:

_:x rdf:type owl11:Axiom
_:x T(apIDi) T(cti) 1 ≤ i ≤ n
_:x rdf:subject s
_:x rdf:predicate p
_:x rdf:object o

Negative object and data property assertions are already reified so only the following triples are added if an assertion contains an annotation:

_:x T(apIDi) T(cti) 1 ≤ i ≤ n

Note that the Label and Comment annotations are just abbreviations. They are serialized into RDF triples by expanding the abbreviation and then applying the transformation from Table 2.

3 Translation from RDF Graphs to Functional-Style Syntax

This section specifies how to translate a set of RDF triples G into an OWL 2 ontology in functional-style syntax O, if possible. The function Type(x) assigns a set of types to each resource node x in G (in this and all other definitions, the graph G is implicitly understood and is not specified explicitly) and is defined as the smallest set satisfying the conditions from Table 3.

Table 3. Types of Nodes in a Graph
If G contains a triple of this form... ...then Type(x) must contain this URI.
x rdf:type owl:Class owl:Class
x rdf:type owl:Restriction owl:Class
x rdf:type owl11:ObjectRestriction owl:Class
x rdf:type owl11:DataRestriction owl:Class
x rdf:type owl:DataRange owl:DataRange
x rdf:type rdfs:Datatype owl:DataRange
x rdf:type owl:ObjectProperty owl:ObjectProperty
x rdf:type owl:TransitiveProperty owl:ObjectProperty
x rdf:type owl:SymmetricProperty owl:ObjectProperty
x rdf:type owl11:AsymmetricProperty owl:ObjectProperty
x rdf:type owl11:ReflexiveProperty owl:ObjectProperty
x rdf:type owl11:IrreflexiveProperty owl:ObjectProperty
x rdf:type owl11:FunctionalObjectProperty owl:ObjectProperty
x rdf:type owl:DatatypeProperty owl:DatatypeProperty
x rdf:type owl11:FunctionalDataProperty owl:DatatypeProperty
x rdf:type owl:AnnotationProperty owl:AnnotationProperty
x rdf:type owl11:Individual owl11:Individual

For a resource node x, the functions OnlyOP(x) and OnlyDP(x) are defined as follows:

The following partial functions are defined for each resource node x:

These functions are defined inductively by the following conditions. For the induction to correctly defined, it should be possible to order all resource nodes in G such that there are no cyclic dependencies in the second condition; if this is not possible, then G cannot be converted into an OWL 2 ontology.

Table 4. Translation of Triples to Object Property Expressions
Pattern Object Property Expression
_:x owl11:inverseObjectPropertyExpression y InverseObjectProperty( OP(y) )
Table 5. Translation of Triples to Data Ranges
Pattern Data Range
_:x rdf:type owl:DataRange
_:x owl:complementOf y		 DataComplementOf( DRANGE(y) )
_:x rdf:type owl:DataRange
_:x owl:oneOf T(SEQ ct1 ... ctn)		 DataOneOf( ct1 ... ctn )
_:x rdf:type owl:DataRange
_:x owl11:onDataRange y
_:x owl11:withRestriction T(SEQ _:x1 ... _:xn)
_:xi owl11:faceti cti for 1 ≤ i ≤ n		 DatatypeRestriction( DRANGE(y) facet1 ct1 ... facetn ctn )
Table 6. Translation of Triples to Descriptions
Pattern Description
_:x rdf:type owl:Class
_:x owl:unionOf T(SEQ y1 ... yn)		 ObjectUnionOf( DESC(y1) ... DESC(yn) )
_:x rdf:type owl:Class
_:x owl:intersectionOf T(SEQ y1 ... yn)		 ObjectIntersectionOf( DESC(y1) ... DESC(yn) )
_:x rdf:type owl:Class
_:x owl:complementOf y		 ObjectComplementOf( DESC(y) )
_:x rdf:type owl:Class
_:x owl:oneOf T(SEQ !y1 ... !yn)		 ObjectOneOf( y1 ... yn )
_:x rdf:type owl11:SelfRestriction
_:x owl:onProperty y
 ObjectExistsSelf( OP(y) )
_:x rdf:type owl11:ObjectRestriction
_:x owl:onProperty y
_:x owl:hasValue !z		 ObjectHasValue( OP(y) z )
_:x rdf:type owl:Restriction
_:x owl:onProperty y
_:x owl:hasValue !z
{ OnlyOP(y) = true }		 ObjectHasValue( OP(y) z )
_:x rdf:type owl11:ObjectRestriction
_:x owl:onProperty y
_:x owl:someValuesFrom z		 ObjectSomeValuesFrom( OP(y) DESC(z) )
_:x rdf:type owl:Restriction
_:x owl:onProperty y
_:x owl:someValuesFrom z
{ OnlyOP(y) = true }		 ObjectSomeValuesFrom( OP(y) DESC(z) )
_:x rdf:type owl11:ObjectRestriction
_:x owl:onProperty y
_:x owl:allValuesFrom z		 ObjectAllValuesFrom( OP(y) DESC(z) )
_:x rdf:type owl:Restriction
_:x owl:onProperty y
_:x owl:allValuesFrom z
{ OnlyOP(y) = true }		 ObjectAllValuesFrom( OP(y) DESC(z) )
_:x rdf:type owl11:ObjectRestriction
_:x owl:minCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onClass z ]		 ObjectMinCardinality( n OP(y) [ DESC(z) ] )
_:x rdf:type owl:Restriction
_:x owl:minCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onClass z ]
{ OnlyOP(y) = true }		 ObjectMinCardinality( n OP(y) [ DESC(z) ] )
_:x rdf:type owl11:ObjectRestriction
_:x owl:maxCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onClass z ]		 ObjectMaxCardinality( n OP(y) [ DESC(z) ] )
_:x rdf:type owl:Restriction
_:x owl:maxCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onClass z ]
{ OnlyOP(y) = true }		 ObjectMaxCardinality( n OP(y) [ DESC(z) ] )
_:x rdf:type owl11:ObjectRestriction
_:x owl:cardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onClass z ]		 ObjectExactCardinality( n OP(y) [ DESC(z) ] )
_:x rdf:type owl:Restriction
_:x owl:cardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onClass z ]
{ OnlyOP(y) = true }		 ObjectExactCardinality( n OP(y) [ DESC(z) ] )
_:x rdf:type owl11:DataRestriction
_:x owl:onProperty y
_:x owl:hasValue ct		 DataHasValue( DP(y) ct )
_:x rdf:type owl:Restriction
_:x owl:onProperty y
_:x owl:hasValue ct
{ OnlyDP(y) = true }		 DataHasValue( DP(y) ct )
_:x rdf:type owl11:DataRestriction
_:x owl:onProperty y
_:x owl:someValuesFrom z		 DataSomeValuesFrom( DP(y) DRANGE(z) )
_:x rdf:type owl:Restriction
_:x owl:onProperty y
_:x owl:someValuesFrom z
{ OnlyDP(y) = true }		 DataSomeValuesFrom( DP(y) DRANGE(z) )
_:x rdf:type owl11:DataRestriction
_:x owl:onProperty T(SEQ y1 ... yn)
_:x owl:someValuesFrom z		 DataSomeValuesFrom( DP(y1) ... DP(yn) DRANGE(z) )
_:x rdf:type owl:Restriction
_:x owl:onProperty T(SEQ y1 ... yn)
_:x owl:someValuesFrom z
{ OnlyDP(y) = true }		 DataSomeValuesFrom( DP(y1) ... DP(yn) MDRANGE(z) )
_:x rdf:type owl11:DataRestriction
_:x owl:onProperty y
_:x owl:allValuesFrom z		 DataAllValuesFrom( DP(y) DRANGE(z) )
_:x rdf:type owl:Restriction
_:x owl:onProperty y
_:x owl:allValuesFrom z
{ OnlyDP(y) = true }		 DataAllValuesFrom( DP(y) DRANGE(z) )
_:x rdf:type owl11:DataRestriction
_:x owl:onProperty T(SEQ y1 ... yn)
_:x owl:allValuesFrom z		 DataAllValuesFrom( DP(y1) ... DP(yn) DRANGE(z) )
_:x rdf:type owl:Restriction
_:x owl:onProperty T(SEQ y1 ... yn)
_:x owl:allValuesFrom z
{ OnlyDP(y) = true }		 DataAllValuesFrom( DP(y1) ... DP(yn) DRANGE(z) )
_:x rdf:type owl11:DataRestriction
_:x owl:minCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onDataRange z ]		 DataMinCardinality( n DP(y) [ DRANGE(z) ] )
_:x rdf:type owl:Restriction
_:x owl:minCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onDataRange z ]
{ OnlyDP(y) = true }		 DataMinCardinality( n DP(y) [ DRANGE(z) ] )
_:x rdf:type owl11:DataRestriction
_:x owl:maxCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onDataRange z ]		 DataMaxCardinality( n DP(y) [ DRANGE(z) ] )
_:x rdf:type owl:Restriction
_:x owl:maxCardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onDataRange z ]
{ OnlyDP(y) = true }		 DataMaxCardinality( n DP(y) [ DRANGE(z) ] )
_:x rdf:type owl11:DataRestriction
_:x owl:cardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onDataRange z ]		 DataExactCardinality( n DP(y) [ DRANGE(z) ] )
_:x rdf:type owl:Restriction
_:x owl:cardinality "n"^^xsd:nonNegativeInteger
_:x owl:onProperty y
[ _:x owl11:onDataRange z ]
{ OnlyDP(y) = true }		 DataExactCardinality( n DP(y) [ DRANGE(z) ] )

The ontology O, corresponding to the set of RDF triples G, is the samllest set containing the axioms occurring in the second column of Table 7 for each triple pattern from the first column.

Table 7. Translation of Triples to Axioms
Pattern Axiom
 !x !yi cti for 1 ≤ i ≤ n
{ rdfs:Datatype ∈ Type(x) and OnlyAP(yi) = true for 1 ≤ i ≤ }		 EntityAnnotation( Datatype(x)
Annotation( y1 ct1 ) ... Annotation( yn ctn ) )
 !x !yi cti for 1 ≤ i ≤ n
{ owl:Class ∈ Type(x) and OnlyAP(yi) = true for 1 ≤ i ≤ }		 EntityAnnotation( OWLClass(x)
Annotation( y1 ct1 ) ... Annotation( yn ctn ) )
 !x !yi cti for 1 ≤ i ≤ n
{ owl:ObjectProperty ∈ Type(x) and OnlyAP(yi) = true for 1 ≤ i ≤ }		 EntityAnnotation( ObjectProperty(x)
Annotation( y1 ct1 ) ... Annotation( yn ctn ) )
 !x !yi cti for 1 ≤ i ≤ n
{ owl:DatatypeProperty ∈ Type(x) and OnlyAP(yi) = true for 1 ≤ i ≤ }		 EntityAnnotation( DataProperty(x)
Annotation( y1 ct1 ) ... Annotation( yn ctn ) )
 !x !yi cti for 1 ≤ i ≤ n
{ owl11:Individual ∈ Type(x) and OnlyAP(yi) = true for 1 ≤ i ≤ }		 EntityAnnotation( Individual(x)
Annotation( y1 ct1 ) ... Annotation( yn ctn ) )
x rdfs:subClassOf y SubClassOf( DESC(x) DESC(y) )
x owl:equivalentClass y EquivalentClasses( DESC(x) DESC(y) )
x owl:disjointWith y DisjointClasses( DESC(x) DESC(y) )
x owl11:disjointUnionOf T(SEQ y1 ... yn) DisjointUnion( DESC(x) DESC(y1) ... DESC(yn) )
x owl11:subObjectPropertyOf y SubObjectPropertyOf( OP(x) OP(y) )
x rdfs:subPropertyOf y
{ OnlyOP(x) = true and OnlyOP(y) = true }		 SubObjectPropertyOf( OP(x) OP(y) )
_:x owl11:subObjectPropertyOf y
_:x owl11:propertyChain T(SEQ x1 ... xn)		 SubObjectPropertyOf(
subObjectPropertyChain( OP(x1) ... OP(xn) ) OP(y) )
_:x rdfs:subPropertyOf y
_:x owl11:propertyChain T(SEQ x1 ... xn)		 SubObjectPropertyOf(
subObjectPropertyChain( OP(x1) ... OP(xn) ) OP(y) )
x owl11:equivalentObjectProperty y EquivalentObjectProperties( OP(x) OP(y) )
x owl:equivalentProperty y
{ OnlyOP(x) = true and OnlyOP(y) = true }		 EquivalentObjectProperties( OP(x) OP(y) )
x owl11:disjointObjectProperties y DisjointObjectProperties( OP(x) OP(y) )
x owl11:objectPropertyDomain y ObjectPropertyDomain( OP(x) DESC(y) )
x rdfs:domain y
{ OnlyOP(x) = true }		 ObjectPropertyDomain( OP(x) DESC(y) )
x owl11:objectPropertyRange y ObjectPropertyRange( OP(x) DESC(y) )
x rdfs:range y
{ OnlyOP(x) = true }		 ObjectPropertyRange( OP(x) DESC(y) )
x owl:inverseOf y InverseObjectProperties( OP(x) OP(y) )
x rdf:type owl:TransitiveProperty TransitiveObjectProperty( OP(x) )
x rdf:type owl11:FunctionalObjectProperty FunctionalObjectProperty( OP(x) )
x rdf:type owl:FunctionalProperty
{ OnlyOP(x) = true }		 FunctionalObjectProperty( OP(x) )
x rdf:type owl:InverseFunctionalProperty InverseFunctionalObjectProperty( OP(x) )
x rdf:type owl11:ReflexiveProperty ReflexiveObjectProperty( OP(x) )
x rdf:type owl11:IrreflexiveProperty IrreflexiveObjectProperty( OP(x) )
x rdf:type owl:SymmetricProperty SymmetricObjectProperty( OP(x) )
x rdf:type owl11:AsymmetricProperty AsymmetricObjectProperty( OP(x) )
x owl11:subDataPropertyOf y SubDataPropertyOf( DP(x) DP(y) )
x rdfs:subPropertyOf y
{ OnlyDP(x) = true and OnlyDP(y) = true }		 SubDataPropertyOf( DP(x) DP(y) )
x owl11:equivalentDataProperty y EquivalentDataProperties(dp1 ... dpn)
x owl:equivalentProperty y
{ OnlyDP(x) = true and OnlyDP(y) = true }		 EquivalentDataProperties(dp1 ... dpn)
x owl11:disjointDataProperties y DisjointDataProperties( DP(x) DP(y) )
x owl11:dataPropertyDomain y DataPropertyDomain( DP(x) DESC(y) )
x rdfs:domain y
{ OnlyDP(x) = true }		 DataPropertyDomain( DP(x) DESC(y) )
x owl11:dataPropertyRange y DataPropertyRange( DP(x) DRANGE(y) )
x rdfs:range y
{ OnlyDP(x) = true }		 DataPropertyRange( DP(x) DRANGE(y) )
x rdf:type owl11:FunctionalDataProperty FunctionalDataProperty( DP(x) )
x rdf:type owl:FunctionalProperty
{ OnlyDP(x) = true }		 FunctionalDataProperty( DP(x) )
!x owl:sameAs !y SameIndividual( x y )
!x owl:differentFrom !y DifferentIndividuals( x y )
 !x rdf:type y
{ y is not a part of RDF(S) or OWL 2 vocabulary }		 ClassAssertion( x DESC(y) )
 !x !y !z
{ none of x, y, and z is a part of RDF(S) or OWL 2 vocabulary }
{ owl:AnnotationProperty is not in Type(y) }		 ObjectPropertyAssertion( OP(y) x z )
_:x rdf:type owl11:NegativeObjectPropertyAssertion
_:x rdf:subject !w
_:x rdf:predicate !y
_:x rdf:object !z		 NegativeObjectPropertyAssertion( OP(y) w z )
 !x !y ct
{ neither x not y is a part of RDF(S) or OWL 2 vocabulary }
{ owl:AnnotationProperty is not in Type(y) }		 DataPropertyAssertion( DP(y) x ct )
_:x rdf:type owl11:NegativeDataPropertyAssertion
_:x rdf:subject !w
_:x rdf:predicate !y
_:x rdf:object ct		 NegativeDataPropertyAssertion( DP(y) w ct )
 !x owl11:declaredAs rdfs:Datatype Declaration( Datatype(x) )
 !x owl11:declaredAs owl:Class Declaration( OWLClass(x) )
 !x owl11:declaredAs owl:ObjectProperty Declaration( ObjectProperty(x) )
 !x owl11:declaredAs owl:DatatypeProperty Declaration( DataProperty(x) )
 !x owl11:declaredAs owl11:Individual Declaration( Individual(x) )
_:x rdf:type owl11:Axiom
_:x !yi cti 1 ≤ i ≤ n
_:x rdf:subject s
_:x rdf:predicate !p
_:x rdf:object o
 The result is the axiom obtained by matching the triple pattern s p o.
The axiom contains the following annotations:
Annotation( y1 ct1 ) ... Annotation( yn ctn ) )

If G contains some triple that is not matched by any triple pattern (including the patterns used to define Type(x)), then G cannot be translated into an OWL 2 ontology.

4 References

[OWL 2 Specification]
OWL 2 Web Ontology Language:Structural Specification and Functional-Style Syntax Boris Motik, Peter F. Patel-Schneider, Ian Horrocks. W3C Editor's Draft, 11 April 2008, http://www.w3.org/2007/OWL/draft/ED-owl2-syntax-20080411/. Latest version available at http://www.w3.org/2007/OWL/draft/owl2-syntax/.
[OWL 2 Semantics]
OWL 2 Web Ontology Language:Model-Theoretic Semantics Bernardo Cuenca Grau, Boris Motik. W3C Editor's Draft, 11 April 2008, http://www.w3.org/2007/OWL/draft/ED-owl2-semantics-20080411/. Latest version available at http://www.w3.org/2007/OWL/draft/owl2-semantics/.
[RDF Semantics]
RDF Semantics. Patrick Hayes, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/.