OWL 2 Web Ontology Language:
Conformance and Test Cases

W3C Editor's Draft 29 September 2008

This version:: http://www.w3.org/2007/OWL/draft/ED-owl2-test-20080929/
Latest editor's draft:: http://www.w3.org/2007/OWL/draft/owl2-test/
Previous version:: http://www.w3.org/2007/OWL/draft/ED-owl2-test-20080922/ (color-coded diff)

Authors:: Michael Smith, Clark & Parsia; Ian Horrocks, Oxford University

Abstract

OWL 2 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 describes the conditions that OWL 2 tools must satisfy in order to be conformant with the language specification. It also presents a set of tests that both illustrate the features of the language and can be used for testing conformance.

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

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

Please Comment By ASAP

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]

1 Introduction
2 Conformance (Normative)
- 2.1 Document Conformance
  - 2.1.1 Syntactic Conformance
  - 2.1.2 Datatype Map Conformance
- 2.2 Document Checker Conformance
  - 2.2.1 Entailment Checker
  - 2.2.2 Query Answering
3 Test Cases
4 References

1 Introduction

This document describes conformance conditions for OWL 2, and presents a set of test cases.

Conformance conditions are described for both OWL 2 documents and for tools that process such documents. In particular, the conformance conditions for an OWL 2 entailment checker are described in some detail.

The presented test cases are intended to illustrate the various features of the language, and can also be used for testing conformance. They are not exhaustive, however, nor do they constitute a conformance test suite for OWL: passing all the tests is no guarantee that a given system conforms to the OWL 2 specification.

In addition to the tests themselves, a categorization of test types and a format for test cases is also presented. This is intended to facilitate their use by OWL system developers, e.g., in a test harness, and the extension of the test suite with new tests.

The italicized keywords MUST, MUST NOT, SHOULD, SHOULD NOT, and MAY are used to specify normative features of OWL 2 documents and tools, and are interpreted as specified in RFC 2119 [RFC 2119].

2 Conformance (Normative)

This section describes conformance conditions for OWL 2 documents and tools.

2.1 Document Conformance

2.1.1 Syntactic Conformance

Any RDF document [RDF Syntax] is an OWL 2 Full ontology document.

An OWL 2 Full ontology document is an OWL 2 DL ontology document iff it can be successfully parsed using the canonical RDF parsing process [OWL 2 Mapping to RDF Graphs] and the resulting ontology in the functional-style syntax satisfies all the restrictions on OWL 2 DL ontologies [OWL 2 Specification].

An OWL 2 DL ontology document is an OWL 2 EL ontology document iff it can be successfully parsed using the canonical RDF parsing process [OWL 2 Mapping to RDF Graphs] and the resulting ontology in the functional-style syntax satisfies all the restrictions on OWL 2 EL ontologies [OWL 2 Profiles].

An OWL 2 DL ontology document is an OWL 2 QL ontology document iff it can be successfully parsed using the canonical RDF parsing process [OWL 2 Mapping to RDF Graphs] and the resulting ontology in the functional-style syntax satisfies all the restrictions on OWL 2 QL ontologies [OWL 2 Profiles].

An OWL 2 Full ontology document is an OWL 2 RL ontology document iff it can be successfully parsed using the canonical RDF parsing process [OWL 2 Mapping to RDF Graphs] and the resulting ontology in the functional-style syntax satisfies all the restrictions on OWL 2 RL ontologies [OWL 2 Profiles].

Review comment from MikeSmith 01:15, 22 September 2008 (UTC)
I find it odd that there are no statements made addressing the syntactic conformance of the non-RDF normative syntaxes.

2.1.2 Datatype Map Conformance

In OWL 2, semantic conditions are defined with respect to a datatype map [OWL 2 Specification]. This MUST be either the OWL 2 Datatype map [OWL 2 Specification] or an extension of the OWL 2 Datatype map to include additional datatypes.

2.2 Document Checker Conformance

2.2.1 Entailment Checker

An OWL 2 entailment checker takes as input two OWL 2 ontology documents O₁ and O₂ and checks if O₁ entails O₂ with respect to a datatype map and either the Model-Theoretic Semantics [OWL 2 Semantics] or the RDF-Based Semantics [OWL 2 RDF-Based Semantics]. Additionally:

It MUST provide a means to determine the datatypes supported by its datatype map, and any limits it has on datatype literals and datatype values [OWL 2 Specification]; for example, by listing them in its supporting documentation.
It MUST provide a means to determine the semantics it uses (either the Model-Theoretic Semantics [OWL 2 Semantics] or the RDF-Based Semantics [OWL 2 RDF-Based Semantics]); for example, in its supporting documentation.

An OWL 2 entailment checker returns a single result, being True, False, Unknown or Error. True indicates that the relevant entailment holds; False indicates that the relevant entailment does not hold; Unknown indicates that the algorithm used by the checker is not able to determine if the entailment holds; Error indicates that the checker encountered an error condition such as receiving an invalid input or exceeding resource limits. While sometimes needed (for example, for pragmatic reasons), Unknown and Error are not desired responses for valid inputs.

Additionally, an OWL 2 entailment checker:

MUST return Error if the parsing process fails (for example, due to network errors);
MUST return Error if an input document uses datatypes that are not supported by its datatype map or literals that it does not support (for example, very large integers); and
MUST return Error if the computation fails, for example as a result of exceeding resource limits.

Five different conformance classes of OWL entailment checker are defined:

An OWL 2 Full entailment checker is an OWL 2 entailment checker that takes RDF documents as input, and uses the RDF-Based Semantics [OWL 2 RDF-Based Semantics]. It MUST return True only when O₁ entails O₂, and it MUST return False only when O₁ does not entail O₂. It SHOULD NOT return Unknown.

An OWL 2 DL entailment checker is an OWL 2 entailment checker that takes OWL 2 DL ontology documents as input, and uses the Model Theoretic Semantics [OWL 2 Semantics]. It MUST return True only when O₁ entails O₂, and it MUST return False only when O₁ does not entail O₂. It SHOULD NOT return Unknown.

An OWL 2 EL entailment checker is an OWL 2 entailment checker that takes OWL 2 EL ontology documents as input, and uses the Model Theoretic Semantics [OWL 2 Semantics]. It MUST return True only when O₁ entails O₂, and it MUST return False only when O₁ does not entail O₂. It SHOULD NOT return Unknown.

An OWL 2 QL entailment checker is an OWL 2 entailment checker that takes OWL 2 QL ontology documents as input, and uses the Model Theoretic Semantics [OWL 2 Semantics]. It MUST return True only when O₁ entails O₂, and it MUST return False only when O₁ does not entail O₂. It SHOULD NOT return Unknown.

An OWL 2 RL entailment checker is an OWL 2 entailment checker that takes RDF documents as input, and uses the RDF-Based Semantics [OWL 2 RDF-Based Semantics]. It MUST return True only when O₁ entails O₂, and it MUST return False only when O₁ does not entail O₂; it MAY return Unknown if FO(O₁) ∪ R does not entail FO(O₂) under the standard first-order semantics, where R denotes the OWL 2 RL/RDF rules [OWL 2 Profiles], and FO(O) denotes the FO theory corresponding to O in which triples are represented using the T predicate — that is, T(s, p, o) represents an RDF triple with the subject s, predicate p, and the object o.

An OWL 2 entailment checker is terminating if, given sufficient resources (memory, addressing space, etc.), it will always return True, False, or Unknown in a finite amount of time (i.e., CPU cycles) on syntactically-valid inputs.

An OWL 2 entailment checker is complete if, given sufficient resources, it will always return True or False on syntactically-valid inputs.

Note: Every OWL 2 Full entailment checker is also an OWL 2 RL entailment checker.

Note: Every OWL 2 DL entailment checker is also an OWL 2 EL and OWL 2 QL entailment checker.

Note: From Theorem 1 of Profiles [OWL 2 Profiles], it follows that an OWL 2 RL entailment checker can return False if O₁ and O₂ satisfy the constraints described in Theorem 1, and FO(O₁) ∪ R does not entail FO(O₂) under the standard first-order semantics, where R denotes the OWL 2 RL/RDF rules [OWL 2 Profiles], and FO(O) denotes the FO theory corresponding to O in which triples are represented using the T predicate — that is, T(s, p, o) represents an RDF triple with the subject s, predicate p, and the object o. Implementations not wishing to check whether O₁ and O₂ satisfy the relevant constraints can simply return Unknown whenever they are not able to return True.

2.2.2 Query Answering

Query answering is closely related to entailment checking. A query can be thought of as an ontology Q in which some of the terms have been replaced by variables x₁, ..., x_n. Given an ontology O, a tuple t = <t₁, ..., t_n> is an answer for Q with respect to O if O entails Q_[x/t], where Q_[x/t] is derived from Q by substituting the variables x₁, ..., x_n with t₁, ..., t_n; the answer to Q with respect to O is the set of all such tuples.

Although highly inefficient in practice, query answering could be performed simply by iterating through all possible n-tuples formed from terms occurring in O and checking the corresponding entailment using an OWL 2 entailment checker. The properties of OWL 2 entailment checkers mean that the resulting answer will always be sound, i.e., every tuple occurring in the answer set is an answer to the query. If any one of the entailment checks might return Unknown, then the answer to the query may be incomplete, i.e., there may exist a tuple t that is an answer to the query but that does not occur in the answer set; implementations SHOULD issue a warning in this case.

The properties of OWL 2 Full, DL, EL and QL entailment checkers mean that query answering SHOULD be both sound and complete. In the case of OWL RL, query answering SHOULD be sound, and will also be complete if both the ontology and the query satisfy the constraints described in Theorem 1.

3 Test Cases

Editor's Note: Presently, the content in this document describing test cases is less mature than the content describing conformance. Among other considerations to be addressed, the test types and formats described below may change, and the manner in which the final test cases will be published remains undecided.

3.1 Test Types

3.1.1 Profile Identification Tests

These tests use one ontology. These tests are used to test the identification of syntactic profiles of OWL. Tests of all other types are also profile identification tests.

3.1.6 Syntax Translation Tests

These tests use one or more ontologies. These tests are used to test translation of OWL from one syntax to another.

3.2 Test Case Format

3.2.1 Status

The test:status property indicates if the test has been PROPOSED (test:PROPOSED), ACCEPTED (test:ACCEPTED), or REJECTED (test:REJECTED).

3.2.2 Type

The type of the test is indicated by a class assertion between the test and one or more of the following classes

test:PositiveEntailmentTest
test:NegativeEntailmentTest
test:ConsistencyTest
test:InconsistencyTest
test:ProfileIdentificationTest
test:SyntaxTranslationTest

3.2.3 Description

The description of the test is given using the test:description property.

3.2.4 Species

If a test has test:species value test:FULL, the input ontology is an OWL Full ontology. All tests should have this value.

If a test has test:species value test:DL, the input ontology satisfies the syntactic restrictions necessary for OWL DL ontologies. Each test must either have a property assertion indicating the input ontology is an OWL DL ontology, or a negative property assertion indicating it is not.

3.2.5 Profiles

If an input ontology is an OWL DL ontology, it may conform to the syntax restrictions of one or more profile.

If a test has test:profile value test:QL, the input ontology conforms to the syntax restrictions of the OWL QL profile.

If a test has test:profile value test:EL, the input ontology conforms to the syntax restrictions of the OWL EL profile.

If a test has test:profile value test:RL, the input ontology conforms to the syntax restrictions of the OWL RL profile.

For each profile, for each test there must either be a property assertion indicating the input ontology conforms to the restrictions of the profile, or a negative property assertion indicating it does not.

3.2.6 Input Ontologies

The test:inputOntology property associates a test with one or more input ontologies. For test types which require multiple input ontologies, subproperties of this property are used to differentiate the input ontologies. Subproperties of test:inputOntology are used to provide each input ontology in multiple syntaxes.

3.2.7 Imported Ontologies

The test:importedOntology property provides ontologies that are contained in the imports closure of the input ontologies. Subproperties of test:importedOntology are used to provide each input ontology in multiple syntaxes.

3.2.8 Normative Syntax

The test:normativeSyntax functional property is used to indicate which syntax of the input ontologies is normative for a test.

The value test:FUNCTIONAL indicates the functional syntax input ontologies are normative and other syntaxes are informative.

The value test:OWLXML indicates the OWL XML syntax input ontologies are normative and other syntaxes are informative.

The value test:RDFXML indicates the RDF/XML syntax input ontologies are normative and other syntaxes are informative.

If an input ontology is not an OWL DL ontology, the normative syntax must be RDF/XML.

3.2.9 Normative Translation

The test:normativeTranslation object property is used to indicate formats to which the translation of the input ontologies has been validated and is normative. Any test which is the subject of a statement with this object property is an instance of test:SyntaxTranslationTest.

The extension of this object property is disjoint with the test:normativeSyntax object property.

The value test:FUNCTIONAL indicates the functional syntax translation of the input ontologies is normative.

The value test:OWLXML indicates the OWL/XML syntax translation of the input ontologies is normative.

The value test:RDFXML indicates the RDF/XML syntax translation of the input ontologies is normative.

3.2.10 Specific Semantics

The test:semantics object property is used to indicate that a test is applicable under one type of OWL semantics, but not another.

The value test:FULL indicates that the test is applicable if and only if OWL RDF semantics are applied.

The value test:DL indicates that the test is applicable if and only if OWL DL semantics are applied.

For all tests which depend on specific semantics the test:alternativeSemanticsTest object property indicates a test which demonstrates the alternative semantics.

3.2.11 Issue

The test:issue annotation can be used to include a link to a specific WG issue.

3.2.12 Identifier

The test:identifier annotation should be used to associate a unique identifier with a test case. This identifier should conform to irelative-ref as defined in [RFC-3987] so that it may be appended to http://www.w3.org/2007/OWL/owlt/ to generate a URI for the test.

3.2.13 Test Ontology

Namespace( = <http://www.w3.org/2007/OWL/testOntology> )
Ontology(<http://www.w3.org/2007/OWL/testOntology>
    Label("The OWL 2 Test Ontology")

    Declaration( Class( :TestCase ) )

    Declaration( AnnotationProperty( :identifier ) )
    Declaration( AnnotationProperty( :description ) )
    Declaration( AnnotationProperty( :creator ) )
    Declaration( AnnotationProperty( :issue ) )


    Declaration( DataProperty( :inputOntology ) )
    Declaration( DataProperty( :premiseOntology ) )
    Declaration( DataProperty( :conclusionOntology ) )
    Declaration( DataProperty( :nonConclusionOntology ) )

    SubPropertyOf( :premiseOntology :inputOntology )
    SubPropertyOf( :conclusionOntology :inputOntology )
    SubPropertyOf( :nonConclusionOntology :inputOntology )


    Declaration( Class( :ProfileIdentificationTest ) )

    SubClassOf( :ProfileIdentificationTest :TestCase )
    SubClassOf( :ProfileIdentificationTest MinCardinality( 1 :inputOntology ) )


    Declaration( Class( :ConsistencyTest ) )
    Declaration( Class( :InconsistencyTest ) )

    SubClassOf( :ConsistencyTest :ProfileIdentificationTest )
    SubClassOf( :InconsistencyTest :ProfileIdentificationTest )
    DisjointClasses( :ConsistencyTest :InconsistencyTest )


    Declaration( Class( :PositiveEntailmentTest ) )

    SubClassOf( :PositiveEntailmentTest :ConsistencyTest )
    SubClassOf( :PositiveEntailmentTest MinCardinality( 1 :premiseOntology ) )
    SubClassOf( :PositiveEntailmentTest MinCardinality( 1 :conclusionOntology ) )


    Declaration( Class( :NegativeEntailmentTest ) )

    SubClassOf( :NegativeEntailmentTest :ConsistencyTest )
    SubClassOf( :NegativeEntailmentTest MinCardinality( 1 :premiseOntology ) )
    SubClassOf( :NegativeEntailmentTest MinCardinality( 1 :nonConclusionOntology ) )


    Declaration( ObjectProperty( :status ) )
    FunctionalProperty( :status )
    PropertyRange( :status OneOf( :Proposed :Approved :Rejected ) )
    DifferentIndividuals( :Proposed :Approved :Rejected )

    SubClassOf( :TestCase ExactCardinality( 1 :status ) )


    Declaration( ObjectProperty( :species ) )
    PropertyRange( :species OneOf( :DL :FULL ) )
    DifferentIndividuals( :DL :FULL )
    SubClassOf( HasValue( :species :DL ) HasValue( :species :FULL ) )


    Declaration( ObjectProperty( :profile ) )
    PropertyRange( :profile OneOf( :EL :QL :RL ) )
    DifferentIndividuals( :EL :QL :RL )


    SubClassOf(
        SomeValuesFrom( :profile OneOf( :EL  :QL ) )
        HasValue( :species :DL )
    )


    Declaration( ObjectProperty( :normativeSyntax ) )
    FunctionalProperty( :normativeSyntax )
    PropertyRange( :normativeSyntax OneOf( :RDFXML :FUNCTIONAL :OWLXML ) )
    DifferentIndividuals( :RDFXML :FUNCTIONAL :OWLXML )

    SubClassOf( :TestCase ExactCardinality( 1 :normativeSyntax ) )

    Declaration( ObjectProperty( :normativeTranslation ) )
    PropertyRange( :normativeTranslation OneOf( :RDFXML :FUNCTIONAL :OWLXML ) )
    DisjointProperties( :normativeSyntax :normativeTranslation )
    EquivalentClasses( :SyntaxTranslationTest IntersectionOf( :TestCase MinCardinality( 1 :normativeTranslation ) ) )

    SubClassOf(
        IntersectionOf( :TestCase ComplementOf( HasValue( :species :DL ) ) ) 
        HasValue( :normativeSyntax :RDFXML )
    )
    
    Declaration( ObjectProperty( :semantics ) )
    Declaration( ObjectProperty( :alternativeSemanticsTest ) )

    PropertyRange( :semantics OneOf( :DL :FULL ) )
    FunctionalProperty( :semantics )
    FunctionalProperty( :alternativeSemanticsTest )
    SymmetricProperty( :alternativeSemanticsTest )

    SubClassOf(
      HasValue( :semantics :DL )
      SomeValuesFrom( :alternativeSemanticsTest HasValue( :semantics :FULL ) )
    )

    SubClassOf(
      HasValue( :semantics :FULL )
      SomeValuesFrom( :alternativeSemanticsTest HasValue( :semantics :DL ) )
    )


    Declaration( DataProperty( :fsInputOntology ) )
    Declaration( DataProperty( :fsPremiseOntology ) )
    Declaration( DataProperty( :fsConclusionOntology ) )
    Declaration( DataProperty( :fsNonConclusionOntology ) )
    SubPropertyOf( :fsInputOntology :inputOntology )
    SubPropertyOf( :fsPremiseOntology :premiseOntology )
    SubPropertyOf( :fsPremiseOntology :fsInputOntology )
    SubPropertyOf( :fsConclusionOntology :conclusionOntology )
    SubPropertyOf( :fsConclusionOntology :fsInputOntology )
    SubPropertyOf( :fsNonConclusionOntology :nonConclusionOntology )
    SubPropertyOf( :fsNonConclusionOntology :fsInputOntology )

    Declaration( DataProperty( :owlXmlInputOntology ) )
    Declaration( DataProperty( :owlXmlPremiseOntology ) )
    Declaration( DataProperty( :owlXmlConclusionOntology ) )
    Declaration( DataProperty( :owlXmlNonConclusionOntology ) )
    SubPropertyOf( :owlXmlInputOntology :inputOntology )
    SubPropertyOf( :owlXmlPremiseOntology :premiseOntology )
    SubPropertyOf( :owlXmlPremiseOntology :owlXmlInputOntology )
    SubPropertyOf( :owlXmlConclusionOntology :conclusionOntology )
    SubPropertyOf( :owlXmlConclusionOntology :owlXmlInputOntology )
    SubPropertyOf( :owlXmlNonConclusionOntology :nonConclusionOntology )
    SubPropertyOf( :owlXmlNonConclusionOntology :owlXmlInputOntology )

    Declaration( DataProperty( :rdfXmlInputOntology ) )
    Declaration( DataProperty( :rdfXmlPremiseOntology ) )
    Declaration( DataProperty( :rdfXmlConclusionOntology ) )
    Declaration( DataProperty( :rdfXmlNonConclusionOntology ) )
    SubPropertyOf( :rdfXmlInputOntology :inputOntology )
    SubPropertyOf( :rdfXmlPremiseOntology :premiseOntology )
    SubPropertyOf( :rdfXmlPremiseOntology :rdfXmlInputOntology )
    SubPropertyOf( :rdfXmlConclusionOntology :conclusionOntology )
    SubPropertyOf( :rdfXmlConclusionOntology :rdfXmlInputOntology )
    SubPropertyOf( :rdfXmlNonConclusionOntology :nonConclusionOntology )
    SubPropertyOf( :rdfXmlNonConclusionOntology :rdfXmlInputOntology )

    DisjointProperties( :fsInputOntology :owlXmlInputOntology :rdfXmlInputOntology )


    Declaration( DataProperty( :importedOntology ) )
    Declaration( DataProperty( :fsImportedOntology ) )
    Declaration( DataProperty( :owlXmlImportedOntology ) )
    Declaration( DataProperty( :rdfXmlImportedOntology ) )

    SubPropertyOf( :fsImportedOntology :importedOntology )
    SubPropertyOf( :owlXmlImportedOntology :importedOntology )
    SubPropertyOf( :rdfXmlImportedOntology :importedOntology )
    DisjointProperties( :fsImportedOntology :owlXmlImportedOntology :rdfXmlImportedOntology )
)