Copyright © 2008 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
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 68 documents:
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.
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.
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 |
This document provides a mapping from the functional-style syntaxmappings by means of which every OWL 2
as givenontology in the functional-style syntax [OWL 2 Specification]
to thecan be mapped into RDF exchange syntax for OWL 2triples and vice versa. Everyback without any change in the
formal meaning of the ontology. More precisely, let O be any
OWL 2 ontology canin functional-style syntax, let T(O) be serializedthe
set of RDF triples obtained by transforming O into RDF
triples as specified in RDF, so everySection 2, and let O' be the OWL 2 ontology in
RDF is a valid OWL Full ontology.functional-style syntax obtained by applying the reverse
transformation from Section 3 to T(O); then, O and O' are
logically equivalent — that is, they have exactly the same set of
models.
The RDF syntax of OWL 2 is backwards-compatible with that of OWL
DL, this is,DL: every OWL DL ontology in RDF issyntax can be mapped into a valid
OWL 2 ontology.ontology using the semanticsreverse-transformation from Section 3 such that the resulting OWL 2 is defined for ontologies inontology has exactly
the functional-style syntax.same set of models as the original 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 ].DL ontology.
The syntax for triples used herein this document is the one used in
the RDF Semantics document.[RDF
Semantics]. Full URIs are abbreviated using namespaces as usual. Editor's Note:the
actualnamespaces used infrom the OWL 2 Specification are subject to discussion and might change in future.[OWL 2
Specification].
The following notation is used throughout this document:document for
referring to parts of RDF graphs:
The italicized keywords MUST, MUST NOT, SHOULD,
SHOULD
NOT, and T(SEQ y 1 ... y n ) denotesMAY specify certain aspects of the encodingnormative
behavior of an RDF listOWL 2 tools, and are interpreted as shownspecified in Table 1. Table 1. Transformation of Sequences to Triples Sequence S Transformation T(S) Main Node of T(S) SEQ rdf:nil SEQ y 1 ... y n _:x rdf:type rdf:List _:x rdf:first T(y 1 ) _:x rdf:rest T(SEQ y 2 ... y n ) _:xRFC
2119 [RFC
2119].
Editor's Note: See Issue-2 (allDisjoint-RDF), Issue-68 (nonmonotonic mapping) and Issue-81 (reification, negative assertions). As explained in [ OWL 2 Specification ],This section defines a mapping of an OWL 2 ontology O in
functional-style syntax is fully typed -- that is, from the syntax, one can immediately see what is the intendend usageinto a set of some symbol. OWL 1.0 syntaxRDF triples T(O). The
mapping is not typed; rather, OWL 1.0 relies on explicit statementspresented in three parts. Section
2.1 shows how to translate axioms that determine the typedo not contain
annotations, Section
2.2 shows how to translate annotations, and Section 2.3
shows how to translate axioms containing annotations.
Table 1 presents the type of a symbol S inoperator T that maps an OWL 2
ontology O (inin functional-style syntax), written Type(S,O)syntax into a set of RDF
triples T(O), provided that no axiom in O is
annotated. The mapping is defined asrecursively, i.e., the smallest set such that if the parse treemapping of
O contains S undera objectPropertyURI node, then owl:ObjectProperty ∈ Type(S,O) ; ifconstruct often depends on the parse treemappings of O contains S underits sub-constructs,
but in a dataPropertyURI node, then owl:DatatypeProperty ∈ Type(S,O) ;slightly unusual way. If the parse treemapping of O contains S undera annotationURI node, then owl:AnnotationProperty ∈ Type(S,O) ; ifconstruct refers
to the parse treemapping of O contains S undera owlClassURI node,sub-construct, then owl:Class ∈ Type(S,O) ; ifthe parse treetriples generated by
the recursive invocation of O contains ST are added to the graph under
a datatypeURI node, then rdfs:Datatype ∈ Type(S,O) ;construction, and if the parse treeits main node is used in place of O contains S under a individualURI node, then owl11:Individual ∈ Type(S,O) .the
aboveinvocation itself.
The definition refers to a parse tree only forof the axioms from O , and not fromoperator T uses the axioms from some ontology that O imports. A symbol S in punnedoperator
TANN in an ontology O if Type(S,O) contains more than one element. Based on that,order to translate annotations. The following two conditions are defined: OnlyOP(S)operator
TANN is true if and only if owl:ObjectProperty ∈ Type(S,O) and owl:DatatypeProperty and owl:AnnotationProperty are notdefined in Type(S,O) ; OnlyDP(S) is true if and only if owl:DatatypeProperty ∈ Type(S,O)Section 2.2. It takes an annotation and owl:ObjectPropertyan URI
reference or a blank node and owl:AnnotationProperty are notproduces the triples that attach the
annotation to the supplied object.
In Type(S,O) ; OnlyAP(S)the mapping of DatatypeRestriction, faceti
is true if and only if owl:AnnotationProperty ∈ Type(S,O)one of the constraining facets listed in Section 4 of the OWL 2
Specification [OWL 2 Specification], and
owl:ObjectPropertyxsd:faceti is a URI resource whose namespace is
xsd: and owl:DatatypeProperty arewhose fragment is the constraining facet name. In the
mapping, each generated blank node (i.e., each blank node that does
not correspond to an anonymous individual) is fresh in Type(S,O) .each
application of a mapping rule. Furthermore, the following
shortcutsconventions are used in the translationthis section to denote different syntactic
parts of OWL 2 ontologies into RDF: RESTRICTION[op] expands to owl:Restriction if OnlyOP(op) = true , and to owl11:ObjectRestriction otherwise; RESTRICTION[dp] expands to owl:Restriction if OnlyDP(dp) = true , and to owl11:DataRestriction otherwise; SUBPROPERTYOF[op 1 ,...,op n ] expands to rdfs:subPropertyOf if OnlyOP(op i ) = true for each 1 ≤ i ≤ n, and to owl11:subObjectPropertyOf otherwise; SUBPROPERTYOF[dp 1 ,dp 2 ] expands to rdfs:subPropertyOf if OnlyDP(dp 1 ) = true and OnlyDP(dp 2 ) = true , and to owl11:subDataPropertyOf otherwise; EQUIVALENTPROPERTY[op 1 ,...,op n ] expands to owl:equivalentProperty if OnlyOP(op i ) = true for each 1 ≤ i ≤ n,ontologies:
In this section, T(SEQ y1 ,...,dp...
yn ] expands to owl:equivalentProperty if OnlyDP(dp i) = true for each 1 ≤ i ≤ n, and to owl11:equivalentDataProperty otherwise; FUNCTIONALPROPERTY[op] expands to owl:FunctionalProperty if OnlyOP(op) = true , and to owl11:FunctionalObjectProperty otherwise; FUNCTIONALPROPERTY[dp] expands to owl:FunctionalProperty if OnlyDP(dp) = true , and to owl11:FunctionalDataProperty otherwise; DOMAIN[op] expands to rdfs:domain if OnlyOP(op) = true , and to owl11:objectPropertyDomain otherwise; DOMAIN[dp] expands to rdfs:domain if OnlyDP(dp) = true , and to owl11:dataPropertyDomain otherwise; RANGE[op] expands to rdfs:range if OnlyOP(op) = true , and to owl11:objectPropertyRange otherwise; and RANGE[dp] expands to rdfs:range if OnlyDP(dp) = true , and to owl11:dataPropertyRange otherwise. Table 2 presentsdenotes the translation of a sequence of
objects from the operator T that translates an OWL 2 ontology infunctional-style syntax into a set ofan RDF triples. This table does not consider axioms with annotations: the translation of such axioms is describedlist, as shown
in Section 2.1 .Table 2.1.
Functional-Style Syntax S | |
Main Node of T(S) |
---|---|---|
|
rdf:nil | |
SEQ y1 ... yn | _:x rdf:first T(y1) _:x rdf:rest T(SEQ y2 ... |
|
Ontology( ontologyURI [ versionURI ] Import( importedOntologyURI1 ) ... annotation1 ... annotationm axiom1 ... axiom ) |
ontologyURI rdf:type owl:Ontology [ ontologyURI owl:versionInfo versionURI ] ontologyURI owl:imports ontologyURI owl:imports importedOntologyURIk TANN(annotation1,ontologyURI) ... TANN(annotationm,ontologyURI) T(axiom1) ... T(axiomn) |
ontologyURI |
Import( importedOntologyURI1 ) Import( importedOntologyURIk ) annotation1 annotationm axiom1 ... axiomn |
_:x rdf:type owl:Ontology _:x owl:imports importedOntologyURI1 _:x owl:imports importedOntologyURIk TANN(annotation1,_:x) ... TANN(annotationm T(axiom1) ... T(axiomn) |
_:x |
C | C | |
Class( C ) | C | |
DT | DT | |
Datatype( DT ) | DT | |
OP | OP | |
ObjectProperty( OP ) | OP | |
DP | DP | |
DataProperty( DP ) | DP | |
AP | AP | |
AnnotationProperty( AP ) | AP | |
a | a | |
NamedIndividual( *:a ) | *:a | |
lt | lt | |
Declaration( Datatype( DT ) ) | T(DT) rdf:type rdfs:Datatype | |
|
T(C) rdf:type owl:Class | |
|
T(OP) rdf:type owl:ObjectProperty | |
|
T(DP) rdf:type owl:DatatypeProperty | |
|
T(AP) rdf:type owl:AnnotationProperty | |
|
T(*:a) rdf:type owl:NamedIndividual | |
InverseOf( OP ) | _:x owl:inverseOf T(OP) | _:x |
ComplementOf( DR ) | _:x rdf:type _:x |
_:x |
|
_:x rdf:type _:x owl:oneOf T(SEQ |
_:x |
facet1 ... facetn ) |
_:x rdf:type _:x _:x ... _:yn xsd:facetn ltn |
_:x |
|
_:x rdf:type owl:Class _:x |
_:x |
|
_:x rdf:type owl:Class _:x |
_:x |
|
_:x rdf:type owl:Class _:x owl:complementOf |
_:x |
|
_:x rdf:type owl:Class _:x owl:oneOf T(SEQ |
_:x |
|
_:x rdf:type _:x owl:onProperty _:x owl:someValuesFrom |
_:x |
|
_:x rdf:type _:x owl:onProperty _:x owl:allValuesFrom |
_:x |
|
_:x rdf:type _:x owl:onProperty _:x |
_:x |
ExistsSelf( OPE ) | _:x rdf:type _:x owl:onProperty |
_:x |
|
_:x rdf:type _:x owl:minCardinality _:x owl:onProperty |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty _:x |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty _:x |
_:x |
ExactCardinality( n OPE ) | _:x rdf:type _:x _:x owl:onProperty |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty _:x |
_:x |
SomeValuesFrom( DPE DR ) | _:x rdf:type _:x owl:onProperty _:x owl:someValuesFrom T(DR) |
_:x |
|
_:x rdf:type _:x _:x owl:someValuesFrom T(DR) |
_:x |
|
_:x rdf:type _:x owl:onProperty _:x owl:allValuesFrom T(DR) |
_:x |
|
_:x rdf:type _:x _:x owl:allValuesFrom T(DR) |
_:x |
|
_:x rdf:type _:x owl:onProperty _:x owl:hasValue |
_:x |
|
_:x rdf:type _:x owl:minCardinality _:x owl:onProperty |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty _:x |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty _:x owl:onDataRange T(DR) |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty |
_:x |
|
_:x rdf:type _:x _:x owl:onProperty _:x |
_:x |
SubClassOf( CE1 CE2 ) | |
|
EquivalentClasses( CE1 |
... |
|
DisjointClasses( CE1 |
|
|
|
_:x rdf:type owl:AllDisjointClasses _:x owl:members T(SEQ CE1 ... |
|
|
|
|
|
|
|
|
_:x _:x |
|
|
... T(OPEn-1) owl:equivalentProperty T(OPEn |
|
DisjointProperties( OPE1 OPE2 ) | T(op1) owl:propertyDisjointWith
T(op |
|
DisjointProperties( OPE1 |
_:x rdf:type owl:AllDisjointProperties _:x owl:members T(SEQ OPE1 ... |
|
|
|
|
PropertyRange( OPE CE ) | T(OPE) rdfs:range T(CE) | |
InverseProperties( OPE1 |
|
|
|
T(OPE) rdf:type |
|
InverseFunctionalProperty( OPE ) | T(OPE) rdf:type owl:InverseFunctionalProperty | |
|
T(OPE) rdf:type |
|
IrreflexiveProperty( OPE ) | T(OPE) rdf:type |
|
SymmetricProperty( OPE ) | T(OPE) rdf:type owl:SymmetricProperty | |
|
T(OPE) rdf:type owl:AsymmetricProperty | |
TransitiveProperty( OPE ) | T(OPE) rdf:type |
|
SubPropertyOf( DPE1 |
|
|
|
T(DPEn-1) |
|
DisjointProperties( DPE1 |
|
|
DisjointProperties( DPE1 |
_:x rdf:type owl:AllDisjointProperties _:x owl:members T(SEQ DPE1 ... |
|
|
T(DPE) rdfs:domain T(CE) | |
PropertyRange( DPE DR ) | T(DPE) rdfs:range T(DR) | |
FunctionalProperty( DPE ) | T(DPE) rdf:type owl:FunctionalProperty | |
HasKey( CE PE1 ... PEn ) | T(CE) owl:hasKey T(SEQ PE1 ...
PEn) |
|
SameIndividual( a1 ... an ) | T(a1) owl:sameAs T(a2) ... T(an-1) owl:sameAs T(an) |
|
DifferentIndividuals( a1 a2 ) | T(a1) owl:differentFrom |
|
DifferentIndividuals( a1 |
_:x rdf:type _:x owl:members T(SEQ a1 ... an) |
|
ClassAssertion( CE a ) | T(a) rdf:type T(CE) | |
PropertyAssertion( OP a1 |
|
|
PropertyAssertion( InverseOf( OP ) a1 a2 ) | T(a2) |
|
NegativePropertyAssertion( OPE a1 |
_:x rdf:type _:x _:x _:x |
|
|
T(a) T(DPE) T(lt) | |
NegativePropertyAssertion( DPE a lt ) | _:x rdf:type _:x _:x _:x |
|
EntityAnnotation( Class( C ) annotation1 ... annotationm ) |
TANN(annotation1,T(C)) ... TANN(annotationm,T(C)) |
|
EntityAnnotation( Datatype( DT ) annotation1 ... annotationm ) |
TANN(annotation1,T(DT)) ... TANN(annotationm,T(DT)) |
|
EntityAnnotation( ObjectProperty( OP ) annotation1 ... annotationm ) |
TANN(annotation1,T(OP)) ... TANN(annotationm,T(OP)) |
|
EntityAnnotation( DataProperty( DP ) annotation1 ... annotationm ) |
TANN(annotation1,T(DP)) ... TANN(annotationm,T(DP)) |
|
EntityAnnotation( AnnotationProperty( AP ) annotation1 ... annotationm ) |
TANN(annotation1,T(AP)) ... TANN(annotationm,T(AP)) |
|
EntityAnnotation( NamedIndividual( *:a ) annotation1 ... annotationm ) |
TANN(annotation1,T(*:a)) ... TANN(annotationm,T(*:a)) |
|
AnonymousIndividualAnnotation( _:a annotation1 ... annotationm ) |
TANN(annotation1,T(_:a)) ... TANN(annotationm,T(_:a)) |
The corresponding axiom withoutoperator TANN, which translates annotations givenand
attaches them to an URI reference or a blank node, is defined in
Table 22. Note that Label, Comment, and the axiom containsDeprecated are
syntactic abbreviations, so they are not listed in Table 2.
|
Triples Generated in an Invocation of TANN(ann,y) |
---|---|
Annotation( AP elt ) | |
Annotation( annotation1 annotationn AP elt ) |
_:x rdf:type owl:Annotation _:x owl:subject y _:x owl:predicate T(AP) _:x owl:object T(etl) TANN(annotation1,_:x) ... TANN(annotationn,_:x) |
Consider the following entity annotation, which associates a:Peter with a simple label.
EntityAnnotation( NamedIndividual(a:Peter)
Label( "Peter Griffin" )
)
This axiom is serialized as follows:translated into the following triple:
a:Peter rdfs:label "Peter
Griffin"^^xsd:string
Consider the following axioms, which associates a:Peter with an annotation containing a nested annotation.
EntityAnnotation( NamedIndividual(a:Peter)
Annotation(
Annotation( a:author
a:Seth_MacFarlane )
rdfs:label "Peter
Griffin"
)
)
This axiom is translated into the following triples:
_:x rdf:type owl11:Axiomowl:Annotation
_:x T(apID i ) T(ct i ) 1 ≤ i ≤ nowl:subject a:Peter
_:x rdf:subject sowl:predicate rdfs:label
_:x rdf:predicate powl:object "Peter Griffin"^^xsd:string
_:x rdf:object o Negative object and data property assertions are already reified so only the following triples are addeda:auhtor a:Seth_MacFarlane
If an assertionaxiom ax contains an annotation: _:x T(apID i ) T(ct i )embedded annotations annotation1 ≤ i ≤ n... annotationm,
its serialization into RDF depends on the type of the axiom. In the
following discussion, let ax' be the axiom that is obtained
from ax by removing all annotations. Note that the
Label and Comment annotations are just abbreviations.abbreviations, so they
are serialized into RDF triplesby expanding the abbreviation and then
applying the transformation from Table 2. 3 Translation from RDF Graphsserialization presented here.
If ax' is translated into an OWL 2 ontology in functional-style syntaxa single RDF triple
s p o, if possible.then the function Type(x) assigns a setaxiom ax generates
the following triples instead of types to each resource node x in G (intriple s p
o:
_:x rdf:type owl:Axiom
_:x owl:subject s
_:x owl:predicate p
_:x owl:object o
TANN(annotation1,_:x)
...
TANN(annotationm,_:x)
This and all other definitions, the graph G is implicitly understood and is not specified explicitly) andis defined asthe smallest set satisfyingcase for the conditions from Table 3. Table 3. Types of Nodes in a Graph If G containsfollowing axioms: SubClassOf, DisjointClasses with two classes, SubPropertyOf without a triple of this form... ...then Type(x) must contain this URI. xproperty chain as the
subproperty expression, PropertyDomain, PropertyRange, InverseProperties, FunctionalProperty, InverseFunctionalProperty, ReflexiveProperty, IrreflexiveProperty, SymmetricProperty, AsymmetricProperty, TransitiveProperty, DisjointProperties with two properties,
ClassAssertion, PropertyAssertion, Declaration, and DifferentIndividuals with two individuals.
Consider the following subclass axiom:
SubClassOf( Comment( "Children are people." ) a:Child a:Person )
Without the annotation, the axiom would be translated into the following triple:
a:Child rdfs:subClassOf a:Person
Thus, the annotated axiom is transformed into the following triples:
_:x rdf:type owl:Axiom
_:x owl:subject a:Child
_:x owl:predicate rdfs:subClassOf
_:x owl:object a:Person
_:x rdfs:comment "Children are people."
Axioms DisjointUnion, SubPropertyOf with a subproperty chain, and HasKey are, without annotations, translated into several, and not a single triple. If such such axioms are annotated, then the main triple is subjected to the transformation described above. The other triples — called side triples — are output without any change.
Consider the following subproperty axiom:
SubPropertyOf( Comment( "An aunt is a mother's sister." ) PropertyChain( a:hasMother a:hasSister ) a:hasAunt ) )
Without the annotation, the axiom would be translated into the following triples:
_:y rdfs:subPropertyOf a:hasAunt
_:y owl:propertyChain _:z1
_:z1 rdf:first a:hasMother
_:z1 rdf:rest _:z2
_:z2 rdf:first a:hasSister
_:z2 rdf:rest rdf:nil
In order to capture the annotation on the axiom, the first triple plays the role of the main triple for the axiom, so it is represented using a fresh blank node _:x in order to be able to attach the annotation to it.
_:x rdf:type owl:Axiom
_:x owl:subject _:y
_:x owl:predicate rdfs:subPropertyOf
_:x owl:object a:hasAunt
_:x rdfs:comment "An aunt is a mother's sister."
_:y owl:propertyChain _:z1
_:z1 rdf:first a:hasMother
_:z1 rdf:rest _:z2
_:z2 rdf:first a:hasSister
_:z2 rdf:rest rdf:nil
Consider the following key axiom:
HasKey( Comment( "SSN uniquely determines a person." ) a:Person a:hasSSN )
Without the annotation, the axiom would be translated into the following triples:
a:Person owl:hasKey _:y
_:y rdf:first a:hasSSN
_:y rdf:rest rdf:nil
In order to capture the annotation on the axiom, the first triple plays the role of the main triple for the axiom, so it is represented using a fresh blank node _:x in order to be able to attach the annotation to it.
_:x rdf:type owl:Axiom
_:x owl:subject a:Person
_:x owl:predicate owl:hasKey
_:x owl:object _:y
_:x rdfs:comment "SSN uniquely determines a person."
_:y rdf:first a:hasSSN
_:y rdf:rest rdf:nil
If the axiom ax' is of type EquivalentClasses, EquivalentProperties, SameIndividual, or EntityAnnotation its translation into RDF can be broken up into several RDF triples (because RDF can only represent binary relations). In this case, each of the RDF triples obtained by the translation of ax' is transformed as described in previous section, and the annotations are repeated for each of the triples obtained in the translation.
Consider the following individual equality axiom:
SameIndividual( Annotation( a:source a:Fox ) a:Meg a:Megan a:Megan_Griffin )
This axiom is first split into the following equalities between pairs of individuals, and the annotation is repeated on each axiom obtained in this process:
SameIndividual( Annotation( a:source a:Fox )
a:Meg a:Megan )
SameIndividual( Annotation( a:source a:Fox )
a:Megan a:Megan_Griffin )
Each of these axioms is now transformed into triples as explained in the previous section:
_:x1 rdf:type owl:Axiom
_:x1 owl:subject a:Meg
_:x1 owl:predicate owl:sameAs
_:x1 owl:object a:Megan
_:x1 a:source a:Fox
_:x2 rdf:type owl:Axiom
_:x2 owl:subject a:Megan
_:x2 owl:predicate owl:sameAs
_:x2 owl:object a:Megan_Griffin
_:x2 a:source a:Fox
If the axiom ax' is of type NegativePropertyAssertion, DisjointClasses with more than two classes, DisjointUnion with more than two properties, or DifferentIndividuals with more than two individuals, then its translation already requires introducing a blank node _:x. In such cases, ax is translated by first translating ax' into _:x as shown in Table 1, and then attaching the annotations of ax to _:x.
Consider the following negative property assertion:
NegativePropertyAssertion( Annotation( a:author a:Seth_MacFarlane ) a:brotherOf a:Chris a:Stewie )
Even without the annotation, this axiom would be represented using a blank node. The annotation can readily be attached to this node, so the axiom is transformed into the following triples:
_:x rdf:type owl:NegativePropertyAssertion
_:x owl:sourceIndividual a:Chris
_:x owl:assertionProperty a:brotherOf
_:x owl:targetIndividual a:Stewie
_:x a:author a:Seth_MacFarlane
This section specifies canonical RDF parsing — a process that transforms a set of RDF triples G into an OWL 2 ontology O in functional-style syntax, if possible. This process is specified as an instance of canonical parsing, defined in Section 5.9.3 of the OWL 2 Specification [OWL 2 Specification]. It is important to understand that canonical RDF parsing merely defines the result of the transformation. An OWL 2 implementation MAY implement whatever algorithm it chooses; however, the result MUST be structurally equivalent to the result of canonical RDF parsing.
Canonical RDF parsing maintains the following functions that map a URI reference or a blank node x occurring in G into a fragment of the functional-style syntax. In particular,
Initially, these functions are undefined for all URIs and blank nodes occurring in G; this is written as CE(x) = ε, DR(x) = ε, OPE(x) = ε, DPE(x) = ε, and AP(x) = ε. The functions are updated as parsing progresses. If at any point in time the following conditions become invalidated, G MUST be rejected as syntactically incorrect.
If there is an attempt to redefine (i.e., change after the initial definition) the value of any of these functions for any x, then G MUST be rejected as syntactically incorrect.
The following sections contain rules in which triple patterns are matched to G. The following notation is used to denote parts of the patterns that are matched to literals with integer value:
Additional conditions on the pattern are enclosed in curly braces { }. Some patterns use optional parts, which are enclosed in square brackets '[ ]'. If a pattern contains a variable number of triples, the maximal possible subset of G MUST be matched.
The abbreviation T(SEQ y1 ... yn) denotes the pattern corresponding to RDF lists, as shown in Table 3. This is the same mapping for lists as used in Table 1, but here it is used to recognize lists instead of mapping them.
Sequence S | Triples Corresponding to T(S) | Main Node of T(S) |
---|---|---|
SEQ | rdf:nil | |
SEQ y1 ... yn | _:x rdf:first y1 _:x rdf:rest T(SEQ y2 ... yn) |
_:x |
First, the ontology header is extracted from G. In particular, if G does not contain a triple whose predicate is rdf:type and object is owl:Ontology, then the ontology header is Ontology( ... ). Otherwise, patterns from Table 4 are matched to G; if no such pattern can be matched in G, or if the pattern can be matched to G in more than one way, the graph G MUST be rejected as syntactically incorrect. Each time a triple pattern is matched, the matched triples are removed from G.
If G contains this pattern... | ...then the ontology header has this form. |
---|---|
*:x rdf:type owl:Ontology [ *:x owl:versionInfo *:y ] *:x owl:imports z1 ... *:x owl:imports zk { The following triple pattern cannot be matched in G: u w *:x u rdf:type owl:Ontology w rdf:type owl:OntologyProperty } |
Ontology( *:x [ *:y ] Import( z1 ) ... Import( zk ) ... ) |
_:x rdf:type owl:Ontology _:x owl:imports y1 ... _:x owl:imports yk { The following triple pattern cannot be matched in G: u w _:x u rdf:type owl:Ontology w rdf:type owl:OntologyProperty } |
Ontology( Import( y1 ) ... Import( yk ) ... ) |
Next, for backwards compatibility with OWL DL, certain redundant triples are removed from G. In particular, if the triple pattern from the left-hand side of Table 5 is matched in G, then the triples on the right-hand side of Table 5 are removed from G.
If G contains this pattern... | ...then these triples are removed from G. |
---|---|
x rdf:type owl:Ontology | x rdf:type owl:Ontology |
x rdf:type owl:Class |
x rdf:type rdfs:Class |
x rdf:type rdfs:Datatype x rdf:type rdfs:Class |
x rdf:type rdfs:Class |
x rdf:type owl:DataRange x rdf:type rdfs:Class |
x rdf:type rdfs:Class |
x rdf:type owl:Restriction x rdf:type rdfs:Class |
x rdf:type rdfs:Class |
x rdf:type owl:Restriction x rdf:type owl:Class |
x rdf:type |
x rdf:type x rdf:type rdf:Property |
x rdf:type rdf:Property |
x rdf:type owl:FunctionalProperty x rdf:type rdf:Property |
x rdf:type rdf:Property |
x rdf:type owl:InverseFunctionalProperty x rdf:type rdf:Property |
x rdf:type rdf:Property |
x rdf:type owl:TransitiveProperty x rdf:type rdf:Property |
x rdf:type rdf:Property |
x rdf:type owl:DatatypeProperty x rdf:type rdf:Property |
x rdf:type rdf:Property |
x rdf:type owl:AnnotationProperty x rdf:type rdf:Property |
x rdf:type rdf:Property |
x rdf:type owl:OntologyProperty x rdf:type rdf:Property |
x rdf:type rdf:Property |
x rdf:type rdf:List x rdf:first y x rdf:rest z |
x rdf:type rdf:List |
Next, for backwards compatibility with OWL DL, G is modified such that declarations can be properly extracted in the next step. When a triple pattern from the first column of Table 6 is matched in G, the matching triples are replaced in G with the triples from the second column. This matching phase stops when matching a pattern and replacing it as specified does not change G. Note that G is a set and thus cannot contain duplicate triples, so this last condition prevents infinite matches.
If G contains this pattern... | ...then the matched triples are replaced in G with these triples. |
---|---|
*:x rdf:type owl:OntologyProperty | *:x rdf:type |
*:x rdf:type |
*:x rdf:type owl:ObjectProperty |
*:x rdf:type owl:TransitiveProperty | *:x rdf:type owl:ObjectProperty |
*:x rdf:type owl:SymmetricProperty | |
Finally, the set of declarations Decl(O) is extracted from G according to Table 7. The matched triples are not removed from G — the triples from Table 7 can contain annotations so, in order to correctly parse the annotations, they will be matched again in the step described in Section 3.4.
If G contains this pattern... | ...then this declaration is added to Decl(O). |
---|---|
*:x rdf:type |
Declaration( Class( *:x ) ) |
*:x rdf:type rdfs:Datatype | Declaration( Datatype( *:x ) ) |
*:x rdf:type |
|
*:x rdf:type owl:DatatypeProperty | |
*:x rdf:type owl:AnnotationProperty | Declaration( AnnotationProperty( *:x ) ) |
*:x rdf:type owl:NamedIndividual | Declaration( NamedIndividual( *:x ) ) |
_:x rdf:type owl:Axiom _:x owl:subject *:y _:x owl:predicate rdf:type _:x owl:object owl:Class |
Declaration( Class( *:y ) ) |
_:x rdf:type owl:Axiom _:x owl:subject *:y _:x owl:predicate rdf:type _:x owl:object rdfs:Datatype |
Declaration( Datatype( *:y ) ) |
_:x rdf:type owl:Axiom _:x owl:subject *:y _:x owl:predicate rdf:type _:x owl:object owl:ObjectProperty |
Declaration( ObjectProperty( *:y ) ) |
_:x rdf:type owl:Axiom _:x owl:subject *:y _:x owl:predicate rdf:type |
|
_:x rdf:type owl:Axiom _:x owl:subject *:y _:x owl:predicate rdf:type _:x owl:object owl:AnnotationProperty |
|
_:x rdf:type owl:Axiom _:x owl:subject *:y _:x owl:predicate rdf:type |
Declaration( NamedIndividual( *:y ) ) |
Next, for a resource node xeach ontology O' imported into O, the
ontology header and declarations are determined. If the ontology
O' is written in RDF then this is done as above. If the
ontology O' is written in some other format then the
ontology header and declarations are determined according to the
rules appropriate to the ontology format.
The set AllDecl(O) of all declarations is computed by taking the union of the set Decl(O), the sets Decl(O') for each ontology O' imported (directly or indirectly) into O, and the declarations for built-in entities from Table 10 of the OWL 2 Specification [OWL 2 Specification]. The declarations in AllDecl(O) are checked for typing constraints, as specified in Section 5.9.1 of the OWL 2 Specification [OWL 2 Specification]. If the constraints are not satisfied, the graph G MUST be rejected as syntactically incorrect.
Next, the functions OnlyOP(x)CE, DR, OPE, DPE, and OnlyDP(x)AP are definedinitialized
as follows: OnlyOP(x) is true ifshown in Table 8.
If |
...then perform this assignment. |
---|---|
Declaration( Class( *:x ) ) | CE(*:x) := a class with the URI *:x |
Declaration( Datatype( *:x ) ) | DR(*:x) := a datatype with the URI *:x |
Declaration( ObjectProperty( *:x ) ) | OPE(*:x) := an object property with the URI *:x |
Declaration( DataProperty( *:x ) ) | DPE(*:x) := a data property with the URI *:x |
Declaration( AnnotationProperty( *:x ) ) | AP(*:x) := an annotation property with the URI *:x |
The function OPEorDPE is truedefined as
follows: OPEorDPE(x) = OPE(x) if and onlyOPE(x) ≠ ε;
OPEorDPE(x) = DPE(x) if owl:DatatypeProperty ∈ Type(x) and owl:ObjectPropertyDPE(x) ≠ ε; and
owl:AnnotationProperty are notOPEorDPE(x) = ε otherwise.
The annotations in Type(x) ; OnlyAP(x)G are parsed next. To this end,
canonical RDF parsing uses a function ANN
that assigns a set of annotations ANN(x)
to each URI reference or a blank node x.
This function is true if and only if owl:AnnotationProperty ∈ Type(x) and owl:ObjectPropertyinitialized by setting ANN(x) = ∅ for each each URI reference or a blank
node x. Next, triple patters from the
headers of Tables 9 and owl:DatatypeProperty10 are notmatched in Type(x)G. For each
matched pattern, ANN(x) is extended with
all annotations from the following partial functionsright columns of the tables matching the
respective conditions in the left columns. Each time one of these
triple patterns is matched, the matched triples are definedremoved from
G. This process is repeated until no further matches are
possible.
For each |
...this annotation is added to |
---|---|
z is a URI reference and CE(z) is a class | Annotation( *:y Class( CE(z) ) ) |
z is a URI reference and DR(z) is a datatype | Annotation( *:y Datatype( DR(z) ) ) |
z is a URI reference and OPE(z) is an object property | |
z is a URI reference and DPE(z) is a data property | |
z is a |
Annotation( *:y AnnotationProperty( AP(z) ) ) |
z is DPE(z), and AP(z) are all equal to |
Annotation( *:y NamedIndividual( z ) ) |
z is blank node | Annotation( *:y z ) |
For each triple pattern _:w rdf:type owl:Annotation
such that AP(*:y) ≠ ε and_:w owl:subject x _:w owl:predicate *:y _:w owl:object z no triple for each |
...this annotation is added to |
---|---|
z is |
Annotation( ANN(_:w) *:y Class( CE(z) ) ) |
z is a URI reference and DR(z) is a datatype | Annotation( ANN(_:w) *:y Datatype( DR(z) ) ) |
z is a URI reference and OPE(z) is an object property | Annotation( ANN(_:w) *:y ObjectProperty( OPE(z) ) ) |
z is a URI reference and DPE(z) is a data property | Annotation( ANN(_:w) *:y DataProperty( DPE(z) ) ) |
z is a URI reference and AP(z) is an annotation property | Annotation( ANN(_:w) *:y AnnotationProperty( AP(z) ) ) |
z is a URI reference and CE(z), DR(z), OPE(z), DPE(z), and AP(z) are all equal to |
Annotation( ANN(_:w) *:y NamedIndividual( z ) ) |
z is blank node | Annotation( ANN(_:w) *:y z ) |
Let x be the node that is matched to
*:x or _:x
while parsing the ontology header of these functions, then G cannot be translated into an OWL 2 ontology. Also, ifO according to the
valuepatterns from Table 4. Then, ANN(x)
determines the set of oneontology annotations of theseO.
Next, the functions is not defined for some node occurringOPE, DR, and CE are extended as
shown in Tables 11, 12, and 13, as well as in Tables 14 and 15. The
functional-style syntax encoding, then G cannotpatterns in the latter two tables are not generated by the mapping
from Section 2, but they can be translated into anpresent in RDF graphs that
encode OWL 2 ontology. Table 4. Translation ofDL ontologies. Each time a pattern is matched, the
matched triples are removed from G. Pattern matching is
repeated until no triple pattern can be matched to G.
|
...then OPE(_:x) is set to this object property
|
---|---|
_:x { OPE(_:x) = ε and OPE(*:y) ≠ ε } |
InverseOf( OPE(*:y) ) |
|
...then DR(_:x) is set to this data |
---|---|
_:x rdf:type _:x owl:datatypeComplementOf y { DR(y) ≠ ε } |
ComplementOf( DR(y) ) |
_:x rdf:type rdfs:Datatype _:x owl:oneOf T(SEQ lt1 ... ltn) |
OneOf( lt1 ... ltn ) |
_:x rdf:type rdfs:Datatype _:x owl:onDatatype *:y _:x owl:withRestrictions T(SEQ _:z1 ... _:zn) _:z1 xsd:facet1 lt1 ... _:zn xsd:facetn ltn { DR(*:y) is a datatype } |
DatatypeRestriction( DR(*:y) facet1 lt1 ... facetn ltn ) |
If G contains this pattern... | ...then CE(_:x) is set to this class expression. |
---|---|
_:x rdf:type owl:Class _:x owl:complementOf y |
ComplementOf( CE(y) ) |
_:x rdf:type owl:Class _:x owl:unionOf T(SEQ y1 ... yn) { n ≥ 2 and CE(yi) ≠ ε for each 1 ≤ i ≤ n } |
UnionOf( CE(y1) ... CE(yn) ) |
_:x rdf:type owl:Class _:x owl:intersectionOf T(SEQ y1 ... yn) { n ≥ 2 and CE(yi) ≠ ε for each 1 ≤ i ≤ n } |
IntersectionOf( CE(y1) ... CE(yn) ) |
_:x rdf:type _:x owl:oneOf T(SEQ |
|
_:x rdf:type _:x { OPE(y) ≠ ε } |
ExistsSelf( OPE(y) ) |
_:x _:x _:x { OPE(y) ≠ ε } |
HasValue( OPE(y) *:z ) |
_:x _:x owl:onProperty y _:x owl:someValuesFrom z { OPE(y) ≠ ε and CE(z) ≠ ε } |
SomeValuesFrom( OPE(y) CE(z) ) |
_:x rdf:type owl:Restriction _:x owl:onProperty y _:x owl:allValuesFrom z { OPE(y) ≠ ε and CE(z) ≠ ε } |
AllValuesFrom( OPE(y) CE(z) ) |
_:x rdf:type owl:Restriction _:x owl:minQualifiedCardinality NN_INT(n) _:x owl:onProperty y _:x owl:onClass z { OPE(y) ≠ ε and CE(z) ≠ ε } |
MinCardinality( n |
_:x rdf:type owl:Restriction _:x owl:maxQualifiedCardinality NN_INT(n) _:x owl:onProperty y _:x owl:onClass z { OPE(y) ≠ ε and CE(z) ≠ ε } |
MaxCardinality( n OPE(y) CE(z) ) |
_:x _:x owl:onProperty y { OPE(y) ≠ ε and CE(z) ≠ ε } |
ExactCardinality( n OPE(y) CE(z) ) |
_:x rdf:type owl:Restriction _:x owl:minCardinality NN_INT(n) _:x owl:onProperty y { OPE(y) ≠ ε } |
MinCardinality( n OPE(y) ) |
_:x owl:maxCardinality NN_INT(n) _:x owl:onProperty y { OPE(y) ≠ ε } |
MaxCardinality( n OPE(y) ) |
_:x owl:cardinality NN_INT(n) _:x owl:onProperty y { OPE(y) ≠ ε } |
ExactCardinality( n OPE(y) ) |
_:x rdf:type owl:Restriction _:x owl:onProperty y _:x owl:hasValue lt { DPE(y) ≠ ε } |
HasValue( DPE(y) lt ) |
_:x rdf:type _:x _:x owl:someValuesFrom z { DPE(y) ≠ ε and DR(z) ≠ ε } |
SomeValuesFrom( DPE(y) DR(z) ) |
_:x rdf:type owl:Restriction _:x owl:onProperties T(SEQ y1 ... yn) { DPE(yi) ≠ ε for each 1 ≤ i ≤ n and DR(z) ≠ ε } |
SomeValuesFrom( DPE(y1) ... |
_:x rdf:type _:x { DPE(y) ≠ ε and DR(z) ≠ ε } |
AllValuesFrom( DPE(y) DR(z) ) |
_:x rdf:type _:x _:x owl:allValuesFrom z { DPE(yi) ≠ ε for each 1 |
AllValuesFrom( DPE(y1) ... |
_:x rdf:type _:x owl:minQualifiedCardinality NN_INT(n) _:x owl:onProperty y { DPE(y) ≠ ε and DR(z) ≠ ε } |
MinCardinality( n DPE(y) DR(z) ) |
_:x rdf:type _:x owl:maxQualifiedCardinality NN_INT(n) _:x owl:onProperty y _:x { DPE(y) ≠ ε and DR(z) ≠ ε } |
MaxCardinality( n DPE(y) DR(z) ) |
_:x rdf:type owl:Restriction _:x owl:qualifiedCardinality NN_INT(n) _:x owl:onProperty y _:x { |
|
_:x rdf:type _:x owl:minCardinality NN_INT(n) _:x owl:onProperty y |
MinCardinality( n DPE(y) ) |
_:x rdf:type owl:Restriction _:x owl:maxCardinality NN_INT(n) _:x owl:onProperty y |
|
_:x rdf:type _:x owl:cardinality NN_INT(n) _:x owl:onProperty y { DPE(y) ≠ ε } |
ExactCardinality( n DPE(y) ) |
If G contains this pattern... | ...then DR(_:x) is set to this object property expression. |
---|---|
_:x _:x owl:oneOf T(SEQ lt1 ... ltn) |
OneOf( lt1 ... ltn ) |
_:x rdf:type _:x |
ComplementOf( rdfs:Literal ) |
If G contains this pattern... | ...then CE(_:x) is set to this class expression. |
---|---|
_:x _:x owl:unionOf T(SEQ) |
owl:Nothing |
_:x rdf:type owl:Class _:x owl:unionOf T(SEQ y) { |
|
_:x rdf:type _:x |
owl:Thing |
_:x _:x { CE(y) ≠ ε } |
CE(y) |
_:x rdf:type owl:Class _:x owl:oneOf T(SEQ) |
owl:Nothing |
The ontology O is then populated with axioms. The patterns from Table 16 are matched in G, the resulting axioms are added to O. Each time a pattern is matched, the matched triples are removed from G. The patterns for the EntityAnnotation and AnonymousIndividualAnnotation axioms can be matched to the empty set of triples so, in order to prevent infinite matches of the same pattern, these patterns are are matched to G at most once for each different URI reference *:x or blank node _:x.
If G contains this pattern... | ...then the following axiom is added to O. |
---|---|
*:x rdf:type owl:Class | Declaration( Class( *:x ) ) |
*:x rdf:type rdfs:Datatype | Declaration( Datatype( *:x ) ) |
*:x rdf:type owl:ObjectProperty | Declaration( ObjectProperty( *:x ) ) |
*:x rdf:type owl:DatatypeProperty | Declaration( DataProperty( *:x ) ) |
|
Declaration( AnnotationProperty( *:x ) ) |
*:x rdf:type owl:NamedIndividual | Declaration( NamedIndividual( *:x ) ) |
[ { ANN(*:x) ≠ ∅ or the optional triple is matched } |
ANN(*:x) [ ) |
ANN(*:x) ≠ ∅ or the optional triple is matched } |
EntityAnnotation( Datatype( *:x ) ANN(*:x) [ ) |
{ ANN(*:x) ≠ ∅ or the optional triple is matched } |
ANN(*:x) [ ) |
ANN(*:x) ≠ ∅ or the optional triple is matched } |
EntityAnnotation( DataProperty( *:x ) ANN(*:x) [ ) |
{ ANN(*:x) ≠ ∅ or the optional triple is matched } |
ANN(*:x) [ ) |
DPE(*:x) ≠ ε, AP(*:x) ≠ ε, and ANN(*:x) ≠ ∅ } |
) |
|
) |
|
|
|
|
{ CE(x) ≠ ε and CE(y) ≠ ε } |
DisjointClasses( CE(x) CE(y) ) |
_:x rdf:type _:x |
|
|
DisjointUnion( CE(x) CE(y1) |
x rdfs:subPropertyOf y |
|
_:x |
PropertyChain( OPE(x1) ... ) |
x owl:equivalentProperty y { |
EquivalentProperties( OPE(x) OPE(y) ) |
{ OPE(x) ≠ ε and OPE(y) ≠ ε } |
|
_:x rdf:type owl:AllDisjointProperties _:x owl:members T(SEQ y1 |
|
{ |
PropertyDomain( OPE(x) CE(y) ) |
{ OPE(x) ≠ ε and CE(y) ≠ ε } |
|
*:x owl:inverseOf y |
InverseProperties( OPE(*:x) OPE(y) ) |
{ OPE(x) ≠ ε } |
FunctionalProperty( OPE(x) ) |
x rdf:type owl:InverseFunctionalProperty { OPE(x) ≠ ε } |
InverseFunctionalProperty( OPE(x) ) |
x rdf:type owl:ReflexiveProperty { OPE(x) ≠ ε } |
ReflexiveProperty( OPE(x) ) |
x rdf:type owl:IrreflexiveProperty { OPE(x) ≠ ε } |
IrreflexiveProperty( OPE(x) ) |
x rdf:type owl:SymmetricProperty { OPE(x) ≠ ε } |
SymmetricProperty( OPE(x) ) |
x rdf:type owl:AsymmetricProperty { OPE(x) ≠ ε } |
AsymmetricProperty( OPE(x) ) |
x rdf:type owl:TransitiveProperty { OPE(x) ≠ ε } |
TransitiveProperty( OPE(x) ) |
x rdfs:subPropertyOf y |
SubPropertyOf( DPE(x) DPE(y) ) |
x owl:equivalentProperty y { DPE(x) ≠ ε and DPE(y) ≠ ε } |
EquivalentProperties( DPE(x) DPE(y) ) |
x owl:propertyDisjointWith y { DPE(x) ≠ ε and DPE(y) ≠ ε } |
DisjointProperties( DPE(x) DPE(y) ) |
_:x owl:members T(SEQ y1 { |
|
x |
PropertyDomain( DPE(x) CE(y) ) |
x |
PropertyRange( DPE(x) DR(y) ) |
x { DPE(x) ≠ ε } |
FunctionalProperty( DPE(x) ) |
x |
HasKey( CE(x) OPEorDPE(y1) ...
|
x |
SameIndividual( x y |
x |
DifferentIndividuals( x y |
_:x _:x |
|
_:x |
|
x { |
|
x { |
|
_:x owl:sourceIndividual w _:x owl:assertionProperty *:y _:x owl:targetIndividual z { OPE(*:y) ≠ ε } |
NegativePropertyAssertion( OPE(*:y) w z ) |
x { |
|
_:x owl:sourceIndividual w _:x owl:assertionProperty *:y _:x owl:targetValue lt { OPE(*:y) ≠ ε } |
NegativePropertyAssertion( DPE(*:y) w lt ) |
xFor clarity, Table 16 handles only axioms without annotations.
In case of the patterns for owl:AllDisjointClasses,
owl:AllDisjointProperties, owl:AllDifferent, and
owl:NegativePropertyAssertion, axiom annotations are defined
by ANN(_:x). For other axioms, axiom
annotations are obtained by additionally matching patterns from
Table 17 in G during axiom matching. Each time a triple
pattern is matched, the matched triples are removed from
G.
If G contains this pattern... | ...then the following axiom is added to O. |
---|---|
_:x rdf:type _:x owl:subject s _:x owl:predicate *:p _:x owl:object o { s *:p o is the main triple for an axiom and G contains possible necessary side triples for the axiom } |
The result is the axiom corresponding to s *:p o (and possible side triples) that additionally contains the annotations ANN(_:x). |
Finally, the patterns from Table 18 are matched in G, the
resulting axioms are added to O. These patterns are not
generated by the mapping from Section 2, but they can be present in RDF graphs that encode
OWL DL ontologies. (Note that the patterns from the table do not
contain triples of the form *:x rdf:type
owl:SymmetricProperty SymmetricObjectProperty( OP(x)owl:Class because such triples are removed while
parsing the entity declarations, as specified in Section
3.1.) Each time a triple pattern is matched, the matched
triples are removed from G.
If G contains this pattern... | ...then the following axiom is added to O. |
---|---|
*:x owl:complementOf y { CE(*:x) ≠ ε and CE(y) ≠ ε } |
EquivalentClasses( CE(*:x) ComplementOf( CE(y) ) |
{ CE(*:x) ≠ ε } |
EquivalentClasses( CE(*:x) owl:Nothing ) |
{ |
|
|
|
{ |
|
|
|
|
|
{ CE(*:x) ≠ ε } |
EquivalentClasses( CE(*:x) owl:Nothing ) |
{ CE(*:x) ≠ ε } |
EquivalentClasses( CE(*:x) OneOf( *:y1 ...
|
At the end of this process, if G contains some triple thatis not matched by any triple pattern (including the patterns used to define Type(x) ),empty then
G cannotMUST be translated into an OWL 2 ontology.rejected as syntactically incorrect.