OWL 1.1 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 1.1
to the RDF exchange syntax for OWL 1.1,
and vice versa.

Status of this document

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 can be found in
the W3C technical reports index
at http://www.w3.org/TR/.

By publishing this document, W3C acknowledges that the Submitting
Members have made a formal Submission request to W3C for discussion.
Publication of this document by W3C indicates no endorsement of its content by
W3C, nor that W3C has, is, or will be allocating any resources to the issues
addressed by it. This document is not the product of a chartered W3C group, but
is published as potential input to the W3C Process. A W3C Team
Comment has been published in conjunction with this Member Submission.
Publication of acknowledged Member Submissions at the W3C site is one of the
benefits of W3C Membership. Please consult the requirements associated with
Member Submissions of section 3.3 of the W3C Patent Policy. Please consult the complete
list of acknowledged W3C
Member Submissions.

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

The following notation is used throughout this document:

_:x denotes a blank node;

x denotes a blank or a named node;

!x denotes a named node; and

T(SEQ y1 ... yn) denotes the encoding
of an RDF list as shown in Table 1.

As explained in [OWL 1.1 Specification],
OWL 1.1 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 1.1 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

if the parse tree of O contains S under a
objectPropertyURI node, then owl:ObjectProperty ∈ Type(S,O);

if the parse tree of O contains S under a
dataPropertyURI node, then owl:DatatypeProperty ∈ Type(S,O);

if the parse tree of O contains S under a
annotationURI node, then owl:AnnotationProperty ∈ Type(S,O);

if the parse tree of O contains S under a
owlClassURI node, then owl:Class ∈ Type(S,O);

if the parse tree of O contains S under a
datatypeURI node, then owl:Datatype ∈ Type(S,O); and

if the parse tree of O contains S under a
individualURI node, then owl11:Individual ∈ Type(S,O).

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:

OnlyOP(S) is true if and only if owl:ObjectProperty ∈ Type(S,O)
and owl:DatatypeProperty and owl:AnnotationProperty are not in Type(S,O);

OnlyDP(S) is true if and only if owl:DatatypeProperty ∈ Type(S,O)
and owl:ObjectProperty and owl:AnnotationProperty are not in Type(S,O);

OnlyAP(S) is true if and only if owl:AnnotationProperty ∈ Type(S,O)
and owl:ObjectProperty and owl:DatatypeProperty are not in Type(S,O).

The following shortcuts are used in the translation of OWL 1.1 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[op1,...,opn] expands to rdfs:subPropertyOf if
OnlyOP(opi) = true for each 1 ≤ i ≤ n, and to owl11:subObjectPropertyOf otherwise;

SUBPROPERTYOF[dp1,dp2] expands to rdfs:subPropertyOf if
OnlyDP(dp1) = true and OnlyDP(dp2) = true,
and to owl11:subDataPropertyOf otherwise;

EQUIVALENTPROPERTY[op1,...,opn] expands to owl:equivalentProperty if
OnlyOP(opi) = true for each 1 ≤ i ≤ n, and to owl11:equivalentObjectProperty otherwise;

EQUIVALENTPROPERTY[dp1,...,dpn] expands to owl:equivalentProperty if
OnlyDP(dpi) = 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 presents the operator T that translates an OWL 1.1 ontology
in functional-style syntax into a set of RDF triples. This table does not consider axioms with annotations.

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:

This section specifies how to translate a set of RDF triples G into an
OWL 1.1 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 owl:Datatype

owl:DataRange

x rdf:type owl:ObjectProperty

owl:ObjectProperty

x rdf:type owl:TransitiveProperty

owl:ObjectProperty

x rdf:type owl11:SymmetricProperty

owl:ObjectProperty

x rdf:type owl11:AntisymmetricProperty

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 owl: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:

OnlyOP(x) is true if and only if owl:ObjectProperty ∈ Type(x)
and owl:DatatypeProperty and owl:AnnotationProperty are not in Type(x);

OnlyDP(x) is true if and only if owl:DatatypeProperty ∈ Type(x)
and owl:ObjectProperty and owl:AnnotationProperty are not in Type(x);

OnlyAP(x) is true if and only if owl:AnnotationProperty ∈ Type(x)
and owl:ObjectProperty and owl:DatatypeProperty are not in Type(x).

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

OP(x) assigns to x an object property expression;

DP(x) assigns to x a data property expression;

DRANGE(x) assigns to x a data range; and

DESC(x) assigns to x a description.

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 1.1 ontology.

If x is not a blank node, then set OP(x),
DP(x), DRANGE(x), and DESC(x)
to x.

For each triple pattern from the first column of Table 4 occurring in G,
set OP(x) to the object property expression from the second column.

For each triple pattern from the first column of Table 5 occurring in G,
set DRANGE(x) to the data range from the second column.

For each tiple pattern from the first column of Table 6 occurring G,
set DESC(x) to the description from the second column.

If there is more than one way of assigning a value to any one of these functions,
then G cannot be translated into an OWL 1.1 ontology. Also,
if the value of one of these functions is not defined for some node occurring in
the functional-style syntax encoding, then G cannot be translated into an OWL 1.1 ontology.