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].
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.
- Introductory remarks
- Language structure
- application/owl+xml Media Type Registration
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.
- Readers unfamiliar with OWL may wish to first consult the OWL Guide
[OWL Guide]
for a more
narrative description of example uses of the language.
- The normative reference on the precise syntax of the language constructs
is the machine readable RDF Schema definition
of OWL, also included as Appendix C.
- This document specifies the exchange syntax for OWL. An abstract syntax designed to serve as a basis for formal specification is specified in the
OWL Abstract Syntax and Semantics
[OWL Abstract Syntax].
- A precise definition of the
meaning of the language constructs is given in the
OWL Abstract Syntax and Semantics
[OWL Abstract Syntax].
- The OWL language provides three increasingly expressive sublanguages designed for use by specific communities of implementors and users:
OWL Lite, OWL DL, and OWL Full.
A description of these layers and their relationships is given in the
The Species of OWL
section of the OWL Guide
[OWL Guide].
OWL Lite is detailed in the
Feature Synopsis for OWL Lite and OWL
[OWL Features].
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.
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.
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.
An ontology element,
owl:Ontology,
identifies the containing document and contains
-
zero or more
owl:imports elements.
Each owl:imports
statement references another OWL ontology containing definitions
that apply to the containing ontology.
Each reference consists of a URI specifying from where the
ontology is to be imported from.
owl:imports
statements are transitive, that is, if ontology A imports B, and B
imports C, then A imports both B and C. Importing an ontology into
itself is considered a null action, so if ontology A imports B and B
imports A, then they are considered to be equivalent.
Note that namespaces only provide a mechanism for
creating unique names for elements, and do not actually include
definitions in the way that owl:imports does. Similarly, owl:imports elements
do not set up a shorthand notation for names. Therefore, it is common to
have imports elements that correspond to each namespace. However,
additional owl:imports may be used for ontologies that provide definitions
without introducing any new names.
-
an optional
owl:versionInfo element.
This generally contains a string giving
information about this version, for example RCS/CVS keywords. This element
does not contribute to the logical meaning of the ontology.
-
an optional
owl:priorVersion element containing a reference to another ontology.
This identifies the specified ontology as a prior
version of the containing ontology.
This has no meaning in the model theoretic
semantics other than that given by the RDF(S) model theory. However, it
may be used by software to organize ontologies by versions.
-
zero or more
owl:backwardCompatibleWith
elements each containing a reference to another ontology.
This identifies the specified ontology as a prior
version of the containing ontology,
and further indicates that it is backward compatible with it. In
particular, this indicates that all identifiers from the previous
version have the same intended interpretations in the new version. Thus,
it is a hint to document authors that they can safely change their
documents to commit to the new version (by simply updating namespace
declarations and imports statements to refer to the URL of the new
version). If owl:backwardCompatibleWith is not declared for two versions, then
compatibility should not be assumed. Like owl:priorVersion, this
has no meaning in the model theoretic semantics other than that given by
the RDF(S) model theory.
Note, this approach does not address the problem described in Section
3.2 of the Requirements Document (under RDF(S) Support)
[OWL Requirements].
There, we gave
an example where we wanted to "fix" an incorrect definition of Dolphin.
Solving this problem would require versioning capabilities that would
change the model theoretic semantics, but at this time it is not clear
what the correct approach would be. A later version of OWL may address
this issue.
-
zero or more
owl:incompatibleWith
elements each containing a reference to another ontology.
This indicates that the containing ontology is a later version of the
referenced ontology, but is not backward compatible with it.
Essentially,
this is for use by ontology authors who want to be explicit that
documents cannot upgrade to use the new version without some changes.
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.
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
- zero or more
rdfs:subClassOf elements (each containing a class-expression).
Each rdfs:subClassOf element asserts that C is a subclass of the
class-expression mentioned in the element. (Each class-expression defines
a (possibly anonymous) class).
RDFS and OWL allow cycles of subclass relationships as a
means to assert equality between classes.
- zero or more
owl:disjointWith elements (each containing a class-expression).
Each owl:disjointWith element asserts that C is disjoint with the
class-expression in the element (ie. C must have no instances in common
with it);
- zero or more
owl:sameClassAs elements (each containing a class-expression).
Each owl:sameClassAs element asserts that C is equivalent to the
class-expression in the element (ie. C and all the class-expression must
have the same instances);
- zero or more
owl:sameAs elements (each
containing a class
expression)
When applied to a class, the owl:sameAs element has
the same semantics as the owl:sameClassAs element.
Warning: the
use of owl:sameClassAs is favoured over the use of owl:sameAs, since
owl:sameClassAs is declared as a subproperty of rdfs:subClassOf, while owl:sameAs
is not. This makes the meaning of owl:sameClassAs at least partly available to
an RDF Schema-only agent, while the meaning of owl:sameAs is completely
opaque to such an agent.
owl:sameAs
is typically used when it is not known that the expression denotes a class.
- zero or more boolean combinations of class
expressions.
The class C must be equivalent to the class defined by each of the boolean
class expression,
and
- zero or more enumeration elements.
Each enumeration element asserts that C contains exactly the instances
enumerated in the element (i.e: no more, no less). Although it is formally
allowed to have multiple such assertions about C, as soon as two of the
enumerations are not equivalent, the class C immediately becomes
inconsistent (since C cannot be equivalent to both of these enumerations
at once).
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.
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.
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>
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
- elements indicating the type of restriction:
- an
owl:allValuesFrom
element (which contains a class expression
).
An owl:allValuesFrom element defines the class of all
objects for whom the values of property P all belong to
the class
expression. In other words, it defines the class of object x
for which it holds that if the pair (x,y) is an instance of P, then y
is an instance of the class-expression or
datatype;
- an
owl:hasValue
element (which contains (a reference to) an
individual object or a datatype value).
An owl:hasValue element defines the class of all objects for
whom the property P has at least one value equal to the
named object or datatype value (and
perhaps other values as well). In other words, if we call the instance
y, then it defines the class of objects x for which (x,y)
is an instance of P;
- an
owl:someValuesFrom
element (which contains a class expression
or a datatype
references).
An owl:someValuesFrom element defines the class of all objects for
which at least one value of the property P is a member of the class
expression or datatype.
In other words, it defines the class of objects x for
which there is
at least one instance y of the class-expression or datatype such
that (x,y) is an instance of P. This does not exclude that there
are other instances (x,y') of P for which y' does not belong to the
class expression or datatype.
Notice that an
owl:allValuesFrom
restriction is analogous to the universal (for-all)
quantifier of Predicate logic - for each instance of the class or datatype that is
being defined, every value for P must fulfill the restriction.
The
owl:someValuesFrom
restriction is analogous to the existential quantifier of
Predicate logic - for each instance of the class or
datatype that is being defined,
there exists at least one value for P that fulfils the restriction.
Also notice that the correspondence of
owl:allValuesFrom
with the universal
quantifier means that an
owl:allValuesFrom
restriction for a property P is trivially
satisfied for an instance that has no value for property P at all. To see
why this is so, observe that the
owl:allValuesFrom
restriction demands that all
values of P belong to class P, and if no such values exist, the
restriction is trivially true.
- elements containing a non-negative integer (to which we will refer as N)
indicating a cardinality restriction:
- an
owl:cardinality element.
This defines the class of all objects that have exactly N
distinct
values for the property P, i.e. x is an instance of the defined class
if and only if there are N distinct values y such that (x,y) is an
instance of P;
- an
owl:maxCardinality element.
This defines the class of all objects that have at most N
distinct values for the property P;
- an
owl:minCardinality element.
This defines the class of all objects that have at least N
distinct values for the property P.
OWL Lite restricts the value of N to 0 or 1.
An owl:cardinality constraint is simply shorthand for a pair of
owl:minCardinality and owl:maxCardinality constraints with equal values of N.
Warning: in order to
avoid "exposed content" (i.e., to hide OWL annotations from
browsers), it is necessary to write cardinality constraints in an
alternative RDF format. See Cardinality Syntax Note for
an example of this.
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.
A boolean combination of class expressions can be constructed from:
- an
owl:intersectionOf element, containing a list of class expressions.
This defines the class that consists of exactly all the objects that are
common to all class expressions from the list. It is
analogous to logical conjunction;
- an
owl:unionOf
element, containing a list of class
expressions.
This defines the class that consists exactly of all the objects that
belong to at least one of the class expressions from the
list. It is analogous to logical disjunction;
- an
owl:complementOf element, containing a single class expression.
This defines the class that consists of exactly all objects
that do not belong to the class expression. It is
analogous to logical negation, but restricted to objects
only.
Note that arbitrarily complex combinations of these expressions can be
formed. See Boolean Note for an example of
this.
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:
- zero or more
rdfs:subPropertyOf elements, each containing a property
name.
Each subPropertyOf element states that P is a subproperty of the property
named in the element. This means that every pair (x,y) that is an instance
of P is also an instance of the named property;
- zero or more
rdfs:domain elements (each containing a class expression).
Each rdfs:domain element asserts that the property P only applies to instances
of the class expression of the element. More formally: if a pair (x,y) is
an instance of P, then x is an instance of the class expression. This
implies that multiple domain expressions restrict the domain of P to the
intersection of the class expressions.
Note that unlike any of
the property restrictions mentioned
above,
rdfs:domain restrictions are global. The property restrictions above are part
of a class element, and are only enforced on the property when applied to
that class. In contrast, rdfs:domain restrictions apply to the property
irrespective of the Class to which it is applied. This is by virtue of
their semantics in RDF Schema;
Because of this, rdfs:domain elements should be used with
great care in OWL.
- zero or more
rdfs:range
elements (each containing a class expression).
Each rdfs:range element asserts that the property P only assumes values that
are instances of the class expression of the element. More formally: a
pair (x,y) can only be an instance of P if y is an instance of the class
expression.
Multiple range restrictions are
interpreted as saying that the range of P must be the
intersection of all the class expressions. Furthermore, as with rdfs:domain
restrictions, rdfs:range restrictions are global, by virtue of RDF Schema;
Because of this, rdfs:range elements should be used with
great care in OWL.
- zero or more
owl:samePropertyAs elements (each containing a property
name).
Each owl:samePropertyAs element asserts that P is equivalent to the named
property (i.e. they must have the same instances),
- zero or more
owl:sameAs elements (each
containing a property name).
When applied to a property, the owl:sameAs element
has the same semantics as the owl:samePropertyAs element;
Warning: the use of owl:samePropertyAs is
favoured over the use of owl:sameAs, since owl:samePropertyAs is declared as
a subproperty of rdfs:subPropertyOf, while owl:sameAs is not. This makes the
meaning of owl:samePropertyAs at least partly available to an RDF Schema-only
agent, while the meaning of owl:sameAs is completely opaque to such an
agent.
owl:sameAs
is typically used when it is not known that the name denotes a property.
and
- zero or more
owl:inverseOf elements (each containing a property name),
for object properties only.
Each owl:inverseOf element asserts that P is the inverse relation of the named
property. More formally: if the pair (x,y) is an instance of P, than the
pair (y,x) is an instance of the named property.
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:
- an
owl:TransitiveProperty element, which is a
subclass of owl:ObjectProperty.
This asserts that P is transitive, i.e. if the pair (x,y) is an instance
of P, and the pair (y,z) is an instance of P, then the pair (x,z) is also
an instance of P;
- an
owl:SymmetricProperty element, which is a
subclass of owl:ObjectProperty.
This asserts that P is symmetric, i.e. if the pair (x,y) is an instance
of P, then the pair (y,x) is also
an instance of P;
- an
owl:FunctionalProperty
element.
This asserts that P can only have one (unique) value y for each instance
x, i.e. there cannot be two distinct instances y1 and y2 such that the
pairs (x,y1) and (x,y2) are both instances of P. Of course, this is a
shorthand notation for the
owl:maxCardinality
restriction of 1.
or
- an
owl:InverseFunctionalProperty element.
This asserts that an instance y can only be the value of P for a single
instance x, i.e. there cannot be two distinct instances x1 and x2 such
that both (x1,y) and (x2,y) are both instances of P.
In OWL DL,
an owl:InverseFunctionalProperty must also explicitly
be an
owl:ObjectProperty.
In OWL Full,
an owl:InverseFunctionalProperty may be either an
owl:ObjectProperty
or an
owl:DatatypeProperty.
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 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 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 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.
Table of Contents
1.
Discussion of this Document
2.
Introduction
3.
application/owl+xml Registration
4.
Social Context
5.
Fragment Identifiers
6.
IANA Considerations
7.
Acknowledgements
§
References
§
Author's Address
§
Full Copyright Statement
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/>.
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.
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.
4. Social Context
@@
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.
6. IANA Considerations
This document calls for registration of a new MIME content-type, according to the registration template in section 2.
7. Acknowledgements
@@
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). |
Author's Address
Full Copyright Statement
Copyright (C) The Internet Society (2002). All Rights Reserved.
This document and translations of it may be copied and furnished to
others, and derivative works that comment on or otherwise explain it
or assist in its implementation may be prepared, copied, published and
distributed, in whole or in part, without restriction of any kind,
provided that the above copyright notice and this paragraph are
included on all such copies and derivative works. However, this
document itself may not be modified in any way, such as by removing
the copyright notice or references to the Internet Society or other
Internet organizations, except as needed for the purpose of
developing Internet standards in which case the procedures for
copyrights defined in the Internet Standards process must be
followed, or as required to translate it into languages other than
English.
The limited permissions granted above are perpetual and will not be
revoked by the Internet Society or its successors or assigns.
This document and the information contained herein is provided on an
"AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
Acknowledgement
Funding for the RFC Editor function is currently provided by the
Internet Society.
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.
- The namespace was changed to
http://www.w3.org/2002/07/owl.
- Various updates to RDF and RDF Schema from the
RDF Core Working Group were incorporated,
including
- cyclic subclasses are now allowed
- multiple
rdfs:domain
and
rdfs:range
properties are handled as intersection
- rdf:parseType="Collection"
replaces
rdf:parseType="daml:collection"
- RDF Model Theory
- datatypes?
- Qualified restrictions were removed from the language,
resulting in the removal of the following properties:
- daml:cardinalityQ
- daml:hasClassQ
- daml:maxCardinalityQ
- daml:minCardinalityQ
- Various properties and classes were renamed,
as shown in the following table:
-
owl:SymmetricProperty
was added.
- An
owl:DatatypeProperty
may be an
owl:InverseFunctionalProperty
in OWL Full.
-
Synonyms for RDF and RDF Schema classes and properties were removed from the language,
resulting in the removal of:
- daml:comment
- daml:domain
owl:domain may still be required as non-synonym
- daml:label
- daml:isDefinedBy
- daml:Literal
- daml:Property
- daml:range
owl:range may still be required as non-synonym
- daml:seeAlso
- daml:subClassOf
- daml:subPropertyOf
- daml:type
- daml:value
-
daml:disjointUnionOf
was removed from the language,
since it can be effected using
owl:unionOf
or
rdfs:subClassOf
and
owl:disjointWith.
-
daml:equivalentTo
was renamed to
owl:sameAs,
and is no longer a superproperty of
owl:sameClassAs,
owl:samePropertyAs,
and
owl:sameIndividualAs
-
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 Lite | OWL DL | OWL 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.
- Ontology/Class [owl:Class in OWL Lite]
- Ontology/SubClassOf [rdfs:subClassOf in OWL Lite]
- Ontology/EnumeratedClass [owl:oneOf in OWL Lite]
- Ontology/DisjointClasses [owl:disjointWith in OWL DL]
- Ontology/EquivalentClasses [owl:sameClassAs in OWL DL]
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.
<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).
<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.
- description/Class [OWL Lite]
- description/DataResriction [owl:Restriction in OWL Lite]
- description/IndividualRestriction [owl:Restriction in OWL Lite]
- description/UnionOf [owl:unionOf in OWL DL]
- description/IntersectionOf [owl:intersectionOf in OWL DL]
- description/ComplementOf [owl:complementOf in OWL DL]
- description/OneOf [owl:oneOf in OWL DL]
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.
<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).
<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).
<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.
<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).
<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.
- DataRestriction/allValuesFrom [owl:allValuesFrom in OWL Lite]
- DataRestriction/someValueFrom [owl:someValuesFrom in OWL Lite]
- DataRestriction/value [owl:hasValue in OWL DL]
- IndividualRestriction/allValuesFrom [owl:allValuesFrom in OWL Lite]
- IndividualRestriction/someValueFrom [owl:someValuesFrom in OWL Lite]
- IndividualRestriction/value [owl:hasValue in OWL DL]
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.
<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).
<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'.
<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).
<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'.
<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).
<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
<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
<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
<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
<!-- 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
<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>
<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
<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>
<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
<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>
<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
<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>
<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
<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>
<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
<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>
<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
- [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/.