W3C

OWL Web Ontology Language
Test Cases

W3C Candidate Recommendation 18 August 2003 (alternative version)

This version:
http://www.w3.org/TR/2003/CR-owl-test-20030818/
Latest version:
http://www.w3.org/TR/owl-test/
Previous version:
http://www.w3.org/TR/2003/WD-owl-test-20030528/
Editors:
Jeremy J. Carroll, HP <jjc@hpl.hp.com>
Jos De Roo, AGFA,<jos.deroo@agfa.com>

The normative version of this document is a compound document. Non-normative versions consisting of a single HTML file are available in three sizes: medium, large, and extra large (this version). The tests of this document are also available in these non-normative formats: Zip archive of approved tests, Zip archive of proposed tests, the test web site.

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

Abstract

This document contains and presents test cases for the Web Ontology Language (OWL) approved by the Web Ontology Working Group. Many of the test cases illustrate the correct usage of the Web Ontology Language (OWL), and the formal meaning of its constructs. Other test cases illustrate the resolution of issues considered by the working group. Conformance for OWL documents and OWL document checkers is specified.

Status of this document

See the normative compound HTML document for document status.

Table of Contents

1. Introduction

As part of the definition of the Web Ontology Language (OWL) the Web Ontology Working Group provides a set of test cases. This document presents those test cases. They are intended to provide examples for, and clarification of, the normative definition of OWL found in [OWL Semantics and Abstract Syntax] to which this document is subsidiary.

This document is one component of the description of OWL, the Web Ontology Language, being produced by the W3C Web Ontology Working Group. The Document Roadmap section of the [OWL Overview] describes each of the different parts and how they fit together.

This document describes the various types of test used and the format in which the tests are presented. Alternative formats of the test collection are provided. These are intended to be suitable for use by OWL developers in test harnesses, possibly as part of a test driven development process, such as Extreme Programming [XP]. The format of the Manifest files used as part of these alternative formats is described.

This document describes the process for conflict resolution and errata related to these tests.

In the non-normative appendices, this document also describes the process for creation and approval of these tests.

Further appendices show further proposed tests that are awaiting resolution by the working group.

1.1. Conformance and Scope

Various conformance levels are defined in this document in terms of [OWL Semantics and Abstract Syntax].

However, the test cases do not constitute a conformance test suite for OWL, since they are silent on several important issues. This document cannot be considered a complete specification of OWL.

The tests illustrate issue resolutions, and illustrate the use and meaning of the terms in the OWL namespace.

There are other miscellaneous tests: some arising in the literature, and in preexisting systems; others intending to show the difficulty of complete implementations of OWL Full.

2. Deliverables (Normative)

The deliverables included as part of the test cases are:

Note: Other files can be found under the top URL of the web-site which are not part of the deliverable.

[[EDITORS' NOTE: Do we need index files for the web site that clarify which parts are part of the deliverable and which are not?]]

2.1. Normative Status

Of the deliverables the only normative tests are those included in this document. All other deliverables are informative. Moreover, the recommendation document is informative except for the conformance statements, the test data (specified in RDF/XML [RDF/XML Syntax]), and the supporting documentation.

3. Test Types (Normative)

Each test consists of one or more RDF/XML documents and a Manifest file. Tests of one document indicate some property of that document when viewed as an OWL knowledge base. Tests of two or more documents indicate a relationship between the two documents when viewed as OWL knowledge bases.

The Manifest file is named ManifestNNN.rdf (The NNN is replaced by the test number). It contains metadata (in RDF) indicating the test type, and describing the test.

The metadata also indicates the language levels appropriate for each test and each document in each test. For each RDF/XML document, one language level is indicated, being OWL Lite, OWL DL or OWL Full, as given by the syntactic rules in [OWL Semantics and Abstract Syntax]. For semantic tests, one or two language levels are indicated. If the language level OWL Full is indicated for a semantic test, then the test holds according to the RDF-Compatible Model-Theoretic Semantics in [OWL Semantics and Abstract Syntax]. If the language level OWL Lite or OWL DL is indicated for a semantic test, then the test holds according to the Direct Model-Theoretic Semantics in [OWL Semantics and Abstract Syntax]. If the language level OWL Lite is indicated for a semantic test, then the test only uses features within the OWL Lite sublanguage.

Some of the tests require that certain datatypes are, or are not, supported in the datatype theory [OWL Semantics and Abstract Syntax]. These are indicated with the test. Other datatypes which are used in the test are also indicated: the test applies whether or not these are supported in the datatype theory . The datatypes xsd:integer, xsd:string from [XML Schema Datatypes] are not indicated, even when used or required, since they must be supported.

3.1. Tests for Incorrect Use of OWL Namespace

These tests use one document. It is named badNNN.rdf. This document includes a use of the OWL namespace with a local name that is not defined by the OWL recommendation. An OWL Syntax checker SHOULD give a warning.

Note: These tests are intended to help migration from DAML+OIL [DAML+OIL], since the local names chosen are defined in the DAML+OIL namespace.

3.2. Entailment Tests

These tests use two documents. One is named premisesNNN.rdf, the other is named conclusionsNNN.rdf. The conclusions are entailed by the premises. Such entailment is defined by the OWL semantics [OWL Semantics and Abstract Syntax], (see also OWL Full entailment).

3.3. Non-Entailment Tests

These tests use two documents. One is named premisesNNN.rdf, the other is named nonconclusionsNNN.rdf. The nonconclusions are not entailed by the premises. Such entailment is defined by the OWL semantics [OWL Semantics and Abstract Syntax], (see also OWL Full entailment).

Exceptionally, test imports-002 includes a third document.

3.4. True Tests

These tests use one document. It is named conclusionsNNN.rdf. The conclusions follow from the OWL semantics [OWL Semantics and Abstract Syntax]. These tests are a special case of the entailment tests in which the premises are empty.

3.5. OWL for OWL Tests

These tests use one document. It is named conclusionsNNN.rdf. These are a special case of true tests. The conclusions follow from the OWL Full semantics [OWL Semantics and Abstract Syntax]. The tests are intended to illustrate how OWL Full can be used to describe its own properties and classes.

3.6. Consistency Tests

These tests use one document. It is named consistentNNN.rdf. The document is consistent as defined by the OWL Semantics [OWL Semantics and Abstract Syntax], (see also OWL Full consistency).

3.7. Inconsistency Tests

These tests use one document. It is named inconsistentNNN.rdf. The document is not consistent as defined by the OWL semantics [OWL Semantics and Abstract Syntax], (see also OWL Full consistency).

3.8. Import Entailment Tests

These tests use more than two documents. One is named premisesNNN.rdf, another is named conclusionsNNN.rdf, the rest have names like supportNNN-A.rdf. The support documents are in the imports closure of the premises document. The conclusions are entailed by the imports closure of the premises. Such entailment is defined by the OWL semantics [OWL Semantics and Abstract Syntax], (see also OWL Full entailment).

3.9. Import Level Tests

These tests use two documents. One is named importsNNN.rdf, the other is named mainNNN.rdf. These tests indicate the interaction between owl:imports and the sublanguage levels of the main document.

4. Conformance (Normative)

4.1. Document Conformance

4.1.1. Syntactic Conformance

An OWL Full document is any RDF/XML document [RDF/XML Syntax].

An OWL DL document is an OWL Full document such that the imports closure [OWL Semantics and Abstract Syntax] of the corresponding RDF graph [RDF Concepts] is an OWL DL ontology in RDF graph form.

An OWL Lite document is an OWL Full document such that the imports closure [OWL Semantics and Abstract Syntax] of the corresponding RDF graph [RDF Concepts] is an OWL Lite ontology in RDF graph form.

4.1.2. Semantic Conformance

An OWL Lite or OWL DL document D is OWL DL consistent with respect to a datatype theory T if and only if there is some abstract OWL interpretation I with respect to T such that I satisfies an abstract ontology O corresponding to D, in which O has a separated vocabulary; (see [OWL Semantics and Abstract Syntax]).

An OWL Full document D is OWL Full consistent with respect to a datatype theory T, if and only if there is some OWL Full interpretation I with respect to T such that I satisfies all the RDF graphs in some imports closed collection containing an RDF graph corresponding to D.

4.2. Document Checker Conformance

This section uses the words MUST, MUST NOT, SHOULD and MAY as in [RFC 2119].

4.2.1. Syntax Checker

An OWL syntax checker takes a document as input, and returns one word being one of Lite, DL, Full, Other.

The return value MUST conform with the following:

Lite
The input document is an OWL Lite document.
DL
The input document is an OWL DL document but not an OWL Lite document.
Full
The input document is an OWL Full document but not an OWL DL document.
Other
The input document is not an OWL Full document.

In addition, an OWL Syntax Checker SHOULD report a warning if the RDF graph [RDF Concepts] corresponding to the document uses any URI references starting with the prefix http://www.w3.org/2002/07/owl# except those found in the [RDF Schema for OWL].

An OWL syntax checker SHOULD report network errors occurring during the computation of the imports closure.

4.2.2. Consistency Checker

An OWL consistency checker takes a document as input, and returns one word being Consistent, Inconsistent, or Unknown.

An OWL consistency checker SHOULD report network errors occurring during the computation of the imports closure.

An OWL consistency checker MUST provide a means to determine the datatypes supported by its datatype theory, [OWL Semantics and Abstract Syntax]; for example, by listing them in its supporting documentation.

An OWL consistency checker MUST provide a means to determine the model theory [OWL Semantics and Abstract Syntax], it uses (either the Direct Model-Theoretic Semantics or the RDF-Compatible Model-Theoretic Semantics); for example, in its supporting documentation.

An OWL consistency checker MUST be sound: it MUST return Consistent only when the input document is consistent and Inconsistent only when the input document is not consistent, with respect to the datatype theory of the checker.

If an input document uses datatypes that are not supported by the datatype theory of an OWL consistency checker then it MAY report a warning.

An OWL consistency checker is complete and terminating, if, given sufficient (but finite) resources (CPU cycles and memory) and the absence of network errors, it will always return either Consistent or Inconsistent. It has been shown that for OWL Lite and DL it is possible to construct a complete and terminating consistency checker (the languages are decidable), and that for OWL full it is not possible to construct a complete and terminating consistency checker (the language is undecidable, [Practical Reasoning]).

The datatype theory of an OWL consistency checker MUST minimally support at least xsd:integer, xsd:string from [XML Schema Datatypes].

An OWL consistency checker SHOULD NOT return Unknown. Unknown, while sometimes needed, is not a desired response.

Four different conformance classes of OWL consistency checker are defined.

An OWL Lite consistency checker is an OWL consistency checker that takes an OWL Lite document as input, and uses the Direct Model-Theoretic Semantics.

An OWL DL consistency checker is an OWL consistency checker that takes an OWL DL document as input and uses the Direct Model-Theoretic Semantics.

An OWL Full consistency checker is an OWL consistency checker that takes an OWL Full document as input and uses the RDF-Compatible Model-Theoretic Semantics.

A complete OWL Lite consistency checker is an OWL Lite consistency checker that is complete and terminating.

Note: An OWL Full consistency checker may indicate that an OWL DL document is inconsistent, while an OWL DL consistency checker indicates that the same document is consistent, (for example: compare test Thing-001 with Thing-002 or compare AnnotationProperty-001 with AnnotationProperty-002). Every OWL DL consistency checker is also an OWL Lite consistency checker.

Note: A complete OWL Lite consistency checker MAY return Unknown for an OWL Lite document in the case where a resource limit has been exceeded.

Note: The usage of the word 'complete' in this section follows the conventions of the description logic community. In some other communities the word 'complete' is used in a weaker sense, refering to the detection of inconsistency by logical inference systems.

5. Testing an OWL Implementation (Informative)

5.1. OWL Syntax Checkers

An OWL syntax checker when presented with any of the test files must return the indicated result.

5.2. OWL Consistency Checker

An OWL consistency checker can be tested using appropriate consistency and inconsistency tests. Appropriate tests are those of an appropriate level and for which the checker has appropriate datatype support. The level of the test indicates the semantic theory being used, which may differ from the level of the file. For example, test Thing-001 contains an OWL Lite file which is consistent as an OWL Lite or OWL DL consistency test, but inconsistent as an OWL Full consistency test.

An OWL consistency checker has appropriate datatype support for a test if both:

An OWL Lite consistency checker with appropriate datatype support, when presented with a file from an OWL Lite consistency test, must return Consistent or Unknown.

An OWL DL consistency checker with appropriate datatype support, when presented with a file from an OWL DL or OWL Lite consistency test, must return Consistent or Unknown.

An OWL Full consistency checker with appropriate datatype support, when presented with a file from an OWL Full consistency test, must return Consistent or Unknown.

The corresponding inconsistency tests must return Inconsistent or Unknown.

A complete OWL Lite consistency checker should not return Unknown on the OWL Lite consistency or inconsistency tests, regardless of the use of unsupported datatypes.

6. Manifest Files (Informative)

The Manifest file follows the RDF schema developed for the RDF Test Cases [RDF Test Cases].

This is augmented by a few new properties and types which are declared in the OWL Test Ontology, found at http://www.w3.org/2002/03owlt/testOntology.

Specifically each test has its own Manifest file, and is identified from the URI reference formed from the Manifest file's URL with a fragment test.

The test has one rdf:type explicit, and this is one of:

otest:NotOwlFeatureTest
A test for the incorrect use of the OWL namespace name.
otest:PositiveEntailmentTest
An entailment test.
otest:NegativeEntailmentTest
A non-entailment test.
otest:TrueTest
A true test.
otest:OWLforOWLTest
An OWL for OWL test.
otest:ConsistencyTest
A consistency test.
otest:InconsistencyTest
An inconsistency test.
otest:ImportEntailmentTest
An import entailment test.
otest:ImportLevelTest
An import level test.

Where otest is bound to http://www.w3.org/2002/03owlt/testOntology# and rtest is bound to http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#.

The name of the original author of the test is shown using a dc:creator property, see [Dublin Core].

A description of the test is given (using XHTML markup [XHTML]) as the value of the rtest:description property.

An issue, if any, from the OWL Issues list [OWL Issues], is the value of a rtest:issue property.

An appropriate language feature, from the OWL namespace, if any, is the value of the otest:feature property.

The input documents with the test data are found as the value of the rtest:inputDocument property or as the value of both the rtest:premiseDocument and the rtest:conclusionDocument. The support files for import entailment tests, import level tests and test imports-002 are found as the values of otest:importedPremiseDocument.

The conformance levels associated with both files and tests are given with the otest:level property. The value for each document is one of otest:Full, otest:DL, otest:Lite or otest:Other. Each test is explicitly associated with one or two levels. If it is associated with otest:Lite then it is implicitly suitable for otest:DL.

The datatypes used in the test are given with the otest:usedDatatype property or with one of its subproperties: otest:supportedDatatype or otest:notSupportedDatatype. These indicate that the test is only valid when the datatype is supported or not supported respectively by the datatype theory being used.

7. The OWL Tests (Normative)

7.1. By Function

7.1.1. owl:AllDifferent

FullPositive Entailment Test:001
Description: (informative) <AllDifferent/Manifest001#test>
using AllDifferent to derive differentFrom
N3 format is informative.
FullPremises: <AllDifferent/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/AllDifferent/premises001#"
    xml:base="http://www.w3.org/2002/03owlt/AllDifferent/premises001" >

    <owl:AllDifferent> 
      <owl:distinctMembers rdf:parseType="Collection">
        <first:Person rdf:about="#Fred" />
        <first:Person rdf:about="#Wilma" />
        <first:Person rdf:about="#Barney" />
        <first:Person rdf:about="#Betty" />
      </owl:distinctMembers>
    </owl:AllDifferent> 

</rdf:RDF>
_:a rdf:type owl:AllDifferent .
first:Fred rdf:type first:Person .
first:Wilma rdf:type first:Person .
first:Barney rdf:type first:Person .
first:Betty rdf:type first:Person .
_:c rdf:first first:Betty .
_:c rdf:rest rdf:nil .
_:e rdf:first first:Barney .
_:e rdf:rest _:c .
_:g rdf:first first:Wilma .
_:g rdf:rest _:e .
_:i rdf:first first:Fred .
_:i rdf:rest _:g .
_:a owl:distinctMembers _:i .
FullConclusions: <AllDifferent/conclusions001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/AllDifferent/premises001#"
    xml:base="http://www.w3.org/2002/03owlt/AllDifferent/conclusions001" >

    <rdf:Description rdf:about="premises001#Barney">
        <owl:differentFrom rdf:resource="premises001#Fred"/>
    </rdf:Description>

</rdf:RDF>
first:Barney owl:differentFrom first:Fred .

7.1.2. owl:FunctionalProperty

FullPositive Entailment Test:001
Description: (informative) <FunctionalProperty/Manifest001#test>
If prop belongs to owl:FunctionalProperty, and subject denotes a resource which is the subject of two prop triples, then the objects of these triples have the same denotation.
N3 format is informative.
FullPremises: <FunctionalProperty/premises001> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xmlns:first="http://www.w3.org/2002/03owlt/FunctionalProperty/premises001#" 
  xml:base="http://www.w3.org/2002/03owlt/FunctionalProperty/premises001" >
    <owl:FunctionalProperty rdf:ID="prop"/>
    <rdf:Description rdf:ID="subject">
      <first:prop rdf:resource="#object1" />
      <first:prop rdf:resource="#object2" />
    </rdf:Description>
</rdf:RDF>
first:prop rdf:type owl:FunctionalProperty .
first:subject first:prop first:object1 .
first:subject first:prop first:object2 .
FullConclusions: <FunctionalProperty/conclusions001> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xml:base="http://www.w3.org/2002/03owlt/FunctionalProperty/conclusions001" >
    <rdf:Description rdf:about="premises001#object1">
      <owl:sameAs rdf:resource="premises001#object2" />
    </rdf:Description>
</rdf:RDF>
first:object1 owl:sameAs first:object2 .

FullPositive Entailment Test:002
Description: (informative) <FunctionalProperty/Manifest002#test>
If prop belongs to owl:FunctionalProperty, and subject denotes a resource which is the subject of two prop triples, then the objects of these triples have the same denotation.Hence any assertion made using one of them can be transferred to the other.
N3 format is informative.
Namespaces:
@prefix eg: <http://www.example.org/> .
FullPremises: <FunctionalProperty/premises002> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xmlns:eg ="http://www.example.org/"
  xmlns:first="http://www.w3.org/2002/03owlt/FunctionalProperty/premises002#" 
  xml:base="http://www.w3.org/2002/03owlt/FunctionalProperty/premises002" >
    <owl:FunctionalProperty rdf:ID="prop"/>
    <rdf:Description rdf:ID="subject">
      <first:prop>
          <rdf:Description rdf:ID="object1">
            <eg:prop2>value</eg:prop2>
          </rdf:Description>
      </first:prop>
      <first:prop rdf:resource="#object2" />
    </rdf:Description>
</rdf:RDF>
first:prop rdf:type owl:FunctionalProperty .
first:object1 eg:prop2 "value" .
first:subject first:prop first:object1 .
first:subject first:prop first:object2 .
FullConclusions: <FunctionalProperty/conclusions002> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:eg ="http://www.example.org/"
  xml:base="http://www.w3.org/2002/03owlt/FunctionalProperty/conclusions002" >
    <rdf:Description rdf:about="premises002#object2" >
        <eg:prop2>value</eg:prop2>
    </rdf:Description>
</rdf:RDF>
first:object2 eg:prop2 "value" .

FullPositive Entailment Test:003
Description: (informative) <FunctionalProperty/Manifest003#test>
If prop is an owl:FunctionalProperty, then its inverse is an owl:InverseFunctionalProperty.
N3 format is informative.
FullPremises: <FunctionalProperty/premises003> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xml:base="http://www.w3.org/2002/03owlt/FunctionalProperty/premises003" >
    <owl:FunctionalProperty rdf:ID="prop">
      <owl:inverseOf rdf:resource="#inv"/>
    </owl:FunctionalProperty>
</rdf:RDF>
first:prop rdf:type owl:FunctionalProperty .
first:prop owl:inverseOf first:inv .
LiteConclusions: <FunctionalProperty/conclusions003> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xml:base="http://www.w3.org/2002/03owlt/FunctionalProperty/conclusions003" >
    <owl:InverseFunctionalProperty rdf:about="premises003#inv"/>
</rdf:RDF>
first:inv rdf:type owl:InverseFunctionalProperty .

FullPositive Entailment Test:004
Description: (informative) <FunctionalProperty/Manifest004#test>
If the range of prop is a singleton set then it is necessarily functional, (i.e. every member of its domain has a single value) and so it is an owl:FunctionalProperty.
N3 format is informative.
FullPremises: <FunctionalProperty/premises004> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"  
  xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
  xml:base="http://www.w3.org/2002/03owlt/FunctionalProperty/premises004" >
    <owl:ObjectProperty rdf:ID="prop">
      <rdfs:range rdf:resource="#Singleton"/>
    </owl:ObjectProperty>
    <rdfs:Class rdf:ID="Singleton">
      <owl:oneOf rdf:parseType="Collection">
          <rdf:Description/>
      </owl:oneOf>
    </rdfs:Class>
</rdf:RDF>
first:prop rdf:type owl:ObjectProperty .
first:prop rdfs:range first:Singleton .
first:Singleton rdf:type rdfs:Class .
_:a rdf:first _:b .
_:a rdf:rest rdf:nil .
first:Singleton owl:oneOf _:a .
FullConclusions: <FunctionalProperty/conclusions004> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xml:base="http://www.w3.org/2002/03owlt/FunctionalProperty/conclusions004" >
    <owl:FunctionalProperty rdf:about="premises004#prop"/>
</rdf:RDF>
first:prop rdf:type owl:FunctionalProperty .

7.1.3. owl:InverseFunctionalProperty

FullPositive Entailment Test:001
Description: (informative) <InverseFunctionalProperty/Manifest001#test>
If prop belongs to owl:InverseFunctionalProperty, and object denotes a resource which is the object of two prop triples, then the subjects of these triples have the same denotation.
N3 format is informative.
FullPremises: <InverseFunctionalProperty/premises001> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xmlns:first="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/premises001#" 
  xml:base="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/premises001" >
    <owl:InverseFunctionalProperty rdf:ID="prop"/>
    <rdf:Description rdf:ID="subject1">
      <first:prop rdf:resource="#object" />
    </rdf:Description>
    <rdf:Description rdf:ID="subject2">
      <first:prop rdf:resource="#object" />
    </rdf:Description>
</rdf:RDF>
first:prop rdf:type owl:InverseFunctionalProperty .
first:subject1 first:prop first:object .
first:subject2 first:prop first:object .
FullConclusions: <InverseFunctionalProperty/conclusions001> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xml:base="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/conclusions001" >
    <rdf:Description rdf:about="premises001#subject1">
      <owl:sameAs rdf:resource="premises001#subject2" />
    </rdf:Description>
</rdf:RDF>
first:subject1 owl:sameAs first:subject2 .

FullPositive Entailment Test:002
Description: (informative) <InverseFunctionalProperty/Manifest002#test>
If prop belongs to owl:InverseFunctionalProperty, and object denotes a resource which is the object of two prop triples, then the subjects of these triples have the same denotation. Hence any assertion made using one of them can be transferred to the other.
N3 format is informative.
Namespaces:
@prefix eg: <http://www.example.org/> .
FullPremises: <InverseFunctionalProperty/premises002> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xmlns:eg ="http://www.example.org/"
  xmlns:first="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/premises002#" 
  xml:base="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/premises002" >
    <owl:InverseFunctionalProperty rdf:ID="prop"/>
    <rdf:Description rdf:ID="subject1" >
      <first:prop rdf:resource="#object" />
      <eg:prop2>value</eg:prop2>
    </rdf:Description>
    <rdf:Description rdf:ID="subject2" >
      <first:prop rdf:resource="#object" />
    </rdf:Description>
</rdf:RDF>
first:prop rdf:type owl:InverseFunctionalProperty .
first:subject1 first:prop first:object .
first:subject1 eg:prop2 "value" .
first:subject2 first:prop first:object .
FullConclusions: <InverseFunctionalProperty/conclusions002> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:eg ="http://www.example.org/"
  xml:base="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/conclusions002" >
    <rdf:Description rdf:about="premises002#subject2" >
      <eg:prop2>value</eg:prop2>
    </rdf:Description>
</rdf:RDF>
first:subject2 eg:prop2 "value" .

FullPositive Entailment Test:003
Description: (informative) <InverseFunctionalProperty/Manifest003#test>
If prop is an owl:InverseFunctionalProperty, then its inverse is an owl:FunctionalProperty.
N3 format is informative.
FullPremises: <InverseFunctionalProperty/premises003> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xml:base="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/premises003" >
    <owl:InverseFunctionalProperty rdf:ID="prop">
      <owl:inverseOf rdf:resource="#inv"/>
    </owl:InverseFunctionalProperty>
</rdf:RDF>
first:prop rdf:type owl:InverseFunctionalProperty .
first:prop owl:inverseOf first:inv .
FullConclusions: <InverseFunctionalProperty/conclusions003> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xml:base="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/conclusions003" >
    <owl:FunctionalProperty rdf:about="premises003#inv"/>
</rdf:RDF>
first:inv rdf:type owl:FunctionalProperty .

FullPositive Entailment Test:004
Description: (informative) <InverseFunctionalProperty/Manifest004#test>
If the domain of prop is a singleton set then it is necessarily inverse functional, (i.e. every member of its range is the value of a single item) so it is an owl:InverseFunctionalProperty.
N3 format is informative.
FullPremises: <InverseFunctionalProperty/premises004> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"  
  xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
  xml:base="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/premises004" >
    <owl:ObjectProperty rdf:ID="prop">
      <rdfs:domain rdf:resource="#Singleton"/>
    </owl:ObjectProperty>
    <rdfs:Class rdf:ID="Singleton">
      <owl:oneOf rdf:parseType="Collection">
          <rdf:Description/>
      </owl:oneOf>
    </rdfs:Class>
</rdf:RDF>
first:prop rdf:type owl:ObjectProperty .
first:prop rdfs:domain first:Singleton .
first:Singleton rdf:type rdfs:Class .
_:a rdf:first _:b .
_:a rdf:rest rdf:nil .
first:Singleton owl:oneOf _:a .
LiteConclusions: <InverseFunctionalProperty/conclusions004> 
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:owl ="http://www.w3.org/2002/07/owl#"
  xml:base="http://www.w3.org/2002/03owlt/InverseFunctionalProperty/conclusions004" >
    <owl:InverseFunctionalProperty rdf:about="premises004#prop"/>
</rdf:RDF>
first:prop rdf:type owl:InverseFunctionalProperty .

7.1.4. owl:Nothing

DL FullOWL described in OWL.002
Description: (informative) <Nothing/Manifest002#test>
An empty owl:Class has the same class extension as owl:Nothing.
N3 format is informative.
DLTrue: <Nothing/conclusions002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xml:base='http://www.w3.org/2002/03owlt/Nothing/conclusions002'
    xmlns:owl="http://www.w3.org/2002/07/owl#">

   <owl:Class>
      <owl:oneOf rdf:parseType="Collection"/>
      <owl:equivalentClass  rdf:resource="http://www.w3.org/2002/07/owl#Nothing" />
   </owl:Class>

</rdf:RDF>
_:a rdf:type owl:Class .
_:a owl:oneOf rdf:nil .
_:a owl:equivalentClass owl:Nothing .

7.1.5. owl:SymmetricProperty

FullPositive Entailment Test:001
Description: (informative) <SymmetricProperty/Manifest001#test>
A simple illustration of symmetric properties.
N3 format is informative.
FullPremises: <SymmetricProperty/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/SymmetricProperty/premises001#"
    xmlns:second="http://www.w3.org/2002/03owlt/SymmetricProperty/conclusions001#"
    xml:base="http://www.w3.org/2002/03owlt/SymmetricProperty/premises001" >

    <rdf:Description rdf:about="premises001#Ghent">
        <first:path rdf:resource="premises001#Antwerp"/>
    </rdf:Description>

    <owl:SymmetricProperty rdf:about="premises001#path"/>

</rdf:RDF>
first:Ghent first:path first:Antwerp .
first:path rdf:type owl:SymmetricProperty .
FullConclusions: <SymmetricProperty/conclusions001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/SymmetricProperty/premises001#"
    xmlns:second="http://www.w3.org/2002/03owlt/SymmetricProperty/conclusions001#"
    xml:base="http://www.w3.org/2002/03owlt/SymmetricProperty/conclusions001" >

    <rdf:Description rdf:about="premises001#Antwerp">
        <first:path rdf:resource="premises001#Ghent"/>
    </rdf:Description>

</rdf:RDF>
first:Antwerp first:path first:Ghent .

7.1.6. owl:TransitiveProperty

FullPositive Entailment Test:001
Description: (informative) <TransitiveProperty/Manifest001#test>
A simple illustration of transitivity.
N3 format is informative.
FullPremises: <TransitiveProperty/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/TransitiveProperty/premises001#"
    xmlns:second="http://www.w3.org/2002/03owlt/TransitiveProperty/conclusions001#"
    xml:base="http://www.w3.org/2002/03owlt/TransitiveProperty/premises001" >

    <rdf:Description rdf:about="premises001#Antwerp">
        <first:path rdf:resource="premises001#Amsterdam"/>
    </rdf:Description>

    <rdf:Description rdf:about="premises001#Ghent">
        <first:path rdf:resource="premises001#Antwerp"/>
    </rdf:Description>

    <owl:TransitiveProperty rdf:about="premises001#path"/>

</rdf:RDF>
first:Antwerp first:path first:Amsterdam .
first:Ghent first:path first:Antwerp .
first:path rdf:type owl:TransitiveProperty .
FullConclusions: <TransitiveProperty/conclusions001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/TransitiveProperty/premises001#"
    xmlns:second="http://www.w3.org/2002/03owlt/TransitiveProperty/conclusions001#"
    xml:base="http://www.w3.org/2002/03owlt/TransitiveProperty/conclusions001" >

    <rdf:Description rdf:about="premises001#Ghent">
        <first:path rdf:resource="premises001#Amsterdam"/>
    </rdf:Description>

</rdf:RDF>
first:Ghent first:path first:Amsterdam .

7.1.7. owl:allValuesFrom

Lite FullPositive Entailment Test:001
Description: (informative) <allValuesFrom/Manifest001#test>
A simple example.
N3 format is informative.
LitePremises: <allValuesFrom/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/allValuesFrom/premises001#"
    xml:base="http://www.w3.org/2002/03owlt/allValuesFrom/premises001" >
    <owl:Class rdf:ID="r">
      <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="#p"/>
            <owl:allValuesFrom rdf:resource="#c"/>
        </owl:Restriction>
      </rdfs:subClassOf>
    </owl:Class>
    <owl:ObjectProperty rdf:ID="p"/>
    <owl:Class rdf:ID="c"/>
    <first:r rdf:ID="i">
       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
       <first:p>
         <owl:Thing rdf:ID="o" />
       </first:p>
    </first:r>
</rdf:RDF>
first:r rdf:type owl:Class .
_:a rdf:type owl:Restriction .
_:a owl:onProperty first:p .
_:a owl:allValuesFrom first:c .
first:r rdfs:subClassOf _:a .
first:p rdf:type owl:ObjectProperty .
first:c rdf:type owl:Class .
first:i rdf:type first:r .
first:i rdf:type owl:Thing .
first:o rdf:type owl:Thing .
first:i first:p first:o .
LiteConclusions: <allValuesFrom/conclusions001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:first="http://www.w3.org/2002/03owlt/allValuesFrom/premises001#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/allValuesFrom/conclusions001" >
    <first:c rdf:about="premises001#o">
       <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
    </first:c>
    <owl:Class rdf:about="premises001#c"/>
</rdf:RDF>
first:o rdf:type first:c .
first:o rdf:type owl:Thing .
first:c rdf:type owl:Class .

Lite FullNegative Entailment Test:002
Description: (informative) <allValuesFrom/Manifest002#test>
Another simple example; contrast with owl:someValuesFrom.
N3 format is informative.
LitePremises: <allValuesFrom/premises002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/allValuesFrom/premises002#"
    xml:base="http://www.w3.org/2002/03owlt/allValuesFrom/premises002" >
    <owl:Class rdf:ID="r">
      <rdfs:subClassOf>
        <owl:Restriction>
            <owl:onProperty rdf:resource="#p"/>
            <owl:allValuesFrom rdf:resource="#c"/>
        </owl:Restriction>
      </rdfs:subClassOf>
    </owl:Class>
    <owl:ObjectProperty rdf:ID="p"/>

    <owl:Class rdf:ID="c"/>
    <first:r rdf:ID="i">
      <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
    </first:r>
</rdf:RDF>
first:r rdf:type owl:Class .
_:a rdf:type owl:Restriction .
_:a owl:onProperty first:p .
_:a owl:allValuesFrom first:c .
first:r rdfs:subClassOf _:a .
first:p rdf:type owl:ObjectProperty .
first:c rdf:type owl:Class .
first:i rdf:type first:r .
first:i rdf:type owl:Thing .
LiteConclusions: <allValuesFrom/nonconclusions002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/allValuesFrom/premises002#"
    xmlns:second="http://www.w3.org/2002/03owlt/allValuesFrom/nonconclusions002#"
    xml:base="http://www.w3.org/2002/03owlt/allValuesFrom/nonconclusions002" >
    <owl:Thing rdf:about="premises002#i">
        <first:p>
           <first:c rdf:nodeID="o" />
         </first:p>
    </owl:Thing>
    <owl:Thing rdf:nodeID="o" />
    <owl:ObjectProperty rdf:about="premises002#p"/>
    <owl:Class rdf:about="premises002#c"/>
</rdf:RDF>
first:i rdf:type owl:Thing .
_:a rdf:type first:c .
first:i first:p _:a .
_:a rdf:type owl:Thing .
first:p rdf:type owl:ObjectProperty .
first:c rdf:type owl:Class .

7.1.8. owl:cardinality

Lite FullPositive Entailment Test:001
Description: (informative) <cardinality/Manifest001#test>
An owl:cardinality constraint is simply shorthand for a pair of owl:minCardinality and owl:maxCardinality constraints.
N3 format is informative.
LitePremises: <cardinality/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/cardinality/premises001" >
    <owl:Class rdf:ID="c">
      <rdfs:subClassOf>
         <owl:Restriction>
            <owl:onProperty rdf:resource="#p"/>
            <owl:cardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
            >1</owl:cardinality>
         </owl:Restriction>
      </rdfs:subClassOf>
    </owl:Class>
    <owl:ObjectProperty rdf:ID="p"/>
</rdf:RDF>
first:c rdf:type owl:Class .
_:a rdf:type owl:Restriction .
_:a owl:onProperty first:p .
_:a owl:cardinality "1"^^xsd:nonNegativeInteger  .
first:c rdfs:subClassOf _:a .
first:p rdf:type owl:ObjectProperty .
LiteConclusions: <cardinality/conclusions001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/cardinality/conclusions001" >
    <owl:Class rdf:about="premises001#c">
      <rdfs:subClassOf>
        <owl:Restriction>
          <owl:onProperty rdf:resource="premises001#p"/>
          <owl:maxCardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
          >1</owl:maxCardinality>
        </owl:Restriction>
      </rdfs:subClassOf>
      <rdfs:subClassOf>
        <owl:Restriction>
          <owl:onProperty rdf:resource="premises001#p"/>
          <owl:minCardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
           >1</owl:minCardinality>
         </owl:Restriction>
       </rdfs:subClassOf>
    </owl:Class>
    <owl:ObjectProperty rdf:about="premises001#p"/>
</rdf:RDF>
first:c rdf:type owl:Class .
_:a rdf:type owl:Restriction .
_:a owl:onProperty first:p .
_:a owl:maxCardinality "1"^^xsd:nonNegativeInteger  .
first:c rdfs:subClassOf _:a .
_:c rdf:type owl:Restriction .
_:c owl:onProperty first:p .
_:c owl:minCardinality "1"^^xsd:nonNegativeInteger  .
first:c rdfs:subClassOf _:c .
first:p rdf:type owl:ObjectProperty .

Lite FullPositive Entailment Test:002
Description: (informative) <cardinality/Manifest002#test>
An owl:cardinality constraint is simply shorthand for a pair of owl:minCardinality and owl:maxCardinality constraints.
N3 format is informative.
LitePremises: <cardinality/premises002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/cardinality/premises002" >    
    <owl:Class rdf:about="conclusions002#c">
      <rdfs:subClassOf>
        <owl:Restriction>
          <owl:onProperty rdf:resource="conclusions002#p"/>
          <owl:maxCardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
          >1</owl:maxCardinality>
        </owl:Restriction>
      </rdfs:subClassOf>
      <rdfs:subClassOf>
        <owl:Restriction>
          <owl:onProperty rdf:resource="conclusions002#p"/>
          <owl:minCardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
          >1</owl:minCardinality>
        </owl:Restriction>
       </rdfs:subClassOf>
     </owl:Class>
     <owl:ObjectProperty rdf:about="conclusions002#p"/>
</rdf:RDF>
second:c rdf:type owl:Class .
_:a rdf:type owl:Restriction .
_:a owl:onProperty second:p .
_:a owl:maxCardinality "1"^^xsd:nonNegativeInteger  .
second:c rdfs:subClassOf _:a .
_:c rdf:type owl:Restriction .
_:c owl:onProperty second:p .
_:c owl:minCardinality "1"^^xsd:nonNegativeInteger  .
second:c rdfs:subClassOf _:c .
second:p rdf:type owl:ObjectProperty .
LiteConclusions: <cardinality/conclusions002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/cardinality/conclusions002" >
    <owl:Class rdf:ID="c">
      <rdfs:subClassOf>
        <owl:Restriction>
          <owl:onProperty rdf:resource="#p"/>
          <owl:cardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
          >1</owl:cardinality>
        </owl:Restriction>
      </rdfs:subClassOf>
    </owl:Class>
    <owl:ObjectProperty rdf:ID="p"/>
</rdf:RDF>
second:c rdf:type owl:Class .
_:a rdf:type owl:Restriction .
_:a owl:onProperty second:p .
_:a owl:cardinality "1"^^xsd:nonNegativeInteger  .
second:c rdfs:subClassOf _:a .
second:p rdf:type owl:ObjectProperty .

DL FullPositive Entailment Test:003
Description: (informative) <cardinality/Manifest003#test>
An owl:cardinality constraint is simply shorthand for a pair of owl:minCardinality and owl:maxCardinality constraints.
N3 format is informative.
DLPremises: <cardinality/premises003> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/cardinality/premises003" >
    <owl:Class rdf:ID="c">
      <rdfs:subClassOf>
        <owl:Restriction>
          <owl:onProperty rdf:resource="#p"/>
          <owl:cardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
          >2</owl:cardinality>
        </owl:Restriction>
      </rdfs:subClassOf>
    </owl:Class>
    <owl:ObjectProperty rdf:ID="p"/>
</rdf:RDF>
first:c rdf:type owl:Class .
_:a rdf:type owl:Restriction .
_:a owl:onProperty first:p .
_:a owl:cardinality "2"^^xsd:nonNegativeInteger  .
first:c rdfs:subClassOf _:a .
first:p rdf:type owl:ObjectProperty .
DLConclusions: <cardinality/conclusions003> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/cardinality/conclusions003" >
    <owl:Class rdf:about="premises003#c">
      <rdfs:subClassOf>
        <owl:Restriction>
          <owl:onProperty rdf:resource="premises003#p"/>
          <owl:maxCardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
          >2</owl:maxCardinality>
        </owl:Restriction>
      </rdfs:subClassOf>
      <rdfs:subClassOf>
        <owl:Restriction>
          <owl:onProperty rdf:resource="premises003#p"/>
          <owl:minCardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
          >2</owl:minCardinality>
        </owl:Restriction>
      </rdfs:subClassOf>
    </owl:Class>
    <owl:ObjectProperty rdf:about="premises003#p"/>
</rdf:RDF>
first:c rdf:type owl:Class .
_:a rdf:type owl:Restriction .
_:a owl:onProperty first:p .
_:a owl:maxCardinality "2"^^xsd:nonNegativeInteger  .
first:c rdfs:subClassOf _:a .
_:c rdf:type owl:Restriction .
_:c owl:onProperty first:p .
_:c owl:minCardinality "2"^^xsd:nonNegativeInteger  .
first:c rdfs:subClassOf _:c .
first:p rdf:type owl:ObjectProperty .

DL FullPositive Entailment Test:004
Description: (informative) <cardinality/Manifest004#test>
An owl:cardinality constraint is simply shorthand for a pair of owl:minCardinality and owl:maxCardinality constraints.
N3 format is informative.
DLPremises: <cardinality/premises004> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/cardinality/premises004" >    
    <owl:Class rdf:about="conclusions004#c">
      <rdfs:subClassOf>
          <owl:Class>
             <owl:intersectionOf rdf:parseType="Collection">
                <owl:Restriction>
                   <owl:onProperty rdf:resource="conclusions004#p"/>
                   <owl:maxCardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
                   >2</owl:maxCardinality>
                </owl:Restriction>
                <owl:Restriction>
                   <owl:onProperty rdf:resource="conclusions004#p"/>
                   <owl:minCardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
                   >2</owl:minCardinality>
                </owl:Restriction>
              </owl:intersectionOf>
           </owl:Class>
       </rdfs:subClassOf>
     </owl:Class>
     <owl:ObjectProperty rdf:about="conclusions004#p"/>
</rdf:RDF>
second:c rdf:type owl:Class .
_:a rdf:type owl:Class .
_:c rdf:type owl:Restriction .
_:c owl:onProperty second:p .
_:c owl:maxCardinality "2"^^xsd:nonNegativeInteger  .
_:e rdf:type owl:Restriction .
_:e owl:onProperty second:p .
_:e owl:minCardinality "2"^^xsd:nonNegativeInteger  .
_:g rdf:first _:e .
_:g rdf:rest rdf:nil .
_:i rdf:first _:c .
_:i rdf:rest _:g .
_:a owl:intersectionOf _:i .
second:c rdfs:subClassOf _:a .
second:p rdf:type owl:ObjectProperty .
DLConclusions: <cardinality/conclusions004> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/cardinality/conclusions004" >
    <owl:Class rdf:ID="c">
      <rdfs:subClassOf>
          <owl:Class>
             <owl:intersectionOf rdf:parseType="Collection">
                <owl:Restriction>
                   <owl:onProperty rdf:resource="#p"/>
                   <owl:cardinality
 rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
                   >2</owl:cardinality>
                </owl:Restriction>
              </owl:intersectionOf>
           </owl:Class>
       </rdfs:subClassOf>
     </owl:Class>
     <owl:ObjectProperty rdf:ID="p"/>
</rdf:RDF>
second:c rdf:type owl:Class .
_:a rdf:type owl:Class .
_:c rdf:type owl:Restriction .
_:c owl:onProperty second:p .
_:c owl:cardinality "2"^^xsd:nonNegativeInteger  .
_:e rdf:first _:c .
_:e rdf:rest rdf:nil .
_:a owl:intersectionOf _:e .
second:c rdfs:subClassOf _:a .
second:p rdf:type owl:ObjectProperty .

7.1.9. owl:complementOf

FullPositive Entailment Test:001
Description: (informative) <complementOf/Manifest001#test>
complementOf is a SymmetricProperty.
N3 format is informative.
FullPremises: <complementOf/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/complementOf/premises001#"
    xmlns:second="http://www.w3.org/2002/03owlt/complementOf/conclusions001#"
    xml:base="http://www.w3.org/2002/03owlt/complementOf/premises001" >

    <rdf:Description rdf:about="premises001#A">
        <owl:complementOf rdf:resource="premises001#B"/>
    </rdf:Description>

</rdf:RDF>
first:A owl:complementOf first:B .
FullConclusions: <complementOf/conclusions001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/complementOf/premises001#"
    xmlns:second="http://www.w3.org/2002/03owlt/complementOf/conclusions001#"
    xml:base="http://www.w3.org/2002/03owlt/complementOf/conclusions001" >

    <rdf:Description rdf:about="premises001#B">
        <owl:complementOf rdf:resource="premises001#A"/>
    </rdf:Description>

</rdf:RDF>
first:B owl:complementOf first:A .

7.1.10. owl:differentFrom

FullPositive Entailment Test:001
Description: (informative) <differentFrom/Manifest001#test>
differentFrom is a SymmetricProperty.
N3 format is informative.
FullPremises: <differentFrom/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/differentFrom/premises001#"
    xmlns:second="http://www.w3.org/2002/03owlt/differentFrom/conclusions001#"
    xml:base="http://www.w3.org/2002/03owlt/differentFrom/premises001" >

    <rdf:Description rdf:about="premises001#a">
        <owl:differentFrom rdf:resource="premises001#b"/>
    </rdf:Description>

</rdf:RDF>
first:a owl:differentFrom first:b .
FullConclusions: <differentFrom/conclusions001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/differentFrom/premises001#"
    xmlns:second="http://www.w3.org/2002/03owlt/differentFrom/conclusions001#"
    xml:base="http://www.w3.org/2002/03owlt/differentFrom/conclusions001" >

    <rdf:Description rdf:about="premises001#b">
        <owl:differentFrom rdf:resource="premises001#a"/>
    </rdf:Description>

</rdf:RDF>
first:b owl:differentFrom first:a .

FullPositive Entailment Test:002
Description: (informative) <differentFrom/Manifest002#test>
using distinctMembers to derive differentFrom
N3 format is informative.
FullPremises: <differentFrom/premises002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/differentFrom/premises002#"
    xml:base="http://www.w3.org/2002/03owlt/differentFrom/premises002" >

    <owl:AllDifferent> 
      <owl:distinctMembers rdf:parseType="Collection">
        <first:Person rdf:about="#Fred" />
        <first:Person rdf:about="#Wilma" />
        <first:Person rdf:about="#Barney" />
        <first:Person rdf:about="#Betty" />
      </owl:distinctMembers>
    </owl:AllDifferent> 

</rdf:RDF>
_:a rdf:type owl:AllDifferent .
first:Fred rdf:type first:Person .
first:Wilma rdf:type first:Person .
first:Barney rdf:type first:Person .
first:Betty rdf:type first:Person .
_:c rdf:first first:Betty .
_:c rdf:rest rdf:nil .
_:e rdf:first first:Barney .
_:e rdf:rest _:c .
_:g rdf:first first:Wilma .
_:g rdf:rest _:e .
_:i rdf:first first:Fred .
_:i rdf:rest _:g .
_:a owl:distinctMembers _:i .
FullConclusions: <differentFrom/conclusions002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/differentFrom/premises002#"
    xml:base="http://www.w3.org/2002/03owlt/differentFrom/conclusions002" >

    <rdf:Description rdf:about="premises002#Barney">
        <owl:differentFrom rdf:resource="premises002#Wilma"/>
    </rdf:Description>

</rdf:RDF>
first:Barney owl:differentFrom first:Wilma .

7.1.11. owl:disjointWith

DL FullPositive Entailment Test:001
Description: (informative) <disjointWith/Manifest001#test>
Disjoint classes have different members.
N3 format is informative.
DLPremises: <disjointWith/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:first="http://www.w3.org/2002/03owlt/disjointWith/premises001#"
    xml:base="http://www.w3.org/2002/03owlt/disjointWith/premises001" >
   <owl:Class rdf:ID="A">
      <owl:disjointWith>
           <owl:Class rdf:ID="B"/>
      </owl:disjointWith>
   </owl:Class>
   <first:A rdf:ID="a"/>
   <owl:Thing rdf:about="#a"/>
   <first:B rdf:ID="b"/>
   <owl:Thing rdf:about="#b"/>
</rdf:RDF>
first:A rdf:type owl:Class .
first:B rdf:type owl:Class .
first:A owl:disjointWith first:B .
first:a rdf:type first:A .
first:a rdf:type owl:Thing .
first:b rdf:type first:B .
first:b rdf:type owl:Thing .
LiteConclusions: <disjointWith/conclusions001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/disjointWith/premises001#"
    xml:base="http://www.w3.org/2002/03owlt/disjointWith/conclusions001" >
    <owl:Thing rdf:about="premises001#a">
       <owl:differentFrom>
          <owl:Thing rdf:about="premises001#b"/>
       </owl:differentFrom>
    </owl:Thing>
</rdf:RDF>
first:a rdf:type owl:Thing .
first:b rdf:type owl:Thing .
first:a owl:differentFrom first:b .

FullPositive Entailment Test:002
Description: (informative) <disjointWith/Manifest002#test>
Disjoint classes have different members.
N3 format is informative.
FullPremises: <disjointWith/premises002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/disjointWith/premises002#"
    xml:base="http://www.w3.org/2002/03owlt/disjointWith/premises002" >

   <rdf:Description rdf:ID="A">
      <owl:disjointWith>
           <rdf:Description rdf:ID="B"/>
      </owl:disjointWith>
   </rdf:Description>
   <first:A rdf:ID="a"/>
   <first:B rdf:ID="b"/>

</rdf:RDF>
first:A owl:disjointWith first:B .
first:a rdf:type first:A .
first:b rdf:type first:B .
FullConclusions: <disjointWith/conclusions002> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/disjointWith/conclusions002" >
    <rdf:Description rdf:about="premises002#a">
       <owl:differentFrom rdf:resource="premises002#b"/>
    </rdf:Description>
</rdf:RDF>
first:a owl:differentFrom first:b .

7.1.12. owl:distinctMembers

FullPositive Entailment Test:001
Description: (informative) <distinctMembers/Manifest001#test>
using distinctMembers to derive differentFrom
N3 format is informative.
FullPremises: <distinctMembers/premises001> 
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:first="http://www.w3.org/2002/03owlt/distinctMembers/premises001#"
    xml:base="http://www.w3.org/2002/03owlt/distinctMembers/premises001" >

    <owl:AllDifferent> 
      <owl:distinctMembers rdf:parseType="Collection">
        <first:Person rdf:about="#Fred" />
        <first:Person rdf:about="#Wilma" />
        <first:Person rdf:about="#Barney" />
        <first:Person rdf:about="#Betty" />
      </owl:distinctMembers>
    </owl:AllDifferent> 

</rdf:RDF>
_:a rdf:type owl:AllDifferent .
first:Fred rdf:type first:Person .
first:Wilma rdf:type first:Person .
first:Barney rdf:type first:Person .
first:Betty rdf:type first:Person .
_:c rdf:first first:Betty .
_:c rdf:rest rdf:nil .
_:e rdf:first first:Barney .
_:e rdf:rest _:c .
_:g rdf:first first:Wilma .
_:g rdf:rest _:e .
_:i rdf:first first:Fred .
_:i rdf:rest _:g .
_:a owl:distinctMembers _:i .