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 (this version), large, and extra large. 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.
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.
See the normative compound HTML document for document status.
owl:AllDifferentowl:FunctionalPropertyowl:InverseFunctionalPropertyowl:Nothingowl:SymmetricPropertyowl:TransitivePropertyowl:allValuesFromowl:cardinalityowl:complementOfowl:differentFromowl:disjointWithowl:distinctMembersowl:equivalentClassowl:equivalentPropertyowl:importsowl:intersectionOfowl:inverseOfowl:maxCardinalityowl:oneOfowl:someValuesFromowl:unionOfAs 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 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.
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.
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?]]
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.
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.
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.
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.
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).
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.
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.
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.
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).
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).
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).
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.
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.
An OWL Lite or OWL DL document D is 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 equivalent to D, in which O has a separated vocabulary; (see [OWL Semantics and Abstract Syntax]).
An OWL Full document D is 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 equivalent to D.
This section uses the words MUST, MUST NOT, SHOULD and MAY as in [RFC 2119].
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:
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.
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 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.
An OWL DL consistency checker is an OWL consistency checker that takes an OWL DL document as input.
An OWL Full consistency checker is an OWL consistency checker that takes an OWL Full document as input.
A complete OWL Lite consistency checker is an OWL Lite consistency checker that is complete and terminating.
Note: Every OWL Full consistency checker is also an OWL DL consistency checker. Every OWL DL consistency checker is also an OWL Lite consistency checker. The different levels are intended to be used to indicate the intended domain of a 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.
An OWL syntax checker when presented with any of the test files must return the indicated result.
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.
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, OWL DL or OWL Lite 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.
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:NotOwlFeatureTestotest:PositiveEntailmentTestotest:NegativeEntailmentTestotest:TrueTestotest:OWLforOWLTestotest:ConsistencyTestotest:InconsistencyTestotest:ImportEntailmentTestotest:ImportLevelTestWhere 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 level associated with both files and tests
are given with the otest:level property.
The value for each document and test is one of
otest:Full, otest:DL,
otest:Lite or otest:Other (documents only).
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.
owl:AllDifferent| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<AllDifferent/Manifest001#test>
|
|||
using AllDifferent to derive differentFrom | |||
| Full | Premises:
<AllDifferent/premises001>
| ||
| Full | Conclusions:
<AllDifferent/conclusions001>
| ||
owl:FunctionalProperty| Full | Positive 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. | |||
| Full | Premises:
<FunctionalProperty/premises001>
| ||
| Full | Conclusions:
<FunctionalProperty/conclusions001>
| ||
| Full | Positive 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. | |||
| Full | Premises:
<FunctionalProperty/premises002>
| ||
| Full | Conclusions:
<FunctionalProperty/conclusions002>
| ||
| Full | Positive Entailment Test: | 003 | |
|---|---|---|---|
Description:
(informative)
<FunctionalProperty/Manifest003#test>
|
|||
If prop is an owl:FunctionalProperty,
then its inverse is an owl:InverseFunctionalProperty. | |||
| Full | Premises:
<FunctionalProperty/premises003>
| ||
| Lite | Conclusions:
<FunctionalProperty/conclusions003>
| ||
| Full | Positive 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. | |||
| Full | Premises:
<FunctionalProperty/premises004>
| ||
| Full | Conclusions:
<FunctionalProperty/conclusions004>
| ||
owl:InverseFunctionalProperty| Full | Positive 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. | |||
| Full | Premises:
<InverseFunctionalProperty/premises001>
| ||
| Full | Conclusions:
<InverseFunctionalProperty/conclusions001>
| ||
| Full | Positive 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. | |||
| Full | Premises:
<InverseFunctionalProperty/premises002>
| ||
| Full | Conclusions:
<InverseFunctionalProperty/conclusions002>
| ||
| Full | Positive Entailment Test: | 003 | |
|---|---|---|---|
Description:
(informative)
<InverseFunctionalProperty/Manifest003#test>
|
|||
If prop is an owl:InverseFunctionalProperty,
then its inverse is an owl:FunctionalProperty. | |||
| Full | Premises:
<InverseFunctionalProperty/premises003>
| ||
| Full | Conclusions:
<InverseFunctionalProperty/conclusions003>
| ||
| Full | Positive 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. | |||
| Full | Premises:
<InverseFunctionalProperty/premises004>
| ||
| Lite | Conclusions:
<InverseFunctionalProperty/conclusions004>
| ||
owl:Nothing| DL | OWL described in OWL. | 002 | |
|---|---|---|---|
Description:
(informative)
<Nothing/Manifest002#test>
|
|||
An empty owl:Class has the same class extension as owl:Nothing. | |||
| DL | True:
<Nothing/conclusions002>
| ||
owl:SymmetricProperty| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<SymmetricProperty/Manifest001#test>
|
|||
| A simple illustration of symmetric properties. | |||
| Full | Premises:
<SymmetricProperty/premises001>
| ||
| Full | Conclusions:
<SymmetricProperty/conclusions001>
| ||
owl:TransitiveProperty| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<TransitiveProperty/Manifest001#test>
|
|||
| A simple illustration of transitivity. | |||
| Full | Premises:
<TransitiveProperty/premises001>
| ||
| Full | Conclusions:
<TransitiveProperty/conclusions001>
| ||
owl:allValuesFrom| Lite | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<allValuesFrom/Manifest001#test>
|
|||
| A simple example. | |||
| Lite | Premises:
<allValuesFrom/premises001>
| ||
| Lite | Conclusions:
<allValuesFrom/conclusions001>
| ||
| Lite | Negative Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<allValuesFrom/Manifest002#test>
|
|||
Another simple example; contrast with owl:someValuesFrom. | |||
| Lite | Premises:
<allValuesFrom/premises002>
| ||
| Lite | Conclusions:
<allValuesFrom/nonconclusions002>
| ||
owl:cardinality| Lite | Positive 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. | |||
| Lite | Premises:
<cardinality/premises001>
| ||
| Lite | Conclusions:
<cardinality/conclusions001>
| ||
| Lite | Positive 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. | |||
| Lite | Premises:
<cardinality/premises002>
| ||
| Lite | Conclusions:
<cardinality/conclusions002>
| ||
| DL | Positive 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. | |||
| DL | Premises:
<cardinality/premises003>
| ||
| DL | Conclusions:
<cardinality/conclusions003>
| ||
| DL | Positive 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. | |||
| DL | Premises:
<cardinality/premises004>
| ||
| DL | Conclusions:
<cardinality/conclusions004>
| ||
owl:complementOf| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<complementOf/Manifest001#test>
|
|||
complementOf is a SymmetricProperty. | |||
| Full | Premises:
<complementOf/premises001>
| ||
| Full | Conclusions:
<complementOf/conclusions001>
| ||
owl:differentFrom| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<differentFrom/Manifest001#test>
|
|||
differentFrom is a SymmetricProperty. | |||
| Full | Premises:
<differentFrom/premises001>
| ||
| Full | Conclusions:
<differentFrom/conclusions001>
| ||
| Full | Positive Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<differentFrom/Manifest002#test>
|
|||
using distinctMembers to derive differentFrom | |||
| Full | Premises:
<differentFrom/premises002>
| ||
| Full | Conclusions:
<differentFrom/conclusions002>
| ||
owl:disjointWith| DL | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<disjointWith/Manifest001#test>
|
|||
| Disjoint classes have different members. | |||
| DL | Premises:
<disjointWith/premises001>
| ||
| Lite | Conclusions:
<disjointWith/conclusions001>
| ||
| Full | Positive Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<disjointWith/Manifest002#test>
|
|||
| Disjoint classes have different members. | |||
| Full | Premises:
<disjointWith/premises002>
| ||
| Full | Conclusions:
<disjointWith/conclusions002>
| ||
owl:distinctMembers| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<distinctMembers/Manifest001#test>
|
|||
using distinctMembers to derive differentFrom | |||
| Full | Premises:
<distinctMembers/premises001>
| ||
| Full | Conclusions:
<distinctMembers/conclusions001>
| ||
owl:equivalentClass| Lite | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<equivalentClass/Manifest001#test>
|
|||
| Two classes may have the same class extension. | |||
| Lite | Premises:
<equivalentClass/premises001>
| ||
| Lite | Conclusions:
<equivalentClass/conclusions001>
| ||
| Lite | Positive Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<equivalentClass/Manifest002#test>
|
|||
| Two classes may be different names for the same set of individuals | |||
| Lite | Premises:
<equivalentClass/premises002>
| ||
| Lite | Conclusions:
<equivalentClass/conclusions002>
| ||
| Lite | Positive Entailment Test: | 003 | |
|---|---|---|---|
Description:
(informative)
<equivalentClass/Manifest003#test>
|
|||
| Two classes may be different names for the same set of individuals | |||
| Lite | Premises:
<equivalentClass/premises003>
| ||
| Lite | Conclusions:
<equivalentClass/conclusions003>
| ||
| Lite | Positive Entailment Test: | 004 | |
|---|---|---|---|
Description:
(informative)
<equivalentClass/Manifest004#test>
|
|||
| Two classes with the same complete description are equivalent. | |||
| Lite | Premises:
<equivalentClass/premises004>
| ||
| Lite | Conclusions:
<equivalentClass/conclusions004>
| ||
| Lite | Negative Entailment Test: | 005 | |
|---|---|---|---|
Description:
(informative)
<equivalentClass/Manifest005#test>
|
|||
| Two classes with the same partial description are not equivalent. | |||
| Lite | Premises:
<equivalentClass/premises005>
| ||
| Lite | Conclusions:
<equivalentClass/nonconclusions005>
| ||
| DL | Positive Entailment Test: | 006 | |
|---|---|---|---|
Description:
(informative)
<equivalentClass/Manifest006#test>
|
|||
| De Morgan's law. | |||
| Lite | Premises:
<equivalentClass/premises006>
| ||
| DL | Conclusions:
<equivalentClass/conclusions006>
| ||
owl:equivalentProperty| Lite | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<equivalentProperty/Manifest001#test>
|
|||
hasLeader may be stated to be the owl:equivalentProperty of hasHead. | |||
| Lite | Premises:
<equivalentProperty/premises001>
| ||
| Lite | Conclusions:
<equivalentProperty/conclusions001>
| ||
| Lite | Positive Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<equivalentProperty/Manifest002#test>
|
|||
A reasoner can also deduce that hasLeader is a subProperty of hasHead and hasHead is a subProperty of hasLeader. | |||
| Lite | Premises:
<equivalentProperty/premises002>
| ||
| Lite | Conclusions:
<equivalentProperty/conclusions002>
| ||
| Lite | Positive Entailment Test: | 003 | |
|---|---|---|---|
Description:
(informative)
<equivalentProperty/Manifest003#test>
|
|||
| The inverse entailment of test 002 also holds. | |||
| Lite | Premises:
<equivalentProperty/premises003>
| ||
| Lite | Conclusions:
<equivalentProperty/conclusions003>
| ||
| DL | Positive Entailment Test: | 004 | |
|---|---|---|---|
Description:
(informative)
<equivalentProperty/Manifest004#test>
|
|||
If p and q have the same property extension then p equivalentProperty q. | |||
| DL | Premises:
<equivalentProperty/premises004>
| ||
| Lite | Conclusions:
<equivalentProperty/conclusions004>
| ||
| Full | Positive Entailment Test: | 005 | |
|---|---|---|---|
Description:
(informative)
<equivalentProperty/Manifest005#test>
|
|||
If p and q have the same property extension then p owl:equivalentProperty q. | |||
| Full | Premises:
<equivalentProperty/premises005>
| ||
| Full | Conclusions:
<equivalentProperty/conclusions005>
| ||
| Full | Positive Entailment Test: | 006 | |
|---|---|---|---|
Description:
(informative)
<equivalentProperty/Manifest006#test>
|
|||
hasLeader may be stated to be the owl:equivalentProperty of hasHead. | |||
| Full | Premises:
<equivalentProperty/premises006>
| ||
| Full | Conclusions:
<equivalentProperty/conclusions006>
| ||
owl:imports| Full | Import Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<imports/Manifest001#test>
|
|||
| If a document imports another document, then it entails anything that is entailed by the conjunction of the two documents. | |||
| Full | Premises:
<imports/premises001>
| ||
| Lite | Imported Premises
<imports/support001-A>
| ||
| Full | Conclusions:
<imports/conclusions001>
| ||
| Full | Negative Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<imports/Manifest002#test>
|
|||
| If a premise document uses a namespace but does not import the document corresponding to the namespace, then the premises do not necessarily entail anything that is entailed by the conjunction of the two documents. | |||
| Full | Premises:
<imports/premises002>
| ||
| Full | Conclusions:
<imports/nonconclusions002>
| ||
| Full | Import Entailment Test: | 003 | |
|---|---|---|---|
Description:
(informative)
<imports/Manifest003#test>
|
|||
| If a document imports a document which in turn imports a third document, then it entails anything which is entailed by the conjunction of the statements from the three documents. That is, imports is transitive. | |||
| Full | Premises:
<imports/premises003>
| ||
| Lite | Imported Premises
<imports/support003-A>
| ||
| Lite | Imported Premises
<imports/support003-B>
| ||
| Full | Conclusions:
<imports/conclusions003>
| ||
| Full | Imports Level Test: | 004 | |
|---|---|---|---|
Description:
(informative)
<imports/Manifest004#test>
|
|||
| Importing OWL Full documents may change the level of OWL Lite or OWL DL documents. | |||
| Full | Imported document:
<imports/imports004>
| ||
| Full | Main document:
<imports/main004>
| ||
| DL | Imports Level Test: | 005 | |
|---|---|---|---|
Description:
(informative)
<imports/Manifest005#test>
|
|||
| If an OWL Lite document imports an OWL DL document then it becomes OWL DL. | |||
| DL | Imported document:
<imports/imports005>
| ||
| DL | Main document:
<imports/main005>
| ||
| Lite | Imports Level Test: | 006 | |
|---|---|---|---|
Description:
(informative)
<imports/Manifest006#test>
|
|||
| The type declarations required by semantic layering can be imported into an OWL Lite or OWL DL file. | |||
| Lite | Imported document:
<imports/imports006>
| ||
| Lite | Main document:
<imports/main006>
| ||
| Lite | Imports Level Test: | 007 | |
|---|---|---|---|
Description:
(informative)
<imports/Manifest007#test>
|
|||
| The type declarations required by semantic layering can be imported into an OWL Lite or OWL DL file. | |||
| Lite | Imported document:
<imports/imports007>
| ||
| Lite | Main document:
<imports/main007>
| ||
| Lite | Imports Level Test: | 008 | |
|---|---|---|---|
Description:
(informative)
<imports/Manifest008#test>
|
|||
| It is often possible to import an ordinary RDFS document unchanged into an OWL Lite document. Aditional type declarations may be needed in the importing document. | |||
| Full | Imported document:
<imports/imports008>
| ||
| Lite | Main document:
<imports/main008>
| ||
owl:intersectionOf| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<intersectionOf/Manifest001#test>
|
|||
The order of the classes in an intersectionOf
construct is unimportant. | |||
| Full | Premises:
<intersectionOf/premises001>
| ||
| Full | Conclusions:
<intersectionOf/conclusions001>
| ||
owl:inverseOf| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<inverseOf/Manifest001#test>
|
|||
If the pair (x,y) is an instance of P, than the pair (y,x) is
an instance of the named property. | |||
| Full | Premises:
<inverseOf/premises001>
| ||
| Full | Conclusions:
<inverseOf/conclusions001>
| ||
owl:maxCardinality| Full | Inconsistent document. | 001 | |
|---|---|---|---|
Description:
(informative)
<maxCardinality/Manifest001#test>
|
|||
| A property with maximum cardinality of two cannot take three distinct values on some subject node. | |||
| Full | Inconsistent:
<maxCardinality/inconsistent001>
| ||
| Full | Inconsistent document. | 002 | |
|---|---|---|---|
Description:
(informative)
<maxCardinality/Manifest002#test>
|
|||
| A property with maximum cardinality of two cannot take three distinct values on some subject node. In this example, one of the three values is implicit. | |||
| Full | Inconsistent:
<maxCardinality/inconsistent002>
| ||
owl:oneOf| Full | Consistent document. | 001 | |
|---|---|---|---|
Description:
(informative)
<oneOf/Manifest001#test>
|
|||
oneOf does not indicate that the named
individuals are distinct. Thus a consistent interpretation
of this file is when all the individual names denote the
same individual. | |||
| Full | Consistent:
<oneOf/consistent001>
| ||
| Full | Positive Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<oneOf/Manifest002#test>
|
|||
oneOf describes a class by enumerating its individuals. | |||
| Full | Premises:
<oneOf/premises002>
| ||
| Full | Conclusions:
<oneOf/conclusions002>
| ||
| Full | Positive Entailment Test: | 003 | |
|---|---|---|---|
Description:
(informative)
<oneOf/Manifest003#test>
|
|||
The order of the instances in an owl:oneOf
construct is unimportant. | |||
| Full | Premises:
<oneOf/premises003>
| ||
| Full | Conclusions:
<oneOf/conclusions003>
| ||
owl:someValuesFrom| Full | Negative Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<someValuesFrom/Manifest002#test>
|
|||
A simple example showing how owl:someValuesFrom differs from owl:allValuesFrom. | |||
| Full | Premises:
<someValuesFrom/premises002>
| ||
| Full | Conclusions:
<someValuesFrom/nonconclusions002>
| ||
owl:unionOf| Full | Positive Entailment Test: | 001 | |
|---|---|---|---|
Description:
(informative)
<unionOf/Manifest001#test>
|
|||
| A union is a superclass of its parts. | |||
| Full | Premises:
<unionOf/premises001>
| ||
| Full | Conclusions:
<unionOf/conclusions001>
| ||
| Full | Positive Entailment Test: | 002 | |
|---|---|---|---|
Description:
(informative)
<unionOf/Manifest002#test>
|
|||
| A union behaves quite like set theoretic union. | |||
| Full | Premises:
<unionOf/premises002>
| ||
| Full | Conclusions:
<unionOf/conclusions002>
| ||
| Lite | Illegal use of OWL namespace. | 001 | |
|---|---|---|---|
Description:
(informative)
<I3.2/Manifest001#test>
|
|||
| The names used in a DAML+OIL qualified cardinality constraint are not defined the OWL namespace. | |||
| Full | Incorrect:
<I3.2/bad001>
| ||
| Lite | Illegal use of OWL namespace. | 002 | |
|---|---|---|---|
Description:
(informative)
<I3.2/Manifest002#test>
|
|||
| The names used in a DAML+OIL qualified max cardinality constraint are not defined the OWL namespace. | |||
| Full | Incorrect:
<I3.2/bad002>
| ||