W3C

Web Ontology Language (OWL)
Reference Version 1.0

Editor's Draft document - no W3C status at this time

This version:
$Id: owl-ref-proposed.html,v 1.112 2003/01/03 04:35:38 mdean Exp $
Latest published version:
http://www.w3.org/TR/owl-ref/
Latest version:
http://www.daml.org/2002/06/webont/owl-ref-proposed
Previous version:
http://www.w3.org/TR/2002/WD-owl-ref-20021112/
Editors:
Mike Dean
Dan Connolly
Frank van Harmelen
James Hendler
Ian Horrocks
Deborah L. McGuinness
Peter F. Patel-Schneider
Lynn Andrea Stein

Abstract

OWL is a semantic markup language for publishing and sharing ontologies on the World Wide Web. OWL is derived from the DAML+OIL Web Ontology Language [DAML+OIL] and builds upon the Resource Description Framework [RDF/XML Syntax].

Status of this document

This Working Draft is the first version of the OWL Web Ontology Language 1.0 specification. The Web Ontology (WebOnt) Working Group expects to update it to reflect changes in requirements until such time as OWL becomes a W3C Recommendation. The working group has not reached consensus on all issues, and has produced an online issues list [OWL Issues] that maintains the current status of all issues being considered. Links to associated issues are highlighted.

Editorial notes to be addressed in future revisions are also highlighted.

Comments on this document should be sent to public-webont-comments@w3.org, a mailing list with a public archive. General discussion of related technology is welcome in www-rdf-logic.

There are no patent disclosures related to this work at the time of this writing.

This is a W3C Working Draft for review by W3C members and other interested parties. It is a draft document and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use W3C Working Drafts as reference materials or to cite them as other than "work in progress." A list of current W3C Recommendations and other technical documents can be found at http://www.w3.org/TR/.

This document has been produced as part of the W3C Semantic Web Activity (Activity Statement) following the procedures set out for the W3C Process. The document has been written by the Web Ontology Working Group. The goals of the Web Ontology working group are discussed in the Web Ontology Working Group charter.

This document is derived from the DAML+OIL (March 2001) Reference Description [DAML+OIL] included in the DAML+OIL submission. The work of the authors, editors, and sponsors of that and predecessor documents is gratefully acknowledged.

Table of contents

  1. Introductory remarks
  2. Language structure
  3. application/owl+xml Media Type Registration

Appendices


1. Introductory remarks

This document gives a systematic, compact and informal description of all the modelling primitives of OWL. We expect this document to serve as a reference guide for users of the OWL language.

An OWL knowledge base is a collection of RDF triples as defined in the RDF/XML Syntax Specification (Revised) [RDF/XML Syntax]. OWL prescribes a specific meaning for triples that use the OWL vocabulary. This document specifies which collections of RDF triples constitute the OWL vocabulary and what the prescribed meaning of such triples is.

Different syntactic forms

As with any set of RDF triples, OWL triples can be represented in many different syntactic forms (as described in the RDF/XML Syntax Specification (Revised) [RDF/XML Syntax]). The current document uses a specific RDF syntactic form for these triples. However, it is also allowed to use any other syntactic RDF form that results in the same underlying set of RDF triples as the syntax used in this document. Such other syntactic forms would then carry exactly the same prescribed meaning as the equivalent syntactic form used in this document. See Syntax Note for an example of this.

Mixing OWL with arbitrary RDF

As stated above, OWL assigns a specific meaning to certain RDF triples. The OWL Abstract Syntax and Semantics [OWL Abstract Syntax] specifies exactly which triples are assigned a specific meaning, and what this meaning is. OWL only provides a semantic interpretation for those parts of an RDF graph that instantiate the schema defined in http://www.w3.org/2002/07/owl. Any additional RDF statements, resulting in additional RDF triples are perfectly allowed, but OWL is silent on the semantic consequences (or lack thereof) of such additional triples. See Mixing Note for an example of this.

2. Language structure

An OWL ontology is made up of several components, some of which are optional, and some of which may be repeated. See the index for a listing of all these components. Throughout this document, OWL constructs will be presented in a structured format, and not as bare RDF triples. This structured RDF format is more natural to read, but, of course, any way of generating the same RDF triples as generated by the structured RDF format is equivalent.

Several components employ lists constructed using the rdf:List, rdf:first, rdf:rest, rdf:nil, and rdf:parseType="Collection" vocabulary [Ed: identify link] recently added to RDF.

An OWL ontology consists of an optional ontology element, followed by zero or more class elements, property elements, and instances.

Ontology elements

An ontology element, owl:Ontology, identifies the containing document and contains

An example Ontology element is:
<owl:Ontology rdf:about="">
  <owl:versionInfo>$Id: owl-ref-proposed.html,v 1.112 2003/01/03 04:35:38 mdean Exp $</versionInfo>
  <rdfs:comment>An example ontology</rdfs:comment>
  <owl:imports rdf:resource="http://www.w3.org/2002/07/owl"/>
</owl:Ontology>

Objects and datatype values

OWL divides the universe into two disjoint parts. One part consists of the values that belong to XML Schema datatypes. This part is called the datatype domain. The other part consists of (individual) objects that are considered to be members of classes described within OWL (or RDF). This part is called the object domain.

OWL is mostly concerned with the creation of classes that describe (or define) part of the object domain. Such classes are called object classes and are elements of owl:Class, a subclass of rdfs:Class. OWL also allows the use of XML Schema datatypes to describe (or define) part of the datatype domain. These datatypes are used within OWL simply by including their URIs within an OWL ontology. They are (implicitly) elements of owl:Datatype. Datatypes are not OWL individual objects. See issue #5.8-Datatypes.

Class elements

A class element, owl:Class, contains (part of) the definition of an object class. A class element refers to a class name (a URI) (we will refer to this class as C) and contains

Notice that the first two elements state necessary but not sufficient conditions for class membership. The final four elements state both necessary and sufficient conditions.

Class expressions

A class expression is the name used in this document for either

Each class expression either refers to a named class, namely the class that is identified by the URI, or implicitly defines an anonymous class, respectively the class that contains exactly the enumerated elements, or the class of all instances which satisfy the property-restriction, or the class that satisfies the boolean combination of such expressions.

Two class names are already predefined, namely the classes owl:Thing and owl:Nothing. Every object is a member of owl:Thing, and no object is a member of owl:Nothing. Consequently, every class is a subclass of owl:Thing and owl:Nothing is a subclass of every class.

Enumerations

An enumeration is a owl:oneOf element, containing a list of the objects that are its instances.
This enables us to define a class by exhaustively enumerating its elements. The class defined by the oneOf element contains exactly the enumerated elements, no more, no less. For example:

<owl:oneOf rdf:parseType="Collection">
  <owl:Thing rdf:about="#Eurasia"/>
  <owl:Thing rdf:about="#Africa"/>
  <owl:Thing rdf:about="#North_America"/>
  <owl:Thing rdf:about="#South_America"/>
  <owl:Thing rdf:about="#Australia"/>
  <owl:Thing rdf:about="#Antarctica"/>
</oneOf>

Property restrictions

A property restriction is a special kind of class expression. It implicitly defines an anonymous class, namely the class of all objects that satisfy the restriction. There are two kinds of restrictions. The first kind, ObjectRestriction, works on object properties, i.e., properties that relate objects to other objects. The second kind, DatatypeRestriction, works on datatype properties, i.e., properties that relate objects to datatype values. Both kinds of restrictions are created using the same syntax, with the usual difference being whether a class element or a datatype reference is used. It is also possible to create restrictions that are neither object restrictions nor datatype restrictions, but these restrictions are not handled within OWL.

An owl:Restriction element contains an owl:onProperty element, which refers to a property name (a URI) (we will refer to this property as P) and one or more of the following

The OWL syntax currently allows restrictions that are malformed. Restrictions with missing components (e.g., an owl:Restriction element with no owl:onProperty element) have no semantic impact, even though treating them as RDF would indicate that there should be some semantic impact. Restrictions with extra components (e.g., an owl:Restriction element with multiple different owl:onProperty elements) have unusual and misleading semantic impact (in general equating the extensions of two or more well-formed restrictions). Use of such constructs should be avoided.

Boolean combination of class expressions

A boolean combination of class expressions can be constructed from:

Note that arbitrarily complex combinations of these expressions can be formed. See Boolean Note for an example of this.

Property elements

An rdf:Property element refers to a property name (a URI) (to which we will refer as P). Properties that are used in property restrictions should be either object properties, which relate objects to other objects, and are instances of owl:ObjectProperty; or datatype properties, which relate objects to datatype values, and are instances of owl:DatatypeProperty.

A property element contains:

Instead of an object property or datatype property element, it is also possible to use any of the following elements, each of which assert additional information about the property:

Notice that owl:FunctionalProperty and owl:InverseFunctionalProperty specify global cardinality restrictions. That is, no matter what class the property is applied to, the cardinality constraints must hold, unlike the various cardinality properties used in property restrictions, which are part of a class element, and are only enforced on the property when applied to that class.
A property is a binary relation that may or may not be defined in the ontology. If it is not defined, then it is assumed to be a binary relation with no globally applicable constraints, i.e. any pair with first element an object and second element an object or datatype value could be an instance of the property.
Warning: If an owl:TransitiveProperty (or any of its superproperties) is used in a cardinality constraint, then class consistency is no longer necessarily decidable. Of course, owl:FunctionalProperty is a particular case of a cardinality constraint.

Instances

Instances of both classes (i.e., objects) and of properties (i.e., pairs) are written in RDF/XML syntax.
See the RDF/XML Syntax Specification(Revised) for more details on the various syntactic forms that are allowed. Here we list just some of the most common notations:

<Continent rdf:ID="Africa"/>

<rdf:Description rdf:ID="Asia">
  <rdf:type>
    <rdfs:Class rdf:about="#Continent"/>
  </rdf:type>
</rdf:Description>

<rdf:Description rdf:ID="India">
  <isPartOf rdf:resource="#Asia"/>
</rdf:Description>

There is no unique name assumption for objects in OWL. To state that objects are the same, an owl:sameIndividualAs element is used. (Note that owl:sameAs can be also used here, but owl:sameIndividualAs is preferred.) To state that objects are distinct, an owl:differentFrom element is used. See issue #I5.18-Unique-Names-Assumption-Support-in-OWL. The situation is different for datatype values, where XML Schema Datatype identity is used.

Datatype values

Datatype values are written in a manner that is valid RDF syntax, but which is given a special semantics in OWL. The preferred method is to give a lexical representation of the value as a string, along with an XML Schema datatype that is used to provide the type of the value as well as the parsing mechanism to go from the string to the value itself. The XML Schema datatype is the rdf:type of the value, and the lexical representation is the rdf:value of the value. So the decimal 10.5 could be input as <xsd:decimal rdf:value="10.5"/> provided that xsd was defined as the URI of the XML Schema Datatype specification.

As a nod to backward compatability, literals that occur outside this sort of construction are interpreted as any of the XML Schema Datatype values with this lexical representation. These values are mostly unusable unless some typing information is available, such as a range for a property.

The question of whether any XML Schema datatype can be used in such constructions, or whether only certain XML Schema dataypes can be so used (such as only the predefined datatypes), remains open.

Deprecation

Deprecation is a feature commonly used in versioning software (for example, see the Java programming language) to indicate that a particular feature is preserved for backward-compatibility purposes, but may be phased out in the future. Here, a specific identifer is said to be of type owl:DeprecatedClass or owl:DeprecatedProperty, where owl:DeprecatedClass is a subclass of rdfs:Class and owl:DeprecatedProperty is a subclass of rdf:Property. By deprecating a term, it means that the term should not be used in new documents that commit to the ontology. This allows an ontology to maintain backward-compatibility while phasing out an old vocabulary (thus, it only makes sense to use deprecation in combination with backward compatibility). As a result, it it easier for old data and applications to migrate to a new version, and thus can increase the level of adoption of the new version. Once again, this has no meaning in the model theoretic semantics other than that given by the RDF(S) model theory. However, authoring tools may use it to warn users when checking OWL markup.

An example of deprecation is:

<owl:Ontology rdf:about="">
  <rdfs:comment>Vehicle Ontology, v. 1.1</rdfs:comment>
  <owl:backwardCompatibleWith
rdf:resource="http://www.example.org/vehicle-1.0">
  <owl:priorVersion rdf:resource="http://www.example.org/vehicle-1.0">
</owl:Ontology>

<owl:DeprecatedClass rdf:ID="Car">
  <rdfs:comment>Automobile is now preferred</rdfs:comment>
</owl:DeprecatedClass>

<owl:Class rdf:ID="Automobile"/>
  <owl:sameClassAs rdf:resource="#Car"/>
  <!-- note that sameClass only means that the classes have the same
       extension, so this DOES NOT lead to the entailment that
       Automobile is of type DeprecatedClass too -->	
</owl:Class>

<owl:DeprecatedProperty rdf:ID="hasDriver">
  <rdfs:comment>inverse property drives is now preferred</rdfs:comment>
</owl:DeprecatedProperty>

<owl:ObjectProperty rdf:ID="drives">
  <owl:inverseOf rdf:resource="#hasDriver"/>
</owl:ObjectProperty>

3. application/owl+xml Media Type Registration

Status of this Memo

This memo provides information for the Internet community. It does not specify an Internet standard of any kind. Distribution of this memo is unlimited.

Copyright Notice

Copyright (C) The Internet Society (2002). All Rights Reserved.

Abstract

This document describes a media type (application/owl+xml) for use with the RDF/XML serialization of the Web Ontology Language (OWL). OWL is intended to provide a language that can be used to describe the classes and relations between them that are inherent in Web documents and applications.


 RFC  00
 TOC 

Table of Contents




 TOC 

1. Discussion of this Document

Please send comments to <mailto:public-webont-comments@w3.org>. To subscribe, send a message with the body 'subscribe' to <mailto:public-webont-comments-request@w3.org>. The mailing list is publically archived at <http://lists.w3.org/Archives/Public/public-webont-comments/>.



 TOC 

2. Introduction

The Web Ontology Language (OWL) is intended to provide a language that can be used to describe the classes and relations between them that are inherent in Web documents and applications.

The interchange language for OWL is the RDF/XML syntax[4] as described in the OWL Reference[1]. An OWL document may be served with the application/rdf+xml media type in which case the document is interpreted according to the application/rdf+xml media type[3] registration. An OWL document may be served with the application/owl+xml media type in which case it is interpreted according to the OWL Abstract Syntax and Semantics[2].

When an OWL document is served with the application/xml media type, no particular interpretation is indicated and must be arranged by private agreement between publisher and consumer of the document. Application/xml might be used when the document is intended to be an example. The OWL model theory licenses additional entialments from the RDF model theory interpretation of the same RDF/XML document. Such differences between these interpretations are discussed in the OWL model theory document.



 TOC 

3. application/owl+xml Registration

This is a media type registration as defined in Multipurpose Internet Mail Extensions (MIME) Part Four: Registration Procedures[8]

MIME media type name: application

MIME subtype name: owl+xml

Required parameters: none

Optional parameter: charset

Same as charset parameter of application/xml.

Encoding considerations:

Same as charset parameter of application/xml.

Security considerations:

Security considerations include many of those described in section 10 of RFC 3023[6] as well as those described in the application/rdf+xml media type registration[3].

Interoperability considerations:

Published specification: see Web Ontology Language (OWL) 1.0 Reference[1] and OWL Abstract Syntax and Semantics[2] (working drafts as of 2002-11)

Applications which use this media type:

OWL is device-, platform-, and vendor-neutral and is supported by a range of Web Ontology user agents, authoring tools and inferencing engines.

Additional information:

Magic number(s): none

Although no byte sequences can be counted on to consistently identify OWL, RDF documents will have the sequence "http://www.w3.org/1999/02/22-rdf-syntax-ns#" to identify the RDF namespace. This will usually be towards the top of the document. OWL documents may or may not declare the OWL namespace "http://www.w3.org/2002/07/owl#"

File extension(s): .owl,.rdf

Macintosh File Type Code(s): "TEXT"

For further information:

Jonathan Borden <jonathan@openhealth.org>

RDF Logic <www-rdf-logic@w3.org>

More information may be found on the WebOnt website: <http://www.w3.org/2001/sw/WebOnt>

Intended usage: COMMON

Author/Change controller:

The OWL specification is a work product of the World Wide Web Consortium. The W3C and the W3C WebOnt Working Group have change control over the specification.



 TOC 

4. Social Context

@@



 TOC 

5. Fragment Identifiers

application/owl+rdf uses the same fragment identifer syntax and semantics as application/rdf+xml.

The rdf:ID and rdf:about attributes can be used to define fragments in an RDF document.

Section 4.1 of the URI specification[7] notes that the semantics of a fragment identifier (part of a URI after a "#") is a property of the data resulting from a retrieval action, and that the format and interpretation of fragment identifiers is dependent on the media type of the retrieval result.



 TOC 

6. IANA Considerations

This document calls for registration of a new MIME content-type, according to the registration template in section 2.



 TOC 

7. Acknowledgements

@@



 TOC 

References

[1] Dean, M., "Web Ontology Language (OWL) 1.0 Reference", W3C owl-reference, July 2002.
[2] Patel-Schneider, P., "Web Ontology Language (OWL) 1.0 Abstract Syntax and Semantics", W3C owl-reference, November 2002.
[3] Swartz, A., "application/rdf+xml media type Registration", IETF rdf-xml-media-type, August 2002.
[4] Beckett, D., "RDF/XML Syntax Specification (Revised)", W3C rdf-syntax-grammar, March 2002.
[5] Hayes, P., "RDF Model Theory", W3C rdf-mt, April 2002.
[6] Murata, M., St. Laurent, S. and D. Kohn, "XML Media Types", RFC 3023, January 2001.
[7] Berners-Lee, T., Fielding, R. and L. Masinter, "Uniform Resource Identifiers (URI): Generic Syntax", RFC 2396, August 1998 (TXT, HTML, XML).
[8] Freed, N., Klensin, J. and J. Postel, "Multipurpose Internet Mail Extensions (MIME) Part Four: Registration Procedures", BCP 13, RFC 2048, November 1996 (TXT, HTML, XML).
[9] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997 (TXT, HTML, XML).


 TOC 

Author's Address

  Jonathan Borden
  St. Vincent Health System
  Section of Neurosurgery
  311 W. 24th Street
  Erie, PA 16502
  USA
Phone:  +1 814 455 4868
EMail:  jonathan@openhealth.org
URI:  http://www.openhealth.org/


 TOC 

Full Copyright Statement

Acknowledgement

Appendix A. Index of all language elements

Appendix B. Notes

Syntax Note:
As a simple example of an alternative syntactic form resulting in the same set of RDF triples, consider the statement in this document that "an OWL class definition consists at least of an rdfs:class element", which suggests the following syntactic form:
<rdfs:Class rdf:ID="Continent"/> 

However, the following RDF statement:

<rdf:Description rdf:ID="Continent">
  <rdf:type resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
</rdf:Description> 


results in exactly the same set of RDF triples, and is therefore perfectly allowed as a class definition.

Another example is the two notations that we discuss for cardinality constraints below. Again, both these forms result in the same set of RDF triples, and are thus equivalent.

Mixing Note:
For example, given
<owl:Class rdf:ID="Person"/>

and then adding
<rdf:Description rdf:about="#Person">
     <dc:Creator>Ora Lassila</dc:Creator>
</rdf:Description>


the semantics don't say what this means or what it would imply for instances of Person. (Beyond of course the minimal Subject-Verb-Object semantics of RDF).

Cardinality Syntax Note:
As an example of content-hiding syntax for cardinality expressions, instead of the standard notation:
<owl:Restriction>
  <owl:onProperty rdf:resource="#father"/>
  <owl:cardinality>1</cardinality>
</owl:Restriction>

we would have to write

<owl:Restriction owl:cardinality="1">
  <owl:onProperty rdf:resource="#father"/>
</owl:Restriction> 

to avoid any exposed content. The cardinality elements are the only ones for which this alternative notation is required to avoid exposed content. (See [Ed: identify link] the section on abbreviated syntax in the RDF specification for more details on this notation).

Boolean Note:
As an example of a combination of boolean operators, the expression "neither meat nor fish" could be written as:
<owl:complementOf>
 <owl:Class>
  <owl:unionOf rdf:parseType="Collection">
   <owl:Class rdf:resource="#Meat"/>
   <owl:Class rdf:resource="#Fish"/>
  </owl:unionOf>
 </owl:Class>
</owl:complementOf>

Appendix C. http://www.w3.org/2002/07/owl

See http://www.w3.org/2002/07/owl. Copy inline for final version.

Appendix D. Changes from DAML+OIL

This section summarizes the changes from DAML+OIL [DAML+OIL] to OWL.

  1. The namespace was changed to http://www.w3.org/2002/07/owl.
  2. Various updates to RDF and RDF Schema from the RDF Core Working Group were incorporated, including
  3. Qualified restrictions were removed from the language, resulting in the removal of the following properties:
  4. Various properties and classes were renamed, as shown in the following table:
    DAML+OIL OWL
    daml:differentIndividualFrom owl:differentFrom
    daml:hasClass owl:someValuesFrom
    daml:toClass owl:allValuesFrom
    daml:UnambiguousProperty owl:InverseFunctionalProperty
    daml:UniqueProperty owl:FunctionalProperty
  5. owl:SymmetricProperty was added.
  6. An owl:DatatypeProperty may be an owl:InverseFunctionalProperty in OWL Full.
  7. Synonyms for RDF and RDF Schema classes and properties were removed from the language, resulting in the removal of:
  8. daml:disjointUnionOf was removed from the language, since it can be effected using owl:unionOf or rdfs:subClassOf and owl:disjointWith.
  9. daml:equivalentTo was renamed to owl:sameAs, and is no longer a superproperty of owl:sameClassAs, owl:samePropertyAs, and owl:sameIndividualAs
  10. The following properties and classes were added to support versioning:

Appendix E. XML Presentation Syntax of OWL

Draft 30 December 2002

Masahiro Hori <horim@jp.ibm.com>

This document is non-normative.

Note: XML Schemas in this documents are defined on the basis of the XML Schema for OWL created by Peter F. Patel-Schneider. Peter's XML Schema in itself is not changed from the version as of 19 December 2002, but has been reconfigured for the adaptation to the three sublanguages of OWL.


Abstract

This document provides XML Schemas for the XML presentation sytax of OWL 1.0 sublanguages: OWL Lite, OWL DL, and OWL Full.

Table of Contents

1. Introduction
1.1 Notational Conventions
1.2 How to Use an XML Schema
2. XML Schema Modules
2.1 Common Core
2.2 Class Element Group
2.3 Description Group
2.4 Cardinality Range Type
2.5 Restriction Group
2.6 Inverse Functional Attribute of Data Property
2.7 Inverse Functional Attribute of Object Property
3. XML Schemas
3.1 Schema Drivers
3.2 Schema Modules
References

1. Introduction

This document specifies the XML presentation syntax for OWL. The OWL 1.0 language provides three increasingly expressive sublanguages: OWL Lite, OWL DL, and OWL Full. This document provides XML Schemas for XML presentation syntax corresponding to each of the three sublanguages.

A zip archive of all the Schemas for XML presentation syntax is also available.

1.1 Notational Conventions

This document uses a number of namespace prefixes as listed below. Note that the choice of any namespace prefix is arbitrary, and not semantically significant.

Prefix Namespace Notes
owl "http://www.w3.org/2002/OWL-XMLSchema" The namespace of the XML presentation syntax of OWL defined by this document
xsd "http://www.w3.org/2001/XMLSchema" The namespace of the XML Schema [XMLSchema-1]
xsi "http://www.w3.org/2001/XMLSchema-instance" The namespace of the XML Schema instance [XMLSchema-1]

No consensus yet on the namespace URI "http://www.w3.org/2002/OWL-XMLSchema"

1.2 How to Use an XML Schema

XML Schemas do not have to be specified in an OWL instance itself, but it may be specified in an instance by adding schemaLocation attribute (in the XML Schema instance namespace) to the root element. For example, if an author uses the XML Schema for OWL Lite, the start tag of the Ontology element may designate the location of the XML Schema as shown below:

<owl:Ontology 
  xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.w3.org/2002/OWL-XMLSchema
                      http://example.org/owl1-lite.xsd" >
The convention of the namespace prefix 'owl' may be confusing... alternative: 'ows' ?

A value of the xsi:schemaLocation attribute is a pair (or pairs) of URI references consisting of a namespace name and a location of an XML Schema. Note that a pair of URI references is only a hint for XML Schema processors, which may use alternative XML Schemas indicated by other names. For the further details of schema document access, see "4.3.2 How schema definitions are located on the Web" of the XML Schema Part 1 [XMLSchema-1]

2. XML Schema Modules

This document provides a set of XML Schema modules for XML presentation syntax of OWL. The design goal of this modularization is to set up a core module common to all the OWL sublanguages and define additional modules to be customized for different sublanguages. Note that the modularization here is done primarily for the adaptation to the three sublanguages, and is not designed for the arbitrary customization of OWL.

The top-level Schema document, which collects required modules together, is called a Schema driver. A driver document only includes other modules, and does not contain any markup declarations in itself. Modularization through drivers and modules is being done for the reformulation of the XHTML specification in XML Schema [XHTML m12n].

Three Schema drivers are defined for the sublanguages: OWL Lite (owl1-lite.xsd), OWL DL (owl1-dl.xsd), and OWL Full (owl1-full.xsd). Modules included into the Schema drivers are summarized in the table below. Each row in the table corresponds to a type of Schema modules to be used for a driver depending on the configuration. The three columns labled with OWL Lite, OWL DL, and OWL Full indicate which type of modules to be included into the sublanguages.

OWL LiteOWL DLOWL Full
2.1 Common Core lite lite lite
2.2 Class Element Group (inequality, equality) lite dl dl
2.3 Description Group (Complex classes) lite dl dl
2.4 Cardinality Range Type lite dl dl
2.5 Restriction Group (Property filler restriction) lite dl dl
2.6 Inverse Functional Attribute of Data Property lite lite full
2.7 Inverse Functional Attribute of Object Property lite dl dl

2.1 Common Core

This module specifies a core module (owl1-lite-core.xsd) common to all the sublanguages, and is included into every Schema driver. This core module requires additional modules explained in the following subsections.

2.2 Class Element Group

The Class Element Group modules (owl1-lite-classElementGroup.xsd and owl1-dl-classElementGroup.xsd) control the inclusion of the elements relevant to owl:Class and declared as immediate children of the root element Ontology.

The OWL Lite Schema driver (owl1-lite.xsd) includes an XML Schema module (owl1-lite-classElementGroup.xsd) that makes Class, SubClassOf, and EnumeratedClass available in OWL Lite. However, EquivalentClasses and DisjointClasses are not included in this module because they are not available in OWL Lite.

XML presentation syntax provides two ways for the enumerated classes (owl:oneOf): OntologyType/EnumeratedClass and description/OneOf. Is this correct?
(Inconsistency?) [OWL Guide] says owl:sameClassAs is included in OWL DL, while [OWL Feature] says owl:sameClassAs is in OWL Lite.
module/owl1-lite-classElementGroup.xsd
<xsd:group name="classElements">
  <xsd:choice>
    <xsd:element name="Class" type="owl:ClassAxiomType" />
    <xsd:element name="SubClassOf" type="owl:SubClassOfType" />
    <xsd:element name="EnumeratedClass" type="owl:EnumerationType" />

    <!-- Inequality and equality elements are not included --> 
  </xsd:choice>
</xsd:group>
Class element group for OWL Lite. Inequality (DisjointClasses) and equality (EquivalentClasses) elements are not included. This model group is extended by "owl1-dl-classElementGroup.xsd".

EquivalentClasses and DisjointClasses are decleared for OWL DL in owl1-dl-classElementGroup.xsd that is included by the Schema drivers for OWL DL (owl1-dl.xsd) and OWL Full (owl-full.xsd).

module/owl1-dl-classElementGroup.xsd
<xsd:redefine schemaLocation="owl1-lite-classElementGroup.xsd"> 
  <xsd:group name="classElements">   
    <xsd:choice>
      <xsd:group ref="owl:classElements" /> 
  
      <!-- Inequality and equality elements are added --> 
      <xsd:element name="DisjointClasses" type="owl:DescriptionsTypeNE" />
      <xsd:element name="EquivalentClasses" type="owl:DescriptionsTypeNE" />
    </xsd:choice>
  </xsd:group>
</xsd:redefine> 
Class element group for OWL DL. Inequality (DisjointClasses) and equality (EquivalentClasses) elements are added. This model group extends "owl1-lite-classElementGroup.xsd".

2.3 Description Group

The Description Group modules (owl1-lite-descriptionGroup.xsd and owl1-dl-descriptionGroup.xsd) control the inclusion of the elements that are declared as members of the description group.

The OWL Lite Schema driver (owl1-lite.xsd) includes an XML Schema module (owl1-lite-descriptionGroup.xsd) that makes Class, DataResiction, and IndividualRestriction available in OWL Lite. However, UnionOf, IntersectionOf, ComplementOf, and OneOf are not included in this module because they are not available in OWL Lite.

module/owl1-lite-descriptionGroup.xsd
<xsd:group name="description"> 
  <xsd:choice>
    <xsd:element name="Class" type="owl:ClassIDType"
                 minOccurs="1" maxOccurs="1" />
    <xsd:element name="DataRestriction" type="owl:DataRestrictionType"
                 minOccurs="1" maxOccurs="1" />
    <xsd:element name="IndividualRestriction" type="owl:IndividualRestrictionType"
                 minOccurs="1" maxOccurs="1" /> 

    <!-- Boolean combination and class enumeration are not included --> 
  </xsd:choice>
</xsd:group>
Description group for OWL Lite. Elements for boolean combination of class expressions (UnionOf, IntersectionOf, ComplementOf), and an element for Class enumeration (OneOf) are not included. This model group is extended by "owl1-dl-descriptionGroup.xsd".

UnionOf, IntersectionOf, ComplementOf, and OneOf are decleared for OWL DL in owl1-dl-descriptionGroup.xsd that is included by the Schema drivers for OWL DL (owl1-dl.xsd) and OWL Full (owl-full.xsd).

module/owl1-dl-descriptionGroup.xsd
<xsd:redefine schemaLocation="owl1-lite-descriptionGroup.xsd"> 
  <xsd:group name="description">   
    <xsd:choice>
      <xsd:group ref="owl:description" /> 

      <!-- Elements for boolean combination are added --> 
      <xsd:element name="UnionOf" type="owl:DescriptionsType"
                   minOccurs="1" maxOccurs="1" />
      <xsd:element name="IntersectionOf" type="owl:DescriptionsType"
                   minOccurs="1" maxOccurs="1" />
      <xsd:element name="ComplementOf" type="owl:DescriptionType"
                   minOccurs="1" maxOccurs="1" />

      <!-- An element for class enumeration is added --> 
      <xsd:element name="OneOf" type="owl:IndividualsType"
                   minOccurs="1" maxOccurs="1" />
    </xsd:choice>
  </xsd:group>
</xsd:redefine> 
Description group for OWL DL. Elements for boolean combination of class expressions (UnionOf, IntersectionOf, ComplementOf), and an element for Class enumeration (OneOf) are added. This model group extends "owl1-lite-descriptionGroup.xsd".

2.4 Cardinality Range Type

The Cardinality Range Type modules (owl1-lite-cardinalityRangeType.xsd and owl1-dl-cardinalityRangeType.xsd) allows to change the cardinality restriction features. OWL Lite only permits cardinality values of 0 or 1, while arbitrary non-negative integers are allowed for OWL DL and OWL Full.

In the XML presentation syntax, cardinality restrictions are represented as attributes (minCardinality, maxCardinality, and cardinality) of DataRestriction and IndividualRestriction elements. As shown below, a simple type definition CardinalityRangeType is used for expressing the constraints on cardinality attributes of DataRestriction and IndividualRestriction elements (see the excerption of the complex type definitions below).

Excerption from "module/owl1-lite-core.xsd"
<xsd:complexType name="DataRestrictionType"> 
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:group ref="owl:dataRestriction" /> 
  </xsd:sequence>
  <xsd:attribute name="property" type="owl:DataPropertyName" 
                 use="required" />
  <xsd:attribute name="minCardinality" type="owl:CardinalityRangeType" />
  <xsd:attribute name="maxCardinality" type="owl:CardinalityRangeType" />
  <xsd:attribute name="cardinality"    type="owl:CardinalityRangeType" /> 
</xsd:complexType>

<xsd:complexType name="IndividualRestrictionType">  
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:group ref="owl:individualRestriction" /> 
  </xsd:sequence>
  <xsd:attribute name="property" type="owl:IndividualPropertyName" 
                 use="required" />
  <xsd:attribute name="minCardinality" type="owl:CardinalityRangeType" />
  <xsd:attribute name="maxCardinality" type="owl:CardinalityRangeType" />
  <xsd:attribute name="cardinality"    type="owl:CardinalityRangeType" /> 
</xsd:complexType>

The OWL Lite Schema driver (owl1-lite.xsd) includes an XML Schema module (owl1-lite-cardinalityRangeType.xsd) with the cardinality range type that only permits cardinality values of 0 or 1.

module/owl1-lite-cardinalityRangeType.xsd
<xsd:simpleType name="CardinalityRangeType"> 
  <xsd:restriction base="xsd:nonNegativeInteger"> 
    <xsd:minInclusive value="0" />
    <xsd:maxInclusive value="1" />
  </xsd:restriction>
</xsd:simpleType>
Cardinality Range Type for OWL Lite. Cardinality value is restricted to either 0 or 1.

The definition of the cardinality range type is extended for OWL DL in owl1-dl-cardinalityRangeType.xsd, so that cardinality values can be arbitrary non-negative integers. The schema module with the extended range type is included by the Schema drivers for OWL DL (owl1-dl.xsd) and OWL Full (owl-full.xsd).

module/owl1-dl-cardinalityRangeType.xsd
<xsd:simpleType name="CardinalityRangeType">
  <xsd:restriction base="xsd:nonNegativeInteger" /> 
</xsd:simpleType>
Cardinality Range Type for OWL DL. Cardinality value can be an arbitrary non-negative integer.

2.5 Restriction Group

The Restriction Group modules (owl1-lite-restrictionGroup.xsd and owl1-dl-restrictionGroup.xsd) control the inclusion of the elements for property filler restriction listed below.

The OWL Lite Schema driver (owl1-lite.xsd) includes an XML Schema module (owl1-lite-restrictionGroup.xsd) that makes allValuesFrom and someValueFrom elements available for both data and individual restrictions in OWL Lite. However, value elements are not included in this module because they are not available in OWL Lite.

module/owl1-lite-restrictionGroup.xsd
<xsd:group name="dataRestriction">
  <xsd:choice>
    <xsd:element name="allValuesFrom" type="owl:DataRangeType" />
    <xsd:element name="someValueFrom" type="owl:DataRangeType" />
    <!-- An element for property filler restriction (value) is not included --> 
  </xsd:choice>
</xsd:group>

<xsd:group name="individualRestriction"> 
  <xsd:choice>
    <xsd:element name="allValuesFrom" type="owl:DescriptionsType" />
    <xsd:element name="someValueFrom" type="owl:DescriptionsType" />
    <!-- An element for property filler restriction (value) is not included --> 
  </xsd:choice>
</xsd:group>
Restriction group for OWL Lite. An element for property filler restriction (value) is not included. This model group is extended by "owl1-dl-restrictionGroup.xsd".

Additional value restriction elements (value) for data and individual restrictions are declared for OWL DL in owl1-dl-restrictionGroup.xsd that is included by the Schema drivers for OWL DL (owl1-dl.xsd) and OWL Full (owl-full.xsd).

module/owl1-dl-restrictionGroup.xsd
<xsd:redefine schemaLocation="owl1-lite-restrictionGroup.xsd"> 
  <xsd:group name="dataRestriction">   
    <xsd:choice>
      <xsd:group ref="owl:dataRestriction" /> 
      <!-- A element for property filler restriction (value) is added --> 
      <xsd:element name="value" type="xsd:anySimpleType" />
    </xsd:choice>
  </xsd:group>

  <xsd:group name="individualRestriction"> 
    <xsd:choice>
      <xsd:group ref="owl:individualRestriction" /> 
      <!-- A element for property filler restriction (value) is added --> 
      <xsd:element name="value" type="owl:IndividualIDType" />
    </xsd:choice>
  </xsd:group>
</xsd:redefine> 
Restriction group for OWL DL. Elements for property filler restriction (value) are added for both data and individual restriction. This model group extends "owl1-lite-restrictionGroup.xsd".

2.6 Inverse Functional Attribute of Data Property

Datatype Property may be declared as inverse functional in OWL Full, while it must not be in OWL DL and OWL Lite. Note that Object Property may be declared as inverse functional not only in OWL Full but also in OWL DL (see also the section 2.7 Inverse Functional Attribute of Object Property).

The Schema drivers for OWL Lite (owl1-lite.xsd) and OWL DL (owl1-dl.xsd) include a module (owl1-lite-dataPropInverseFuncAttr.xsd) for the inverse functional attribute of Datatype Property to be fixed as 'false'.

module/owl1-lite-dataPropInverseFuncAttr.xsd
<xsd:attributeGroup name="dataPropInverseFuncAttr"> 
  <xsd:attribute name="inverseFunctional" type="xsd:boolean" fixed="false" /> 
</xsd:attributeGroup>

On the other hand, the inverse functional attribute of Datatype Property is set to 'false' by default (and may be changed to 'true' as needed) in the module for OWL Full (owl1-full-dataPropInverseFuncAttr.xsd) that is included by the OWL Full Schema driver (owl1-full.xsd).

module/owl1-full-dataPropInverseFuncAttr.xsd
<xsd:attributeGroup name="dataPropInverseFuncAttr"> 
  <xsd:attribute name="inverseFunctional" type="xsd:boolean" default="false" />
</xsd:attributeGroup>

2.7 Inverse Functional Attribute of Object Property

Object Property may be declared as inverse functional in OWL DL and OWL Full, while it must not be in OWL Lite. Note that Datatype Property must not be inverse functional in OWL DL and OWL Lite (see also the section 2.6 Inverse Functional Attribute of Data Property).

The Schema drivers for OWL Lite (owl1-lite.xsd) includes a module (owl1-lite-dataPropInverseFuncAttr.xsd) for the inverse functional attribute of Object Property to be fixed as 'false'.

module/owl1-lite-objPropInverseFuncAttr.xsd
<xsd:attributeGroup name="objectPropInverseFuncAttr"> 
  <xsd:attribute name="inverseFunctional" type="xsd:boolean" fixed="false" />
</xsd:attributeGroup>

On the other hand, the inverse functional attribute of Object Property is set to 'false' by default (and may be changed to 'true' as needed) in the module (owl1-full-dataPropInverseFuncAttr.xsd) for OWL DL that is included by the Schema drivers for OWL DL (owl1-dl.xsd) and OWL Full (owl1-full.xsd).

module/owl1-dl-objectPropInverseFuncAttr.xsd
<xsd:attributeGroup name="objectPropInverseFuncAttr"> 
  <xsd:attribute name="inverseFunctional" type="xsd:boolean" default="false" />
</xsd:attributeGroup>

3. XML Schemas

3.1 Schema Drivers

3.1.1 OWL Lite Schema Driver

owl1-lite.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      XML Schema driver for OWL 1.0 Lite
    </xsd:documentation> 
  </xsd:annotation>

  <xsd:include schemaLocation="module/owl1-lite-core.xsd" />
  <xsd:include schemaLocation="module/owl1-lite-classElementGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-lite-descriptionGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-lite-cardinalityRangeType.xsd" /> 
  <xsd:include schemaLocation="module/owl1-lite-restrictionGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-lite-dataPropInverseFuncAttr.xsd" /> 
  <xsd:include schemaLocation="module/owl1-lite-objectPropInverseFuncAttr.xsd" /> 
</xsd:schema>

3.1.2 OWL DL Schema Driver

owl1-dl.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      XML Schema driver for OWL 1.0 DL
    </xsd:documentation> 
  </xsd:annotation>

  <xsd:include schemaLocation="module/owl1-lite-core.xsd" />
  <xsd:include schemaLocation="module/owl1-dl-classElementGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-dl-descriptionGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-dl-cardinalityRangeType.xsd" /> 
  <xsd:include schemaLocation="module/owl1-dl-restrictionGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-lite-dataPropInverseFuncAttr.xsd" /> 
  <xsd:include schemaLocation="module/owl1-dl-objectPropInverseFuncAttr.xsd" /> 
</xsd:schema>

3.1.3 OWL Full Schema Driver

owl1-full.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      XML Schema driver for OWL 1.0 Full
    </xsd:documentation> 
  </xsd:annotation>

  <xsd:include schemaLocation="module/owl1-lite-core.xsd" />
  <xsd:include schemaLocation="module/owl1-dl-classElementGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-dl-descriptionGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-dl-cardinalityRangeType.xsd" /> 
  <xsd:include schemaLocation="module/owl1-dl-restrictionGroup.xsd" /> 
  <xsd:include schemaLocation="module/owl1-full-dataPropInverseFuncAttr.xsd" /> 
  <xsd:include schemaLocation="module/owl1-dl-objectPropInverseFuncAttr.xsd" /> 
</xsd:schema>

3.2 Schema Modules

3.2.1 Common Core Module

module/owl1-lite-core.xsd
<!--		XML Schema for OWL
                Peter F. Patel-Schneider, Bell Labs Research
                19 December 2002

  This is an XML schema for an XML syntax for OWL.  
  I have included some comments in-line, to show what is going on. 

  This XML Schema defines an XML dialect similar to the OWL abstract syntax.
  For arcane technical reasons it is somewhat more general in a few places,
  allowing zero or more descriptions where a single description is allowed in 
  the OWL abstract syntax.  Each of these places can be translated to the OWL 
  abstract syntax by wrapping the descriptions in an intersectionOf.
-->
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified"> 

  <xsd:annotation>
    <xsd:documentation>
      This module (module/owl1-lite-core.xsd) specifies a core 
      module common to all the OWL sublanguages, and is included 
      into every Schema driver. 
    </xsd:documentation>
  </xsd:annotation>

<!-- A OWL document contains an ontology, 
     which has includes, axioms, and facts. -->

<xsd:element name="Ontology" type="owl:OntologyType" >
  <xsd:unique name="classNameUniqueness"> 
    <xsd:annotation>
      <xsd:documentation>
        This constraint ensures that every class name is unique 
        in an ontology document. 
      </xsd:documentation>
    </xsd:annotation>
    <xsd:selector xpath="owl:Class" /> 
    <xsd:field xpath="@owl:name" /> 
  </xsd:unique>

</xsd:element> 


<xsd:complexType name="OntologyType">
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:choice>
      <xsd:element name="Imports" type="owl:IncludeType" />
      <xsd:element name="Annotation" type="owl:AnnotationType" />

      <!-- ***************************************************** -->
      <!--   + owl:classElements (xsd:group)                     --> 
      <!--  is incluced from                                     --> 
      <!--    either owl1-lite-classElementGroup.xsd             --> 
      <!--        or owl1-dl-classElementGroup.xsd               --> 
      <!-- ***************************************************** -->
      <xsd:group ref="owl:classElements" />

      <xsd:element name="DatatypeProperty" type="owl:DataPropertyAxiomType" />
      <xsd:element name="ObjectProperty" type="owl:ObjectPropertyAxiomType" />
      <!-- The conditions on relationships between properties are 
	   context-sensitive so this lets any property in -->
      <xsd:element name="EquivalentProperties" type="owl:PropertiesTypeNE" />
      <xsd:element name="SubPropertyOf" type="owl:SubPropertyOfType" />
 
      <xsd:element name="Individual" type="owl:IndividualType" />
      <xsd:element name="SameIndividual" type="owl:IndividualsTypeNE" />
      <xsd:element name="DifferentIndividuals" type="owl:IndividualsTypeNE" />
 
    </xsd:choice>
  </xsd:sequence>
  <xsd:attribute name="name" type="owl:OntologyName" />
</xsd:complexType>


<!-- Imports points to another ontology -->

<xsd:complexType name="IncludeType">
  <xsd:attribute name="ontology" type="xsd:anyURI" use="required"/>
</xsd:complexType>

<!-- Annotations allow arbitrary uninterpreted information to be added to
     ontologies -->

<xsd:complexType name="AnnotationType">
  <xsd:attribute name="subject" type="xsd:anyURI" use="required"/>
  <xsd:attribute name="object" type="xsd:anyURI" use="required"/>
</xsd:complexType>

<!-- The body of a class axiom is a potentially empty sequence of
     descriptions.  Attributes provide the name of the class and the
     modality for the class. --> 

<xsd:complexType name="ClassAxiomType">
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:group ref="owl:description" />
  </xsd:sequence>
  <xsd:attribute name="name" type="owl:ClassName" use="required" />
  <xsd:attribute name="complete" type="xsd:boolean" use="required" />
</xsd:complexType>

<!-- An enumeration is just a sequence of individuals,
     suitably encapsulated. -->

<xsd:complexType name="EnumerationType">
  <xsd:group ref="owl:individuals" />
  <xsd:attribute name="name" type="owl:ClassName" use="required" />
</xsd:complexType>

<!-- Disjoint and Equivalent for classes take a non-empty group of
     descriptions. -->

<xsd:complexType name="DescriptionsTypeNE"> 
  <xsd:sequence minOccurs="1" maxOccurs="unbounded">
    <xsd:group ref="owl:description" />
  </xsd:sequence>
</xsd:complexType>

<!-- A subclassOf statement is just two descriptions, sub and super. -->

<xsd:complexType name="SubClassOfType">
  <xsd:all>
    <xsd:element name="sub" type="owl:DescriptionType"
                 minOccurs="1" maxOccurs="1" />
    <xsd:element name="super" type="owl:DescriptionType"
                 minOccurs="1" maxOccurs="1" />
  </xsd:all>
</xsd:complexType>

<!-- Property axioms contain supers, domains, and ranges, along
     with characteristics of the property. -->

<xsd:complexType name="DataPropertyAxiomType">
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:choice>
      <xsd:element name="super"  type="owl:DataPropertyIDType" />
      <xsd:element name="domain" type="owl:DescriptionsType" />
      <xsd:element name="range"  type="owl:DataRangeType" />
    </xsd:choice>
  </xsd:sequence>
  <xsd:attribute name="name" type="owl:DataPropertyName" use="required" />
  <xsd:attribute name="functional" type="xsd:boolean" default="false" /> 

  <!-- 'owl:dataPropInverseFuncAttr' is included from    --> 
  <!--    either 'owl1-lite-dataPropInverseFuncAttr.xsd' --> 
  <!--    or     'owl1-full-dataPropInverseFuncAttr.xsd' --> 
  <xsd:attributeGroup ref="owl:dataPropInverseFuncAttr" /> 
</xsd:complexType>

<xsd:complexType name="ObjectPropertyAxiomType">
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:choice>
      <xsd:element name="super"  type="owl:IndividualPropertyIDType" />
      <xsd:element name="domain" type="owl:DescriptionsType" />
      <xsd:element name="range"  type="owl:DescriptionsType" />
    </xsd:choice>
  </xsd:sequence>
  <xsd:attribute name="name" type="owl:IndividualPropertyName" use="required" />
  <xsd:attribute name="inverseOf"  type="owl:IndividualPropertyName" />
  <xsd:attribute name="transitive" type="xsd:boolean" default="false" />
  <xsd:attribute name="symmetric"  type="xsd:boolean" default="false" />
  <xsd:attribute name="functional" type="xsd:boolean" default="false" />

  <!-- 'owl:objectPropInverseFuncAttr' is included from    --> 
  <!--    either 'owl1-lite-objectPropInverseFuncAttr.xsd' --> 
  <!--    or     'owl1-dl-objectPropInverseFuncAttr.xsd'   --> 
  <xsd:attributeGroup ref="owl:objectPropInverseFuncAttr" /> 
</xsd:complexType>


<!-- Datatypes and sets of values can show up in data property ranges. -->

<xsd:complexType name="DataRangeType">
  <xsd:sequence>
    <xsd:element name="OneOf" type="owl:DataValuesType"
                 minOccurs="0" maxOccurs="1" />
  </xsd:sequence>
  <xsd:attribute name="datatype" type="owl:DatatypeName" />
</xsd:complexType>


<!-- EquivalentProperties takes several propertyIDs, 
     all of the same variety (not expressed here) . -->

<xsd:complexType name="PropertiesTypeNE">    
  <xsd:sequence>
    <xsd:element name="property" type="owl:PropertyIDType"
                 minOccurs="1" maxOccurs="unbounded" />
  </xsd:sequence>
</xsd:complexType>

<!-- A subproperty statement is just two propertyIDs, sub and super, 
     with the following restrictions (not expressed here)
     if sub is a data property then super must be a data property
     if sub is a simple property then super must be an individual property.
     There are other restrictions having to do with transitivity and
     cardinalites. 
-->

<xsd:complexType name="SubPropertyOfType">
  <xsd:attribute name="sub" type="owl:PropertyName" use="required" />
  <xsd:attribute name="super" type="owl:PropertyName" use="required" />
</xsd:complexType>


<!-- **************************************************** -->
<!--   + owl:description (xsd:group)                      --> 
<!--  is included from                                    --> 
<!--     either  owl1-lite-descriptionGroup.xsd           --> 
<!--         or  owl1-dl-descriptionGroup.xsd             --> 
<!-- **************************************************** -->


<xsd:complexType name="DescriptionType"> 
  <xsd:group ref="owl:description" />
</xsd:complexType>

<xsd:complexType name="DescriptionsType"> 
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:group ref="owl:description" />
  </xsd:sequence>
  <xsd:attribute name="class" type="owl:ClassName" />
</xsd:complexType>

<!-- All types of restrictions have the property name as an attribute, an
     optional cardinality, zero or more ranges, zero or more required
     restrictions, and zero or more value restrictions. 
     There is a side condition that restrictions on transitive properties
     and their sub-properties cannot have cardinality constraints.
-->  

<xsd:complexType name="DataRestrictionType"> 
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:group ref="owl:dataRestriction" /> 
  </xsd:sequence>
  <xsd:attribute name="property" type="owl:DataPropertyName" 
                 use="required" />
  <xsd:attribute name="minCardinality" type="owl:CardinalityRangeType" />
  <xsd:attribute name="maxCardinality" type="owl:CardinalityRangeType" />
  <xsd:attribute name="cardinality"    type="owl:CardinalityRangeType" /> 
</xsd:complexType>

<xsd:complexType name="IndividualRestrictionType">  
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:group ref="owl:individualRestriction" /> 
  </xsd:sequence>
  <xsd:attribute name="property" type="owl:IndividualPropertyName" 
                 use="required" />
  <xsd:attribute name="minCardinality" type="owl:CardinalityRangeType" />
  <xsd:attribute name="maxCardinality" type="owl:CardinalityRangeType" />
  <xsd:attribute name="cardinality"    type="owl:CardinalityRangeType" /> 
</xsd:complexType>


<!-- **************************************************** -->
<!--   + owl:dataRestriction (xsd:group)                  --> 
<!--   + owl:individualRestriction (xsd:group)            --> 
<!--  are included from                                   --> 
<!--     either owl1-lite-restrictionGroup.xsd            --> 
<!--         or owl1-dl-restrictionGroup.xsd              --> 
<!-- **************************************************** -->

<!-- **************************************************** -->
<!--   + owl:CardinalityRangeType (xsd:simpleType)        --> 
<!--  is included from                                    --> 
<!--     either owl1-lite-cardinalityRangeType.xsd        --> 
<!--         or owl1-dl-cardinalityRangeType.xsd          --> 
<!-- **************************************************** -->


<!-- Facts about individuals have several types and property
     information, including nested facts.  -->

<xsd:complexType name="IndividualType">        
  <xsd:sequence minOccurs="0" maxOccurs="unbounded">
    <xsd:choice>
      <xsd:element name="type" type="owl:ClassIDType" />
      <xsd:element name="ObjectPropertyValue" 
                   type="owl:IndividualPropertyValueType" />
      <xsd:element name="DataPropertyValue" 
                   type="owl:DataPropertyValueType" />
    </xsd:choice>
  </xsd:sequence>
  <xsd:attribute name="name" type="owl:IndividualName" />
</xsd:complexType>

<xsd:complexType name="IndividualPropertyValueType"> 
  <xsd:group ref="owl:individuals" />
  <xsd:attribute name="property" type="owl:IndividualPropertyName"
                 use="required" />
</xsd:complexType>

<xsd:complexType name="DataPropertyValueType"> 
  <xsd:group ref="owl:datavalues" />
  <xsd:attribute name="property" type="owl:DataPropertyName"
                 use="required" />
</xsd:complexType>

<xsd:group name="individuals">
  <xsd:sequence>
    <xsd:element name="Individual" type="owl:IndividualType"
                 minOccurs="0" maxOccurs="unbounded" />
  </xsd:sequence>
</xsd:group>

<xsd:complexType name="IndividualsType">   
  <xsd:group ref="owl:individuals" />
</xsd:complexType>

<xsd:complexType name="IndividualsTypeNE">   
  <xsd:sequence>
    <xsd:element name="Individual" type="owl:IndividualType"
                 minOccurs="1" maxOccurs="unbounded" />
  </xsd:sequence>
</xsd:complexType>

<xsd:group name="datavalues">
  <xsd:sequence>
    <xsd:element name="DataValue" type="xsd:anySimpleType"
                 minOccurs="0" maxOccurs="unbounded" />
  </xsd:sequence>
</xsd:group>

<xsd:complexType name="DataValuesType">   
  <xsd:group ref="owl:datavalues" />
</xsd:complexType>



<!-- Finally, some utility types for the various kinds of names. -->

<xsd:complexType name="ClassIDType">
  <xsd:attribute name="name" type="owl:ClassName" use="required"/>
</xsd:complexType>

<xsd:complexType name="DatatypeIDType">
  <xsd:attribute name="name" type="owl:DatatypeName" use="required" />
</xsd:complexType>

<xsd:complexType name="PropertyIDType">
  <xsd:attribute name="name" type="owl:PropertyName" use="required"/>
</xsd:complexType>

<xsd:complexType name="DataPropertyIDType">
  <xsd:attribute name="name" type="owl:DataPropertyName" use="required"/>
</xsd:complexType>

<xsd:complexType name="IndividualPropertyIDType">
  <xsd:attribute name="name" type="owl:IndividualPropertyName" use="required"/>
</xsd:complexType>

<xsd:complexType name="IndividualIDType">
  <xsd:attribute name="name" type="owl:IndividualName" use="required"/>
</xsd:complexType>

<xsd:simpleType name="OntologyName">
  <xsd:restriction base="xsd:anyURI" />
</xsd:simpleType>

<xsd:simpleType name="ClassName">
  <xsd:restriction base="xsd:anyURI" />
</xsd:simpleType>

<xsd:simpleType name="DatatypeName">
  <xsd:restriction base="xsd:anyURI" />
</xsd:simpleType>

<xsd:simpleType name="PropertyName">
  <xsd:restriction base="xsd:anyURI" />
</xsd:simpleType>

<xsd:simpleType name="DataPropertyName">
  <xsd:restriction base="xsd:anyURI" />
</xsd:simpleType>

<xsd:simpleType name="IndividualPropertyName">
  <xsd:restriction base="xsd:anyURI" />
</xsd:simpleType>

<xsd:simpleType name="IndividualName">
  <xsd:restriction base="xsd:anyURI" />
</xsd:simpleType>

</xsd:schema>

3.2.2 Class Element Group Module

module/owl1-lite-classElementGroup.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      Class element group for OWL Lite.  
      Inequality (DisjointClasses) and equality (EquivalentClasses) 
      elements are not included. 
      This model group is extended by "owl1-dl-classElementGroup.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:group name="classElements">
    <xsd:choice>
      <xsd:element name="Class" type="owl:ClassAxiomType" />
      <xsd:element name="SubClassOf" type="owl:SubClassOfType" />
      <xsd:element name="EnumeratedClass" type="owl:EnumerationType" />

      <!-- Inequality and equality elements are not included --> 
    </xsd:choice>
  </xsd:group>

</xsd:schema>
module/owl1-dl-classElementGroup.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      Class element group for OWL DL.  
      Elements for inequality (DisjointClasses) and equality 
      (EquivalentClasses) are added. 
      This model group extends "owl1-lite-classElementGroup.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:redefine schemaLocation="owl1-lite-classElementGroup.xsd"> 
    <xsd:group name="classElements">   
      <xsd:choice>
        <xsd:group ref="owl:classElements" /> 
  
        <!-- Inequality and equality elements are added --> 
        <xsd:element name="DisjointClasses" type="owl:DescriptionsTypeNE" />
        <xsd:element name="EquivalentClasses" type="owl:DescriptionsTypeNE" />
      </xsd:choice>
    </xsd:group>
  </xsd:redefine> 

</xsd:schema>

3.2.3 Description Group Module

module/owl1-lite-descriptionGroup.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      Description group for OWL Lite.  
      Elements for boolean combination of class expressions 
      (UnionOf, IntersectionOf, ComplementOf), and an element 
      for Class enumeration (OneOf) are not included. 
      This model group is extended by "owl1-dl-descriptionGroup.xsd". 
    </xsd:documentation>
  </xsd:annotation>

<!-- Descriptions are either named classes, property restrictions,
     oneOfs, or boolean combinations of descriptions. -->

  <xsd:group name="description"> 
    <xsd:choice>
      <xsd:element name="Class" type="owl:ClassIDType"
                   minOccurs="1" maxOccurs="1" />
      <xsd:element name="DataRestriction" type="owl:DataRestrictionType"
                   minOccurs="1" maxOccurs="1" />
      <xsd:element name="IndividualRestriction" type="owl:IndividualRestrictionType"
                   minOccurs="1" maxOccurs="1" /> 

      <!-- Boolean combination and class enumeration are not included --> 
    </xsd:choice>
  </xsd:group>

</xsd:schema>
module/owl1-dl-descriptionGroup.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      Description group for OWL DL. 
      Elements for boolean combination of class expressions 
      (UnionOf, IntersectionOf, ComplementOf), and an element 
      for Class enumeration (OneOf) are included. 
      This model group extends "owl1-lite-descriptionGroup.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:redefine schemaLocation="owl1-lite-descriptionGroup.xsd"> 
    <xsd:group name="description">   
      <xsd:choice>
        <xsd:group ref="owl:description" /> 

        <!-- Elements for boolean combination are added --> 
        <xsd:element name="UnionOf" type="owl:DescriptionsType"
                     minOccurs="1" maxOccurs="1" />
        <xsd:element name="IntersectionOf" type="owl:DescriptionsType"
                     minOccurs="1" maxOccurs="1" />
        <xsd:element name="ComplementOf" type="owl:DescriptionType"
                     minOccurs="1" maxOccurs="1" />

        <!-- An element for class enumeration is added --> 
        <xsd:element name="OneOf" type="owl:IndividualsType"
                     minOccurs="1" maxOccurs="1" />
      </xsd:choice>
    </xsd:group>
  </xsd:redefine> 

</xsd:schema>

3.2.4 Cardinality Range Type Module

module/owl1-lite-cardinalityRangeType.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      Cardinality Range Type for OWL Lite.  
      Cardinality value is restricted to either 0 or 1. 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:simpleType name="CardinalityRangeType"> 
    <xsd:restriction base="xsd:nonNegativeInteger"> 
      <xsd:minInclusive value="0" /> 
      <xsd:maxInclusive value="1" />
    </xsd:restriction>
  </xsd:simpleType>

</xsd:schema>
module/owl1-dl-cardinalityRangeType.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified"> 

  <xsd:annotation>
    <xsd:documentation>
      Cardinality Range Type for OWL DL. 
      Cardinality value can be an arbitrary non-negative integer. 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:simpleType name="CardinalityRangeType">
    <xsd:restriction base="xsd:nonNegativeInteger" /> 
  </xsd:simpleType>

</xsd:schema>

3.2.5 Restriction Group Module

module/owl1-lite-restrictionGroup.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      Restriction group for OWL Lite.  
      An element for property filler restriction (value) is not included. 
      This model group is extended by "owl1-dl-restrictionGroup.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:group name="dataRestriction">
    <xsd:choice>
      <xsd:element name="allValuesFrom" type="owl:DataRangeType" />
      <xsd:element name="someValueFrom" type="owl:DataRangeType" />
      <!-- An element for property filler restriction (value) is not included --> 
    </xsd:choice>
  </xsd:group>
  
  <xsd:group name="individualRestriction"> 
    <xsd:choice>
      <xsd:element name="allValuesFrom" type="owl:DescriptionsType" />
      <xsd:element name="someValueFrom" type="owl:DescriptionsType" />
      <!-- An element for property filler restriction (value) is not included --> 
    </xsd:choice>
  </xsd:group>

</xsd:schema>
module/owl1-dl-restrictionGroup.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      Restriction group for OWL DL.  
      Elements for property filler restriction (value) are added 
      for both data and individual restriction. 
      This model group extends "owl1-lite-restrictionGroup.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:redefine schemaLocation="owl1-lite-restrictionGroup.xsd"> 
    <xsd:group name="dataRestriction">   
      <xsd:choice>
        <xsd:group ref="owl:dataRestriction" /> 
        <!-- A element for property filler restriction (value) is added --> 
        <xsd:element name="value" type="xsd:anySimpleType" />
      </xsd:choice>
    </xsd:group>

    <xsd:group name="individualRestriction"> 
      <xsd:choice>
        <xsd:group ref="owl:individualRestriction" /> 
        <!-- A element for property filler restriction (value) is added --> 
        <xsd:element name="value" type="owl:IndividualIDType" />
      </xsd:choice>
    </xsd:group>
  </xsd:redefine> 

</xsd:schema>

3.2.6 Data Property's Inverse Functional Attribute Module

module/owl1-lite-dataPropInverseFuncAttr.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      'inverseFunctional' attribute of DataPropertyAxiomType 
      is fixed as 'false' for OWL Lite and OWL DL. 
      The attribute value is set to 'false' by default for OWL Full 
      in "owl1-full-dataPropInverseFuncAttr.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup name="dataPropInverseFuncAttr"> 
    <xsd:attribute name="inverseFunctional" type="xsd:boolean" fixed="false" /> 
  </xsd:attributeGroup>

</xsd:schema>
module/owl1-full-dataPropInverseFuncAttr.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      'inverseFunctional' attribute of DataPropertyAxiomType is set 
      to 'false' by default  (and may be changed to 'true' as needed) 
      for OWL Full. 
      The attribute value is fixed as 'false' for OWL Lite and LD 
      in "owl1-lite-dataPropInverseFuncAttr.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup name="dataPropInverseFuncAttr"> 
    <xsd:attribute name="inverseFunctional" type="xsd:boolean" default="false" />
  </xsd:attributeGroup>

</xsd:schema>

3.2.7 Object Property's Inverse Functional Attribute Module

module/owl1-lite-objPropInverseFuncAttr.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      'inverseFunctional' attribute of ObjectPropertyAxiomType 
      is fixed as 'false' for OWL Lite. 
      The attribute value is set to 'false' by default for OWL DL 
      in "owl1-dl-objPropInverseFuncAttr.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup name="objectPropInverseFuncAttr"> 
    <xsd:attribute name="inverseFunctional" type="xsd:boolean" fixed="false" />
  </xsd:attributeGroup>

</xsd:schema>
module/owl1-dl-objectPropInverseFuncAttr.xsd
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:owl="http://www.w3.org/2002/OWL-XMLSchema"
    targetNamespace="http://www.w3.org/2002/OWL-XMLSchema"
    elementFormDefault="qualified"
    attributeFormDefault="qualified">

  <xsd:annotation>
    <xsd:documentation>
      'inverseFunctional' attribute of DataPropertyAxiomType 
      is set to 'false' by default for OWL DL. 
      The attribute is fixed as 'false' for OWL Lite in 
      "owl1-lite-objectPropInverseFuncAttr.xsd". 
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup name="objectPropInverseFuncAttr"> 
    <xsd:attribute name="inverseFunctional" type="xsd:boolean" default="false" />
  </xsd:attributeGroup>

</xsd:schema>

References

[XHTML m12n]
Modularization of XHTML in XML Schema. W3C Working Draft, http://www.w3.org/TR/xhtml-m12n-schema (2002).
[XMLSchema-1]
XML Schema Part 1: Structures. W3C Recommendation, http://www.w3.org/TR/xmlschema-1/ (2001).

Appendix F. UML Presentation Syntax of OWL

forthcoming

References

[DAML+OIL]
DAML+OIL (March 2001) Reference Description. Dan Connolly, Frank van Harmelen, Ian Horrocks, Deborah L. McGuinness, Peter F. Patel-Schneider, and Lynn Andrea Stein. W3C Note 18 December 2001. Latest version is available at http://www.w3.org/TR/daml+oil-reference.
[OWL Abstract Syntax]
Web Ontology Language (OWL) Abstract Syntax and Semantics. Peter F. Patel-Schneider, Patrick Hayes, Ian Horrocks, and Frank van Harmelen. W3C Working Draft 8 November 2002. Latest version is available at http://www.w3.org/TR/owl-semantics/. Editor's draft is available at http://www-db.research.bell-labs.com/user/pfps/owl/semantics/.
[OWL Features]
Web Ontology Language (OWL Lite and OWL) Feature Synopsis Version 1.0. Deborah L. McGuinness and Frank van Harmelen. W3C Working Draft 29 Jul 2002. Latest version is available at http://www.w3.org/TR/owl-features/. Editor's draft is available at http://www.ksl.stanford.edu/people/dlm/webont/OWLFeatureSynopsis.htm.
[OWL Guide]
Web Ontology Language (OWL) Guide Version 1.0. Michael K. Smith, Raphael Volz, and Deborah McGuinness. W3C Working Draft 4 November 2002. Latest version is available at http://www.w3.org/TR/owl-guide/.
[OWL Issues]
Web Ontology Issue Status. Michael K. Smith, ed. 18 December 2002. Latest version is available at http://www.w3.org/2001/sw/WebOnt/webont-issues.
[OWL Requirements]
Requirements for a Web Ontology Language. Jeff Heflin, Raphael Volz, and Jonathan Dale. W3C Working Draft 8 July 2002. Latest version is available at http://www.w3.org/TR/webont-req/.
[OWL Test Cases]
Web Ontology Language (OWL) Test Cases. Jeremy J. Carroll and Jos De Roo. W3C Working Draft 24 October 2002. Latest version is available at http://www.w3.org/TR/owl-test/.
[RDF Schema]
RDF Vocabulary Description Language 1.0: RDF Schema. Dan Brickley and R.V. Guha, eds. W3C Working Draft 30 April 2002. Latest version is available at http://www.w3.org/TR/rdf-schema/.
[RDF/XML Syntax]
RDF/XML Syntax Specification (Revised). Dave Beckett, ed. W3C Working Draft 25 March 2002. Latest version is available at http://www.w3.org/TR/rdf-syntax-grammar/.