OWL 1.1 Web Ontology Language
Mapping to RDF Graphs

W3C Member Submission 19 December 2006

This version:

http://www.w3.org/submissions/2006/SUBM-owl11-rdf_mapping-20061219/

Latest version:

http://www.w3.org/submissions/owl11-rdf_mapping/

Authors:

Bernardo Cuenca Grau, The University of Manchester

Boris Motik, The University of Manchester

Contributors:

Ian Horrocks, The University of Manchester

Bijan Parsia, The University of Manchester

Copyright © 2006 by the Submitters. This document is available under the W3C Document License. See the W3C Intellectual Rights Notice and Legal Disclaimers for additional information.

1 Introduction

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 y₁ ... y_n) denotes the encoding of an RDF list as shown in Table 1.

2 Translation from Functional-Style Syntax to RDF Graphs

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[op₁,...,op_n] expands to rdfs:subPropertyOf if OnlyOP(op_i) = true for each 1 ≤ i ≤ n, and to owl11:subObjectPropertyOf otherwise;
• SUBPROPERTYOF[dp₁,dp₂] expands to rdfs:subPropertyOf if OnlyDP(dp₁) = true and OnlyDP(dp₂) = true, and to owl11:subDataPropertyOf otherwise;
• EQUIVALENTPROPERTY[op₁,...,op_n] expands to owl:equivalentProperty if OnlyOP(op_i) = true for each 1 ≤ i ≤ n, and to owl11:equivalentObjectProperty otherwise;
• EQUIVALENTPROPERTY[dp₁,...,dp_n] 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 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(apID_i ct_i), 1 ≤ i ≤ n, then, instead of being serialized as s p o, the axiom is serialized as follows:

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

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

_:x T(apID_i) T(ct_i)   1 ≤ i ≤ n

3 Translation from RDF Graphs to Functional-Style Syntax

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.

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.

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

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

References

[OWL 1.1 Specification]

OWL 1.1 Web Ontology Language: Structural Specification and Functional-Style Syntax. Peter F. Patel-Schneider, Ian Horrocks, and Boris Motik, eds., 2006.

[OWL 1.1 Semantics]

OWL 1.1 Web Ontology Language: Model-Theoretic Semantics. Bernardo Cuenca Grau and Boris Motik, eds., 2006.

[RDF Semantics]

RDF Semantics. Patrick Hayes, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/.