OWL 2 Web Ontology Language:
Mapping to RDF Graphs

W3C Working Draft 08 October 2008

This version:

http://www.w3.org/TR/2008/WD-owl2-mapping-to-rdf-20081008/

Latest version:

http://www.w3.org/TR/owl2-mapping-to-rdf/

Previous version:

http://www.w3.org/TR/2008/WD-owl2-mapping-to-rdf-20080411/

Editors:

Peter F. Patel-Schneider, Bell Labs Research, Alcatel-Lucent

Boris Motik, Oxford University

Contributors:

Bernardo Cuenca Grau, Oxford University

Ian Horrocks, Oxford University

Bijan Parsia, The University of Manchester

Note: The complete list of contributors is being compiled and will be included in the next draft.

---

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

Abstract

Status of this Document

May Be Superseded

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

Set of Documents

This document is being published as one of a set of 7 documents:

1. Structural Specification and Functional-Style Syntax
2. Direct Semantics
3. RDF-Based Semantics
4. Mapping to RDF Graphs (this document)
5. XML Serialization
6. Profiles
7. Conformance and Test Cases

Compatibility with OWL 1

The OWL Working Group intends to make OWL 2 be a superset of OWL 1, except for a limited number of situations where we believe the impact will be minimal. This means that OWL 2 will be backward compatible, and creators of OWL 1 documents need only move to OWL 2 when they want to make use of OWL 2 features. More details and advice concerning migration from OWL 1 to OWL 2 will be in future drafts.

Summary of Changes

The major change to this document since the version of 11 April 2008 reflects the major revamping of the functional syntax to disallow punning between classes and datatypes and between object, data, and annotation properties and to include mapping for new features such as keys. Some minor changes were made to reflect changes in the Functional Syntax.

Please Comment By 2008-10-23

The OWL Working Group seeks public feedback on these Working Drafts. Please send your comments to public-owl-comments@w3.org (public archive). If possible, please offer specific changes to the text that would address your concern. You may also wish to check the Wiki Version of this document for internal-review comments and changes being drafted which may address your concerns.

No Endorsement

Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

Patents

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

[Show Short TOC]

[Show Full TOC]

This document provides mappings by means of which every OWL 2 ontology in the functional-style syntax [OWL 2 Specification] can be mapped into RDF triples and back without any change in the formal meaning of the ontology. More precisely, let O be any OWL 2 ontology in functional-style syntax, let T(O) be the set of RDF triples obtained by transforming O into RDF triples as specified in Section 2, and let O' be the OWL 2 ontology in 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: every OWL DL ontology in RDF syntax 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].

The following notation is used throughout this document for referring to parts of RDF graphs:

• *:x denotes a URI reference;
• _:x denotes a blank node;
• x denotes a blank node or a URI reference; and
• lt denotes a literal.

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 syntax into a set of RDF triples 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.

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 syntactic parts of OWL 2 ontologies:

• OP denotes an object property;
• OPE denotes an object property expression;
• DP denotes a data property;
• DPE denotes a data property expression;
• PE denotes an object or a data property expression;
• AP denotes an annotation property;
• C denotes a class;
• CE denotes a class expression;
• DT denotes a datatype;
• DR denotes a data range;
• a denotes an individual (named or anonymous);
• *:a denotes a named individual;
• _:a denotes an anonymous individual;
• lt denotes a literal;
• elt denotes an entity, an anonymous individual, or a literal; and
• f denotes a constraining facet.

In this section, T(SEQ y₁ ... y_n) denotes the translation of a sequence of objects from the functional-style syntax into an RDF list, as shown in Table 1.

If ax' is translated into a single RDF triple s p o, then the axiom ax generates the following triples instead of triple s p o:

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, and DifferentIndividuals with two individuals.

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.

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.

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,

• CE(x) maps x into a class expression,
• DR(x) maps x into a data range,
• OPE(x) maps x into an object property expression,
• DPE(x) maps x into a data property expression, and
• AP(x) maps x into an annotation property.

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.

• For each x, at most one of OPE(x), DPE(x), and AP(x) is defined.
• For each x, at most one of CE(x) and DR(x) is defined.

Firthermore, 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.

The function OPEorDPE is defined as follows:

• OPEorDPE(x) = OPE(x) if OPE(x) ≠ ε;
• OPEorDPE(x) = DPE(x) if DPE(x) ≠ ε; and
• OPEorDPE(x) = ε otherwise.

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:

• POS_INT(n) is matched to any literal whose value is a positive integer;
• NN_INT(n) is matched to any literal whose value 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 y₁ ... y_n) 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.

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.

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.

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 CE, DR, OPE, DPE, and AP are initialized as shown in Table 8.

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, triple patters from the headers of Tables 9 and 10 are matched in G. For each matched pattern, ANN(x) is extended with all annotations from the right 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 removed from G. This process is repeated until no further matches are possible.

Next, the functions 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.

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.

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

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.1.) Each time a triple pattern is matched, the matched triples are removed from G.

At the end of this process, if G is not empty then G MUST be rejected as syntactically incorrect.

[OWL 2 Specification]

OWL 2 Web Ontology Language:Structural Specification and Functional-Style Syntax Boris Motik, Peter F. Patel-Schneider, Bijan Parsia, eds. W3C Working Draft, 08 October 2008, http://www.w3.org/TR/2008/WD-owl2-syntax-20081008/. Latest version available at http://www.w3.org/TR/owl2-syntax/.

[RDF Semantics]

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

[RFC 2119]

RFC 2119: Key words for use in RFCs to Indicate Requirement Levels. Network Working Group, S. Bradner. Internet Best Current Practice, March 1997.