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 711 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 providesdefines mappings by means of which every OWL 2
ontology in the functional-style syntax[OWL 2
Specification] can be mapped into an RDF triplesgraph and back withoutback.
These transformations do not incur any change in the formal meaning
of the ontology. More precisely, let O be any OWL 2
ontology in functional-style syntax,ontology, let T(O) be the set ofRDF triplesgraph obtained by transforming
O into RDF triplesas specified in Section 2, and let O' be the OWL 2 ontology in functional-style syntaxobtained
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 ismappings presented in this document are backwards-compatible
with that of OWL DL: every OWL DL ontology inencoded as an RDF syntaxgraph
can be mapped into a valid OWL 2 ontology using the
reverse-transformation from Section 3 such that the resulting OWL 2 ontology has exactly
the same set of models as the original OWL DL ontology.
The syntax for triples used in this document is the one used in the RDF Semantics [RDF Semantics]. Full URIs are abbreviated using the namespaces from the OWL 2 Specification [OWL 2 Specification]. OWL 2 ontologies mentioned in this document should be understood as instances of the structural specification of OWL 2 [OWL 2 Specification]; when required, these are written in this document using the functional-style syntax.
The following notation is used throughout this document for referring to parts of RDF graphs:
The italicized keywords MUST, MUST NOT, SHOULD, SHOULD NOT, and MAY specify certain aspects of the normative behavior of OWL 2 tools, and are interpreted as specified in RFC 2119 [RFC 2119].
This section defines a mapping of an OWL 2 ontology O
in functional-style syntaxinto a set ofan RDF triplesgraph T(O). The mapping is presented in three
parts. Section 2.1 shows how to translate axioms that do 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 operator T that maps an OWL 2
ontology O in functional-style syntaxinto a set ofan RDF triplesgraph T(O), provided that no
axiom in O is annotated. The mapping is defined recursively, i.e.,recursively;
that is, the mapping of a construct often depends on the mappings
of its sub-constructs,subconstructs, but in a slightly unusual way.way: if the mapping
of a construct refers to the mapping of a sub-construct,subconstruct, then the
triples generated by the recursive invocation of T are added
to the graph under construction, and its main node is used
in place of the invocation itself.
The definition of the operator T uses the operator TANN in order to translate annotations. The operator TANN is defined in Section 2.2. It takes an annotation and an URI reference or a blank node and produces the triples that attach the annotation to the supplied object.
In the mapping, each generated blank node (i.e., each blank node
that does not correspond to an anonymous individual) is fresh in
each application of a mapping rule. Furthermore, the following
conventions are used in this section to denote different syntacticparts of
OWL 2 ontologies:
In this section, T(SEQ y1 ...
yn) denotes the translation of a sequence of
objects from the functional-style syntaxstructural specification into an RDF list, as
shown in Table 1.
|
Triples Generated in an Invocation of |
Main Node of |
---|---|---|
SEQ | rdf:nil | |
SEQ y1 ... yn | _:x rdf:first T(y1) _:x rdf:rest T(SEQ y2 ... yn) |
_:x |
Ontology( ontologyURI [ versionURI ] Import( importedOntologyURI1 ) ... Import( importedOntologyURIk ) annotation1 ... annotationm axiom1 ... axiomn ) |
ontologyURI rdf:type owl:Ontology [ ontologyURI owl:versionInfo versionURI ] ontologyURI owl:imports importedOntologyURI1 ... ontologyURI owl:imports importedOntologyURIk TANN(annotation1 ... TANN(annotationm T(axiom1) ... T(axiomn) |
ontologyURI |
Ontology( Import( importedOntologyURI1 ) ... Import( importedOntologyURIk ) annotation1 ... annotationm axiom1 ... axiomn ) |
_:x rdf:type owl:Ontology _:x owl:imports importedOntologyURI1 ... _:x owl:imports importedOntologyURIk TANN(annotation1 ... TANN(annotationm T(axiom1) ... T(axiomn) |
_:x |
C | C | |
|
|
|
OP | OP | |
|
|
|
AP | AP | |
|
U | |
a | a | |
|
lt | |
Declaration( Datatype( DT ) ) | T(DT) rdf:type rdfs:Datatype | |
Declaration( Class( C ) ) | T(C) rdf:type owl:Class | |
Declaration( ObjectProperty( OP ) ) | T(OP) rdf:type owl:ObjectProperty | |
Declaration( DataProperty( DP ) ) | T(DP) rdf:type owl:DatatypeProperty | |
Declaration( AnnotationProperty( AP ) ) | T(AP) rdf:type owl:AnnotationProperty | |
Declaration( NamedIndividual( *:a ) ) | T(*:a) rdf:type owl:NamedIndividual | |
InverseOf( OP ) | _:x owl:inverseOf T(OP) | _:x |
IntersectionOf( DR1 ... DRn ) | _:x rdf:type rdfs:Datatype _:x owl:intersectionOf T(SEQ DR1 ... DRn) |
_:x |
UnionOf( DR1 ... DRn ) | _:x rdf:type rdfs:Datatype _:x owl:unionOf T(SEQ DR1 ... DRn) |
_:x |
ComplementOf( DR ) | _:x rdf:type rdfs:Datatype _:x owl:datatypeComplementOf T(DR) |
_:x |
OneOf( lt1 ... ltn ) | _:x rdf:type rdfs:Datatype _:x owl:oneOf T(SEQ lt1 ... ltn) |
_:x |
DatatypeRestriction( DT F1 lt1 ... Fn ltn ) |
_:x rdf:type rdfs:Datatype _:x owl:onDatatype T(DT) _:x owl:withRestrictions T(SEQ _:y1 ... _:yn) _:y1 F1 lt1 ... _:yn Fn ltn |
_:x |
IntersectionOf( CE1 ... CEn ) | _:x rdf:type owl:Class _:x owl:intersectionOf T(SEQ CE1 ... CEn) |
_:x |
UnionOf( CE1 ... CEn ) | _:x rdf:type owl:Class _:x owl:unionOf T(SEQ CE1 ... CEn) |
_:x |
ComplementOf( CE ) | _:x rdf:type owl:Class _:x owl:complementOf T(CE) |
_:x |
OneOf( a1 ... an ) | _:x rdf:type owl:Class _:x owl:oneOf T(SEQ a1 ... an) |
_:x |
SomeValuesFrom( OPE CE ) | _:x rdf:type owl:Restriction _:x owl:onProperty T(OPE) _:x owl:someValuesFrom T(CE) |
_:x |
AllValuesFrom( OPE CE ) | _:x rdf:type owl:Restriction _:x owl:onProperty T(OPE) _:x owl:allValuesFrom T(CE) |
_:x |
HasValue( OPE a ) | _:x rdf:type owl:Restriction _:x owl:onProperty T(OPE) _:x owl:hasValue T(a) |
_:x |
|
_:x rdf:type _:x owl:onProperty T(OPE) _:x owl:hasSelf "true"^^xsd:boolean |
_:x |
MinCardinality( n OPE ) | _:x rdf:type owl:Restriction _:x owl:minCardinality _:x owl:onProperty T(OPE) |
_:x |
MinCardinality( n OPE CE ) | _:x rdf:type owl:Restriction _:x owl:minQualifiedCardinality _:x owl:onProperty T(OPE) _:x owl:onClass T(CE) |
_:x |
MaxCardinality( n OPE ) | _:x rdf:type owl:Restriction _:x owl:maxCardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(OPE) |
_:x |
MaxCardinality( n OPE CE ) | _:x rdf:type owl:Restriction _:x owl:maxQualifiedCardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(OPE) _:x owl:onClass T(CE) |
_:x |
ExactCardinality( n OPE ) | _:x rdf:type owl:Restriction _:x owl:cardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(OPE) |
_:x |
ExactCardinality( n OPE CE ) | _:x rdf:type owl:Restriction _:x owl:qualifiedCardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(OPE) _:x owl:onClass T(CE) |
_:x |
SomeValuesFrom( DPE DR ) | _:x rdf:type owl:Restriction _:x owl:onProperty T(DPE) _:x owl:someValuesFrom T(DR) |
_:x |
SomeValuesFrom( DPE1 ... DPEn DR ), n ≥ 2 | _:x rdf:type owl:Restriction _:x owl:onProperties T(SEQ DPE1 ... DPEn) _:x owl:someValuesFrom T(DR) |
_:x |
AllValuesFrom( DPE DR ) | _:x rdf:type owl:Restriction _:x owl:onProperty T(DPE) _:x owl:allValuesFrom T(DR) |
_:x |
AllValuesFrom( DPE1 ... DPEn DR ), n ≥ 2 | _:x rdf:type owl:Restriction _:x owl:onProperties T(SEQ DPE1 ... DPEn) _:x owl:allValuesFrom T(DR) |
_:x |
HasValue( DPE lt ) | _:x rdf:type owl:Restriction _:x owl:onProperty T(DPE) _:x owl:hasValue T(lt) |
_:x |
MinCardinality( n DPE ) | _:x rdf:type owl:Restriction _:x owl:minCardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(DPE) |
_:x |
MinCardinality( n DPE DR ) | _:x rdf:type owl:Restriction _:x owl:minQualifiedCardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(DPE) _:x owl:onDataRange T(DR) |
_:x |
MaxCardinality( n DPE ) | _:x rdf:type owl:Restriction _:x owl:maxCardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(DPE) |
_:x |
MaxCardinality( n DPE DR ) | _:x rdf:type owl:Restriction _:x owl:maxQualifiedCardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(DPE) _:x owl:onDataRange T(DR) |
_:x |
ExactCardinality( n DPE ) | _:x rdf:type owl:Restriction _:x owl:cardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(DPE) |
_:x |
ExactCardinality( n DPE DR ) | _:x rdf:type owl:Restriction _:x owl:qualifiedCardinality "n"^^xsd:nonNegativeInteger _:x owl:onProperty T(DPE) _:x owl:onDataRange T(DR) |
_:x |
SubClassOf( CE1 CE2 ) | T(CE1) rdfs:subClassOf T(CE2) | |
EquivalentClasses( CE1 ... CEn ) | T(CE1) owl:equivalentClass
T(CE2) ... T(CEn-1) owl:equivalentClass T(CEn) |
|
DisjointClasses( CE1 CE2 ) | T(CE1) owl:disjointWith T(CE2) | |
DisjointClasses( CE1 ... CEn ), n > 2 | _:x rdf:type owl:AllDisjointClasses _:x owl:members T(SEQ CE1 ... CEn) |
|
DisjointUnion( C CE1 ... CEn ) | T(C) owl:disjointUnionOf T(SEQ CE1 ... CEn) | |
SubPropertyOf( OPE1 OPE2 ) | T(OPE1) rdfs:subPropertyOf T(OPE2) | |
SubPropertyOf( PropertyChain( OPE1 ... OPEn ) OPE ) | _:x rdfs:subPropertyOf T(OPE) _:x owl:propertyChain T(SEQ OPE1 ... OPEn) |
|
EquivalentProperties( OPE1 ... OPEn ) | T(OPE1) owl:equivalentProperty
T(OPE2) ... T(OPEn-1) owl:equivalentProperty T(OPEn) |
|
DisjointProperties( OPE1 OPE2 ) | T(op1) owl:propertyDisjointWith T(op2) | |
DisjointProperties( OPE1 ... OPEn ), n > 2 | _:x rdf:type owl:AllDisjointProperties _:x owl:members T(SEQ OPE1 ... OPEn) |
|
PropertyDomain( OPE CE ) | T(OPE) rdfs:domain T(CE) | |
PropertyRange( OPE CE ) | T(OPE) rdfs:range T(CE) | |
InverseProperties( OPE1 OPE2 ) | T(OPE1) owl:inverseOf T(OPE2) | |
FunctionalProperty( OPE ) | T(OPE) rdf:type owl:FunctionalProperty | |
InverseFunctionalProperty( OPE ) | T(OPE) rdf:type owl:InverseFunctionalProperty | |
ReflexiveProperty( OPE ) | T(OPE) rdf:type owl:ReflexiveProperty | |
IrreflexiveProperty( OPE ) | T(OPE) rdf:type owl:IrreflexiveProperty | |
SymmetricProperty( OPE ) | T(OPE) rdf:type owl:SymmetricProperty | |
AsymmetricProperty( OPE ) | T(OPE) rdf:type owl:AsymmetricProperty | |
TransitiveProperty( OPE ) | T(OPE) rdf:type owl:TransitiveProperty | |
SubPropertyOf( DPE1 DPE2 ) | T(DPE1) rdfs:subPropertyOf T(DPE2) | |
EquivalentProperties( DPE1 ... DPEn ) | T(DPE1) owl:equivalentProperty
T(DPE2) ... T(DPEn-1) owl:equivalentProperty T(DPEn) |
|
DisjointProperties( DPE1 DPE2 ) | T(DPE1) owl:propertyDisjointWith T(DPE2) | |
DisjointProperties( DPE1 ... DPEn ), n > 2 | _:x rdf:type owl:AllDisjointProperties _:x owl:members T(SEQ DPE1 ... DPEn) |
|
PropertyDomain( DPE CE ) | 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 T(a2) | |
DifferentIndividuals( a1 ... an ), n > 2 | _:x rdf:type owl:AllDifferent _:x owl:members T(SEQ a1 ... an) |
|
ClassAssertion( CE a ) | T(a) rdf:type T(CE) | |
PropertyAssertion( OP a1 a2 ) | T(a1) T(OP) T(a2) | |
PropertyAssertion( InverseOf( OP ) a1 a2 ) | T(a2) T(OP) T(a1) | |
NegativePropertyAssertion( OPE a1 a2 ) | _:x rdf:type owl:NegativePropertyAssertion _:x owl:sourceIndividual T(a1) _:x owl:assertionProperty T(OPE) _:x owl:targetIndividual T(a2) |
|
PropertyAssertion( DPE a lt ) | T(a) T(DPE) T(lt) | |
NegativePropertyAssertion( DPE a lt ) | _:x rdf:type owl:NegativePropertyAssertion _:x owl:sourceIndividual T(a) _:x owl:assertionProperty T(DPE) _:x owl:targetValue T(lt) |
|
|
|
|
SubPropertyOf( AP1 |
|
|
|
|
|
PropertyRange( AP U ) | |
The operator TANN, which translates annotations and attaches them to an URI reference or a blank node, is defined in Table 2.
Annotation ann | Triples Generated in an Invocation of |
---|---|
Annotation( AP |
|
Annotation( annotation1 ... annotationn AP ) |
T(y) T(AP) T(av) _:x rdf:type owl:Annotation _:x owl:subject _:x owl:predicate T(AP) _:x owl:object TANN(annotation1 ... TANN(annotationn |
Consider the following entity annotation, whichaxiom that associates the URI
a:Peter with a simple label.
EntityAnnotation( NamedIndividual(AnnotationAssertion( rdfs:label a:Peter ) Label("Peter
Griffin" )
)This axiom is translated into the following triple:
a:Peter rdfs:label "Peter
Griffin"^^xsd:stringGriffin"^^xsd:string
Consider the following axioms, whichaxiom that associates a:Peter with
an annotation containing a nested annotation.
EntityAnnotation( NamedIndividual(AnnotationAssertion( a:Peter
) Annotation(
Annotation( a:author
a:Seth_MacFarlane )
rdfs:label "Peter
Griffin"
)
)
This axiom is translated into the following triples:
a:Peter rdfs:label "Peter
Griffin"^^xsd:string
_:x rdf:type owl:Annotation
_:x owl:subject a:Peter
_:x owl:predicate rdfs:label
_:x owl:object "Peter Griffin"^^xsd:stringGriffin"^^xsd:string
_:x a:auhtor a:Seth_MacFarlane
If an axiom ax contains embedded annotations annotation1 ... 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 axiom annotations.
Editor's Note: OWL WG Issue 144 is related to this part of the mapping.If ax' is translated into a single RDF triple
s p o, then the axiom ax generatesis
translated into the following triples instead of tripletriples:
s p o
:_:x rdf:type owl:Axiom
_:x owl:subject s
_:x owl:predicate p
_:x owl:object o
TANN(annotation1 ,_:x), _:x)
...
TANN(annotationm ,_:x), _:x)
This is the case for the following axioms: SubClassOf, DisjointClasses with two classes, SubPropertyOf without a property chain as the
subproperty expression, PropertyDomain, PropertyRange, InverseProperties, FunctionalProperty, InverseFunctionalProperty, ReflexiveProperty, IrreflexiveProperty, SymmetricProperty, AsymmetricProperty, TransitiveProperty, DisjointProperties with two properties,
ClassAssertion, PropertyAssertion, Declaration, andDifferentIndividuals with two individuals.individuals, and
AnnotationAssertion.
Consider the following subclass axiom:
SubClassOf( Comment(Annotation( rdfs: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:
a:Child rdfs:subClassOf a:Person
_: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." Axiomspeople."^^xsd:string
DisjointUnion, SubPropertyOf with a subproperty chain, and HasKey axioms 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(Annotation( rdfs: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. The original triple is output alongside all other triples as well.
_: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."sister."^^xsd:string
_: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
Consider the following key axiom:
HasKey( Comment(Annotation( rdfs: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."person."^^xsd:string
a:Person owl:hasKey _:y
_:y rdf:first a:hasSSN
_:y rdf:rest rdf:nil
Editor's Note: OWL WG Issue 144 is related to this part of the mapping.If the axiom ax' is of type EquivalentClasses, EquivalentProperties, or SameIndividual, or EntityAnnotationits 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:
a:Meg owl:sameAs a:Megan
_: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
a:Megan owl:sameAs a:Megan_Griffin
_: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,
DisjointUnionDisjointObjectProperties or
DisjointDataProperties 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
An RDF syntax ontology document is a sequence of octets
accessible from some URI by means of the standard protocols that
can be parsed into an RDF graph G; thus, the graph G
is often identified with an ontology document. This section specifiesdefines
the canonical RDF parsing — aprocess that transforms a set of RDF triplescan be used to
transform G into an OWL 2 ontology O in functional-style syntax,, if possible.
This parsing process is specified as an instance of canonical
parsing, defined in Section 5.9.35.8.3 of the OWL 2 Specification
[OWL 2
Specification]. If any of these steps cannot be
completed for some reason, the graph G MUST be rejected as
syntactically invalid. 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 fragmentan object of the functional-style syntax.structural
specification. 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.invalid.
Firthermore,Furthermore, if there is an attempt to redefine the value
of any of these functions for any x
(i.e., if a function is not undefined for x and there is an attempt to change the function's
value for x), then G MUST be rejected as
syntactically incorrect.invalid.
The function OPEorDPE is defined as follows:
The following sections contain rules in which triple patterns
are matched to G. The followingnotation is used to denote parts of the patterns that are matched to literals with integer value: POS_INT(n) is matched to any literal whose value is a positive integer;NN_INT(n) iscan be matched to any literal whose value
n is a nonnegative integer.
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 similar to the mapping for lists presented in Table 1, but here the abbreviation is used to recognize lists instead of mapping them into RDF.
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 |
For backwards compatibility with OWL DL, if G contains an
owl:imports triple pointing to an RDF graph G' and
G' does not have an ontology header, this owl:imports
triple whose predicateis rdf:typeinterpreted as an include rather than an import —
that is, the triples of G' are included into G and
objectare not parsed into a separate ontology. To achieve this, the graph
G is first subjected to the following transformation.
If G contains a pair of triples of the form
x rdf:type owl:Ontology
x owl:imports *:y
the following actions are performed:
Next, the ontology header is Ontology( ... )extracted from G. Otherwise,To this
end, the 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.invalid. 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 ... *:x owl:imports { 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( ... Import( ... ) |
_:x rdf:type owl:Ontology _:x owl:imports ... _:x owl:imports { The following triple pattern cannot be matched in G: u w _:x u rdf:type owl:Ontology w rdf:type owl:OntologyProperty } |
Ontology( Import( ... Import( ... ) |
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: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 owl:Class |
x rdf:type owl:ObjectProperty 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 owl:AnnotationProperty |
*:x rdf:type owl:InverseFunctionalProperty | *:x rdf:type owl:ObjectProperty *:x rdf:type owl:InverseFunctionalProperty |
*:x rdf:type owl:TransitiveProperty | *:x rdf:type owl:ObjectProperty *:x rdf:type owl:TransitiveProperty |
*:x rdf:type owl:SymmetricProperty | *:x rdf:type owl:ObjectProperty *:x rdf:type owl:SymmetricProperty |
Finally,Next, the set of declarations Decl(O)Decl(G) 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.43.6.
If G contains this pattern... | ...then this declaration is added to |
---|---|
*: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 ) ) |
*: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 owl:object owl:DatatypeProperty |
Declaration( DataProperty( *:y ) ) |
_:x rdf:type owl:Axiom _:x owl:subject *:y _:x owl:predicate rdf:type _:x owl:object owl:AnnotationProperty |
Declaration( AnnotationProperty( *:y ) ) |
_:x rdf:type owl:Axiom _:x owl:subject *:y _:x owl:predicate rdf:type _:x owl:object owl:NamedIndividual |
Declaration( NamedIndividual( *:y ) ) |
3.2 Parsing the Imported Ontologies Next, for each ontology O' imported into O , the ontology header and declarations are determined. IfFinally, the ontology O' is writtenset RIND of anonymous
individuals used in RDF thenreification is identified. This is done as above. Ifby
initially setting RIND = ∅ and then
applying the ontology O' is writtenpatterns shown in some other format thenTable 8. The ontology header and declarationsmatched triples are not
deleted from G.
If G contains this pattern, then :_x is added to RIND. |
---|
_:x rdf:type owl:Axiom |
_:x rdf:type owl:Annotation |
_:x rdf:type owl:AllDisjointClasses |
_:x rdf:type owl:AllDisjointProperties |
_:x rdf:type owl:AllDifferent |
_:x rdf:type owl:NegativePropertyAssertion |
Next, for each ontology URI U imported into G, the
document of the ontology identified by U is accessed as
specified in Section 3.2.2 of the OWL 2 Specification
[OWL 2
Specification]. The ontology header and the declarations
of that document are determined according to the rules appropriate toof the
ontology format. 3.3syntax in which the document was written, and the process is
repeated recursively until the header and the declarations of all
ontologies in the import closure of G are determined.
The set AllDecl(O)AllDecl(G) of all declarations is computed by
taking the union of the set Decl(O)Decl(G), the sets
Decl(O')Decl(D') for each ontology O'document D' imported
(directly or indirectly) into OG, and the declarations for
built-in entities from Table 109 of the OWL 2 Specification
[OWL 2
Specification]. If the set AllDecl(G) violates
the declarations in AllDecl(O) are checked fortyping constraints, as specified inconstraints from Section 5.9.15.8.1 of the OWL 2
Specification [OWL 2 Specification ]. If the constraints are not satisfied, the graph], then G MUST be rejected as
syntactically incorrect.invalid.
Next, the functions CE, DR, OPE, DPE, and AP are initialized
as shown in Table 8.9.
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 |
Editor's Note: OWL WG Issue 144 is related to this part of the reverse mapping.The annotations in 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 initialized by setting ANN(x) = ∅ for each each URI reference or a blank
node x. Next, the triple patterspatterns from
the headers of Tables 9 andTable 10 are matched in G .and, for each matched pattern,
ANN(x) is extended with all annotationsan annotation
from the right columns of the tables matching the respective conditions in the left columns.column. Each time one of these triple patterns is
matched, the matched triples are removed from G. This
process is repeated until no further matches are possible.
|
...then this annotation is added to ANN(x). |
---|---|
x *:y z { AP(*:y) ≠ ε, z is a URI reference or a blank node, and _:w rdf:type owl:Annotation _:w owl:subject x _:w owl:predicate *:y _:w owl:object z } |
Annotation( *:y |
_:w owl:subject x _:w owl:predicate *:y _:w owl:object z z is a URI reference or a blank node, and no other triple in G |
Annotation( ANN(_:w) *:y z ) |
An ontology O is created with the header as determined in
Section 3.2. Let x be the node
that iswas matched in G to *:x or
_:x while parsing the ontology header of Oaccording to the patterns from Table
4.4; then, ANN(x) determines the set of
ontology annotations of O.
Next, thefunctions OPE, DR, and CE are extended as
shown in Tables 11, 12, and 13, as well as in Tables 14 and 15. The
patterns in the latter two tables are not generated by the mapping
from Section 2, but they can be present in RDF graphs that encode
OWL DL 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.
If G contains this pattern... | ...then OPE(_:x) is set to this object property expression. |
---|---|
_:x owl:inverseOf *:y { OPE(_:x) = ε and OPE(*:y) ≠ ε } |
InverseOf( OPE(*:y) ) |
If G contains this pattern... | ...then DR(_:x) is set to this data range. |
---|---|
_:x rdf:type rdfs:Datatype _:x owl:intersectionOf T(SEQ y1 ... yn) { n ≥ 2 and DR(yi) ≠ ε for each 1 ≤ i ≤ n } |
IntersectionOf( DR(y1) ... DR(yn) ) |
_:x rdf:type rdfs:Datatype _:x owl:unionOf T(SEQ y1 ... yn) { n ≥ 2 and DR(yi) ≠ ε for each 1 ≤ i ≤ n } |
UnionOf( DR(y1) ... DR(yn) ) |
_:x rdf:type rdfs:Datatype _:x owl:datatypeComplementOf y { DR(y) ≠ ε } |
ComplementOf( DR(y) ) |
_:x rdf:type rdfs:Datatype _:x owl:oneOf T(SEQ lt1 ... ltn) { n ≥ 1 } |
OneOf( lt1 ... ltn ) |
_:x rdf:type rdfs:Datatype _:x owl:onDatatype *:y _:x owl:withRestrictions T(SEQ _:z1 ... _:zn) _:z1 ... _:zn { DR(*:y) is a datatype } |
DatatypeRestriction( DR(*:y) ... ) |
If G contains this pattern... | ...then CE(_:x) is set to this class expression. |
---|---|
_:x rdf:type owl:Class _:x { n ≥ 2 and CE(yi) ≠ ε for each 1 ≤ i ≤ n } |
|
_:x rdf:type owl:Class _:x { n ≥ 2 and CE(yi) ≠ ε for each 1 ≤ i ≤ n } |
|
_:x rdf:type owl:Class _:x owl:complementOf y { CE(y) ≠ ε } |
ComplementOf( CE(y) ) |
_:x rdf:type owl:Class _:x owl:oneOf T(SEQ *:y1 ... *:yn) { n ≥ 1 } |
OneOf( *:y1 ... *:yn ) |
_:x rdf:type _:x owl:onProperty y _:x owl:someValuesFrom z { OPE(y) ≠ ε and CE(z) ≠ ε } |
|
_:x rdf:type owl:Restriction _:x owl:onProperty y _:x { OPE(y) ≠ ε and CE(z) ≠ ε } |
|
_:x rdf:type owl:Restriction _:x owl:onProperty y _:x { OPE(y) ≠ ε |
|
_:x rdf:type owl:Restriction _:x owl:onProperty y _:x { OPE(y) ≠ ε |
|
_: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 OPE(y) CE(z) ) |
_: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 rdf:type owl:Restriction _:x owl:qualifiedCardinality NN_INT(n) _:x owl:onProperty y _:x owl:onClass z { 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 rdf:type owl:Restriction _:x owl:maxCardinality NN_INT(n) _:x owl:onProperty y { OPE(y) ≠ ε } |
MaxCardinality( n OPE(y) ) |
_:x rdf:type owl:Restriction _: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 owl:Restriction _:x owl:onProperty y _: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) _:x owl:someValuesFrom z { DPE(yi) ≠ ε for each 1 ≤ i ≤ n and DR(z) ≠ ε } |
SomeValuesFrom( DPE(y1) ... DPE(yn) DR(z) ) |
_:x rdf:type owl:Restriction _:x owl:onProperty y _:x owl:allValuesFrom z { DPE(y) ≠ ε and DR(z) ≠ ε } |
AllValuesFrom( DPE(y) DR(z) ) |
_:x rdf:type owl:Restriction _:x owl:onProperties T(SEQ y1 ... yn) _:x owl:allValuesFrom z { DPE(yi) ≠ ε for each 1 ≤ i ≤ n and DR(z) ≠ ε } |
AllValuesFrom( DPE(y1) ... DPE(yn) DR(z) ) |
_:x rdf:type owl:Restriction _:x owl:minQualifiedCardinality NN_INT(n) _:x owl:onProperty y _:x owl:onDataRange z { DPE(y) ≠ ε and DR(z) ≠ ε } |
MinCardinality( n DPE(y) DR(z) ) |
_:x rdf:type owl:Restriction _:x owl:maxQualifiedCardinality NN_INT(n) _:x owl:onProperty y _:x owl:onDataRange z { 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 owl:onDataRange z { DPE(y) ≠ ε and DR(z) ≠ ε } |
ExactCardinality( n DPE(y) DR(z) ) |
_:x rdf:type owl:Restriction _:x owl:minCardinality NN_INT(n) _:x owl:onProperty y { DPE(y) ≠ ε } |
MinCardinality( n DPE(y) ) |
_:x rdf:type owl:Restriction _:x owl:maxCardinality NN_INT(n) _:x owl:onProperty y { DPE(y) ≠ ε } |
MaxCardinality( n DPE(y) ) |
_:x rdf:type owl:Restriction _: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 rdf:type owl:DataRange _:x owl:oneOf T(SEQ lt1 ... ltn) { n ≥ 1 } |
OneOf( lt1 ... ltn ) |
_:x rdf:type owl:DataRange _:x owl:oneOf T(SEQ) |
ComplementOf( rdfs:Literal ) |
If G contains this pattern... | ...then CE(_:x) is set to this class expression. |
---|---|
_:x rdf:type owl:Class _:x owl:unionOf T(SEQ) |
owl:Nothing |
_:x rdf:type owl:Class _:x owl:unionOf T(SEQ y) { CE(y) ≠ ε } |
CE(y) |
_:x rdf:type owl:Class _:x owl:intersectionOf T(SEQ) |
owl:Thing |
_:x rdf:type owl:Class _:x owl:intersectionOf T(SEQ y) { CE(y) ≠ ε } |
CE(y) |
_:x rdf:type owl:Class _:x owl:oneOf T(SEQ) |
owl:Nothing |
The ontology O is then populated with axioms. For clarity, the axiom patterns are split into two tables.
The axioms in G are parsed as follows:
In either case, 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 owl:Class | Declaration( Class( *:x ) ) |
*:x rdf:type rdfs:Datatype | Declaration( Datatype( *:x ) ) |
*:x rdf:type owl:ObjectProperty | Declaration( ObjectProperty( *:x ) ) |
*:x rdf:type |
Declaration( DataProperty( *:x ) |
|
Declaration( AnnotationProperty( *:x ) |
|
Declaration( NamedIndividual( *:x ) ) |
x rdfs:subClassOf y { CE(x) ≠ ε and CE(y) ≠ ε } |
SubClassOf( CE(x) CE(y) ) |
x owl:equivalentClass y { CE(x) ≠ ε and CE(y) ≠ ε } |
EquivalentClasses( CE(x) CE(y) ) |
x owl:disjointWith y { CE(x) ≠ ε and CE(y) ≠ ε } |
DisjointClasses( CE(x) CE(y) ) |
_:x rdf:type owl:AllDisjointClasses _:x owl:members T(SEQ y1 ... yn) { n ≥ 2 and CE(yi) ≠ ε for each 1 ≤ i ≤ n } |
DisjointClasses( CE(y1) ... CE(yn) ) |
x owl:disjointUnionOf T(SEQ y1 ...
yn) { n ≥ 2, CE(x) ≠ ε, and CE(yi) ≠ ε for each 1 ≤ i ≤ n } |
DisjointUnion( CE(x) CE(y1) ... CE(yn) ) |
x rdfs:subPropertyOf y { OPE(x) ≠ ε and OPE(y) ≠ ε } |
SubPropertyOf( OPE(x) OPE(y) ) |
_:x rdfs:subPropertyOf y _:x owl:propertyChain T(SEQ x1 ... xn) { n ≥ 2, OPE(xi) ≠ ε for each 1 ≤ i ≤ n, and OPE(y) ≠ ε } |
SubPropertyOf( PropertyChain( OPE(x1) ... OPE(xn) ) OPE(y) ) |
x owl:equivalentProperty y { OPE(x) ≠ ε and OPE(y) ≠ ε } |
EquivalentProperties( OPE(x) OPE(y) ) |
x owl:propertyDisjointWith y { OPE(x) ≠ ε and OPE(y) ≠ ε } |
DisjointProperties( OPE(x) OPE(y) ) |
_:x rdf:type owl:AllDisjointProperties _:x owl:members T(SEQ y1 ... yn) { n ≥ 2 and OPE(yi) ≠ ε for each 1 ≤ i ≤ n } |
DisjointProperties( OPE(y1) ... OPE(yn) ) |
x rdfs:domain y { OPE(x) ≠ ε and CE(y) ≠ ε } |
PropertyDomain( OPE(x) CE(y) ) |
x rdfs:range y { OPE(x) ≠ ε and CE(y) ≠ ε } |
PropertyRange( OPE(x) CE(y) ) |
x owl:inverseOf y { OPE(x) ≠ ε and OPE(y) ≠ ε } |
InverseProperties( OPE(x) OPE(y) ) |
x rdf:type owl:FunctionalProperty { 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 { DPE(x) ≠ ε and DPE(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 rdf:type owl:AllDisjointProperties _:x owl:members T(SEQ y1 ... yn) { n ≥ 2 and DPE(yi) ≠ ε for each 1 ≤ i ≤ n } |
DisjointProperties( DPE(y1) ... DPE(yn) ) |
x rdfs:domain y { DPE(x) ≠ ε and CE(y) ≠ ε } |
PropertyDomain( DPE(x) CE(y) ) |
x rdfs:range y { DPE(x) ≠ ε and DR(y) ≠ ε } |
PropertyRange( DPE(x) DR(y) ) |
x rdf:type owl:FunctionalProperty { DPE(x) ≠ ε } |
FunctionalProperty( DPE(x) ) |
x owl:hasKey T(SEQ y1 ...
yn) { n ≥ 1, CE(x) ≠ ε, and OPEorDPE(yi) ≠ ε for each 1 ≤ i ≤ n } |
HasKey( CE(x) OPEorDPE(y1) ... OPEorDPE(yn) ) |
x owl:sameAs y | SameIndividual( x y ) |
x owl:differentFrom y | DifferentIndividuals( x y ) |
_:x rdf:type owl:AllDifferent _:x owl:members T(SEQ x1 ... xn) { n ≥ 2 } |
DifferentIndividuals( x1 ... xn ) |
_:x rdf:type owl:AllDifferent _:x owl:distinctMembers T(SEQ x1 ... xn) { n ≥ 2 } |
DifferentIndividuals( x1 ... xn ) |
x rdf:type y { CE(y) ≠ ε } |
ClassAssertion( x CE(y) ) |
x *:y z { OPE(*:y) ≠ ε } |
PropertyAssertion( OPE(*:y) x z ) |
_:x rdf:type owl:NegativePropertyAssertion _:x owl:sourceIndividual w _:x owl:assertionProperty y _:x owl:targetIndividual z { OPE(y) ≠ ε } |
NegativePropertyAssertion( OPE(y) w z ) |
x *:y lt { DPE(*:y) ≠ ε } |
PropertyAssertion( DPE(*:y) x lt ) |
_:x rdf:type owl:NegativePropertyAssertion _:x owl:sourceIndividual w _:x owl:assertionProperty y _:x owl:targetValue lt { DPE(y) ≠ ε } |
NegativePropertyAssertion( DPE(y) w lt ) |
|
AnnotationAssertion( owl:deprecated *:x "true"^^xsd:boolean ) |
*:x rdf:type owl:DeprecatedProperty | AnnotationAssertion( owl:deprecated *:x "true"^^xsd:boolean ) |
*:x rdfs:subPropertyOf *:y { AP(*:x) ≠ ε and |
SubPropertyOf( AP(*:x) AP(*:y) ) |
*:x rdfs:domain *:y { AP(*:x) ≠ ε } |
PropertyDomain( AP(*:x) *:y ) |
*:x rdfs:range *:y { AP(*:x) ≠ ε } |
PropertyRange( AP(*:x) *:y ) |
If G contains this pattern... | ...then the following axiom is added to O. |
---|---|
s *:p o _:x rdf:type owl:Axiom _:x owl:subject s _:x owl:predicate *:p _:x owl:object o { s *:p o is the main triple for an axiom according to Table 17 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). |
Next, for each blank node or URI reference x such that x ∉ RIND, and for each annotation Annotation( annotation1 ... annotationn AP y ) ∈ ANN(x) with n possibly being equal to zero, the following annotation assertion is added to O:
AnnotationAssertion( annotation1 ... annotationn AP x y )
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:Class because such triples are removed while
parsing the entity declarations, as specified in Section
3.13.2.) 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) ) ) |
*:x owl:unionOf T(SEQ) { CE(*:x) ≠ ε } |
EquivalentClasses( CE(*:x) owl:Nothing ) |
*:x owl:unionOf T(SEQ y1) { CE(*:x) ≠ ε and CE(y1) ≠ ε } |
EquivalentClasses( CE(*:x) CE(y) ) |
*:x owl:unionOf T(SEQ y1 ...
yn) { n ≥ 2, CE(*:x) ≠ ε, and CE(yi) ≠ ε for each 1 ≤ i ≤ n } |
EquivalentClasses( CE(*:x) UnionOf( CE(y1) ... CE(yn) ) ) |
*:x owl:intersectionOf T(SEQ) { CE(*:x) ≠ ε } |
EquivalentClasses( CE(*:x) owl:Thing ) |
*:x owl:intersectionOf T(SEQ y1) { CE(*:x) ≠ ε and CE(y1) ≠ ε } |
EquivalentClasses( CE(*:x) CE(y) ) |
*:x owl:intersectionOf T(SEQ y1 ...
yn) { n ≥ 2, CE(*:x) ≠ ε, and CE(yi) ≠ ε for each 1 ≤ i ≤ n } |
EquivalentClasses( CE(*:x) IntersectionOf( CE(y1) ... CE(yn) ) ) |
*:x owl:oneOf T(SEQ) { CE(*:x) ≠ ε } |
EquivalentClasses( CE(*:x) owl:Nothing ) |
*:x owl:oneOf T(SEQ *:y1 ...
*:yn) { CE(*:x) ≠ ε } |
EquivalentClasses( CE(*:x) OneOf( *:y1 ... *:yn ) ) |
At the end of this process, if G is not empty then
G MUST be rejected as syntactically incorrect.invalid.
All ontology documents directly imported into G are parsed according to the rules of the syntax they are written in. The resulting ontologies are identified as being directly imported into O.