NOTE-daml+oil-reference-20011218 64.7 KB

Raw Blame History Permalink

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta name="generator" content="HTML Tidy, see www.w3.org" />
  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
  <title>DAML+OIL (March 2001) Reference Description</title>
  <link rel="stylesheet" type="text/css"
    href="http://www.w3.org/StyleSheets/TR/W3C-NOTE" />
</head>

<body>
<div class="head"><a href="http://www.w3.org/"><img height="48"
width="72" alt="W3C" src="http://www.w3.org/Icons/w3c_home" /></a>

<h1>DAML+OIL (March 2001) Reference Description</h1>

<h2>W3C Note 18 December 2001</h2>

<dl>
<dt>This version:</dt>

<dd><a href="http://www.w3.org/TR/2001/NOTE-daml+oil-reference-20011218">http://www.w3.org/TR/2001/NOTE-daml+oil-reference-20011218</a></dd>

<dt>Latest version:</dt>

<dd><a href="http://www.w3.org/TR/daml+oil-reference">http://www.w3.org/TR/daml+oil-reference</a></dd>

<dt>Authors:</dt>

<dd>
<a href="http://www.w3.org/People/Connolly/">Dan Connolly</a><br />
<a href="http://www.cs.vu.nl/~frankh/"> Frank van Harmelen</a><br />
<a href="http://www.cs.man.ac.uk/~horrocks/"> Ian Horrocks</a><br />
<a href="http://www.ksl.stanford.edu/people/dlm/">Deborah L. McGuinness</a> <br />
<a href="http://www.bell-labs.com/user/pfps/"> Peter F. Patel-Schneider</a> <br />
<a href="http://faculty.olin.edu/~las/">Lynn Andrea Stein</a><br />
</dd>
</dl>

<p class="copyright">
&copy;2001
<a href="http://www.w3.org/People/Connolly/">Dan Connolly</a>,
<a href="http://www.cs.vu.nl/~frankh/"> Frank van Harmelen</a>,
<a href="http://www.cs.man.ac.uk/~horrocks/"> Ian Horrocks</a>,
<a href="http://www.ksl.stanford.edu/people/dlm/">Deborah L. McGuinness</a>,
<a href="http://faculty.olin.edu/~las/">Lynn Andrea Stein</a>,
and <a href="http://www.lucent.com/"> Lucent Technologies, Inc.</a>.
All Rights Reserved.
Distribution policies are governed by the W3C intellectual property <a
href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright"> terms</a>.</p>

<hr />
</div>

<h2><a id="abstract" name="abstract">Abstract</a></h2>

<p>
DAML+OIL is a semantic markup language for Web resources. It builds on
earlier W3C standards such as RDF and RDF Schema, and extends these languages
with richer modelling primitives. DAML+OIL provides modelling primitives
commonly found in frame-based languages. DAML+OIL (March 2001) extends
DAML+OIL (December 2000) with values from XML Schema datatypes. DAML+OIL
was built from the original DAML ontology language DAML-ONT (October 2000)
in an effort to combine many of the language components of
<a href="http://www.ontoknowledge.org/oil/">OIL</a>.
The language has a clean and well defined semantics.
</p>

<h2><a id="status" name="status">Status of this document</a></h2>

<p>This document is a submission to the <a href="http://www.w3.org/">World Wide Web Consortium</a> from Lucent Technologies (see <a href="/Submission/2001/12/">Submission Request</a>,
<a href="/Submission/2001/12/Comment">W3C Staff Comment</a>).</p>

<p>Please send comments to Peter F. Patel-Schneider
<a href="mailto:pfps@research.bell-labs.com">pfps@research.bell-labs.com</a>,
or, preferably, to the publicly archived
distribution list,
<a href="mailto:www-rdf-logic@w3.org">www-rdf-logic@w3.org</a>
[<a href="http://lists.w3.org/Archives/Public/www-rdf-logic/">archive</a>].</p>

<p>This document is a NOTE made available by the W3C for discussion only.
Publication of this Note by W3C indicates no endorsement by W3C or the W3C
Team, or any W3C Members. W3C has had no editorial control over the
preparation of this Note. This document is a work in progress and may be
updated, replaced, or rendered obsolete by other documents at any
time.</p>

<p>A list of current W3C technical documents can be found at the <a href="/TR/">
Technical Reports</a> page.</p>

<h2><a id="contents" name="contents">Table of contents</a></h2>

<ol>
  <li><a href="#1">Introductory remarks</a></li>
  <li><a href="#2">Language structure</a></li>
  <li><a href="#3">rdf:parseType="daml:collection"</a></li>
</ol>

<h2><a id="appendix" name="appendix">Appendices</a></h2>

<ul>
  <li>Appendix A. <a href="#appa">Index of all language elements</a></li>
  <li>Appendix B. <a href="#appb">Notes</a></li>
  <li>Appendix C. <a href="#appc">http://www.w3.org/2001/10/daml+oil</a></li>
</ul>

<hr />

<h2><a name="1"></a>1. Introductory remarks </h2>

<p>This document gives a systematic, compact and informal description of all
the modelling primitives of DAML+OIL (March 2001). We expect this document to serve as a
reference guide for users of the DAML+OIL language.</p>
<ul>
  <li>Readers unfamiliar with DAML+OIL should first consult the <a
    href="http://www.w3.org/TR/daml+oil-walkthru/">DAML+OIL walkthrough</a> for a more
    narrative description of an example use of the language.</li>
  <li>The normative reference on the precise syntax of the language constructs
    is the machine readable <a href="http://www.w3.org/2001/10/daml+oil">RDF Schema definition</a>
    of DAML+OIL, also included as <a href="#appb">Appendix C</a>.</li>
  <li>Two references that give a precise definition of the
	meaning of the language constructs are the
	<a href="http://www.w3.org/TR/daml+oil-model">model-theoretic semantics</a>
	and the
	<a href="http://www.w3.org/TR/daml+oil-axioms">KIF axiomatization</a>.
	</li>
</ul>


<p>A DAML+OIL knowledge base is a collection of RDF
triples. DAML+OIL prescribes a specific meaning for triples that use the
DAML+OIL vocabulary. This document informally specifies which collections of
RDF triples constitute the DAML+OIL vocabulary and what the prescribed meaning
of such triples is.</p>

<h3>Different syntactic forms</h3>

<p>As with any set of RDF triples, DAML+OIL triples can be
represented in many different syntactic forms (as described in the <a
href="http://www.w3.org/1999/02/22-rdf-syntax-ns">RDF specification)</a>. The
current document uses a specific RDF syntactic form for these triples.
However, <strong>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 form would then carry exactly the same
prescribed meaning as the equivalent syntactic form used in this
document</strong>. See <sup><a href="#Syntax">Syntax Note</a></sup> for an
example of this.</p>

<h3>Mixing DAML+OIL with arbitrary RDF</h3>

<p>As stated above, DAML+OIL assigns a specific meaning to
certain RDF triples. The <a
href="http://www.w3.org/TR/daml+oil-model">model-theoretic
semantics</a> specifies exactly which triples are assigned a specific meaning,
and what this meaning is. DAML+OIL only provides a semantic interpretation for
those parts of an RDF graph that instantiate the schema defined in <a
href="http://www.w3.org/2001/10/daml+oil">http://www.w3.org/2001/10/daml+oil</a>. Any additional RDF statements, resulting in additional RDF
triples are perfectly allowed, but DAML+OIL is silent on the semantic
consequences (or lack thereof) of such additional triples.
See <sup><a href="#Mixing">Mixing Note</a></sup> for an example of
this.
The KIF axiomatization provides a meaning for all RDF triples, but non
DAML+OIL triples are only modelled as triples, nothing deeper.
</p>

<h2><a name="2"></a>2. Language structure </h2>

<p>A DAML+OIL ontology is made up of several components, some of which are
optional, and some of which may be repeated. See <a href="#appa">the
index</a> for a listing of all these components.
Througout this document, DAML+OIL 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.
</p>

<p>A DAML+OIL ontology consists of zero or more <a
href="#Header">headers</a>, followed
by zero or more <a href="#Class">class elements</a>, <a
href="#Property">property elements</a>,
and <a href="#Instances">instances.</a></p>

<h3><a name="Header" id="Header">Header</a></h3>

<p><a name="Ontology-def" id="Ontology-def"></a>An <code>daml:Ontology</code>
element contains zero or more <a href="#Version">version information</a>
and <a href="#Imports">imports elements</a>.<br />
</p>
<pre>&lt;Ontology rdf:about=""&gt;
  &lt;versionInfo&gt;$Id: NOTE-daml+oil-reference-20011218.html,v 1.6 2001/12/18 22:12:09 connolly Exp $&lt;/versionInfo&gt;
  &lt;rdfs:comment&gt;An example ontology&lt;/rdfs:comment&gt;
  &lt;imports rdf:resource="http://www.w3.org/2001/10/daml+oil"/&gt;
&lt;/Ontology&gt;</pre>

<h3><a name="Version" id="Version">Version information</a></h3>

<p><a name="versionInfo-def" id="versionInfo-def"></a>The
<code>daml:versionInfo</code> element 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. See the example
above.</p>

<h3><a name="Imports" id="Imports">Imports</a></h3>

<p><a name="imports-def" id="imports-def"></a>
Each <code>daml:imports</code>
statement references another DAML+OIL ontology containing definitions
that apply to the current DAML+OIL resource.
Each reference consists of a URI specifying from where the
ontology is to be imported from. See the example above.
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. </p>

<p>Note that namespaces only provide a mechanism for
creating unique names for elements, and do not actually include
definitions in the way that imports does. Similarly, imports statements
do not set up a shorthand notation for names. Therefore, it is common to
have imports statements that correspond to each namespace. However,
additional imports may be used for ontologies that provide definitions
without introducing any new names.
</p>


<h3><a name="Objects" id="Object"></a>Objects and Datatype Values</h3>

<p>
DAML+OIL 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
DAML+OIL (or RDF). This part is called the object domain.
</p>

<p>
DAML+OIL 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
<a name="ObjectClass" id="ObjectClass"><tt>daml:Class</tt></a>, a
subclass of <tt>rdfs:Class</tt>.
DAML+OIL (March 2001) also allows the use of XML Schema datatypes to describe
(or define) part of the datatype domain.  These
datatypes are used within
DAML+OIL simply by including their URIs within a DAML+OIL ontology.
They are (implicitly) elements of
<a name="Datatype" id="Datatype"><tt>daml:Datatype</tt></a>.  Datatypes are not  DAML+OIL individual objects.
</p>

<h3><a name="Class" id="Class">Class elements</a></h3>

<p>
<a name="Class-def" id="Class-def"></a>
A class element, <code>daml:Class</code>, 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</p>
<ul>
  <li><a name="subClassOf-def" id="subClassOf-def"></a>zero or more
    <code>rdfs:subClassOf</code> elements (each containing a <a
    href="#Class1">class-expression</a>). <br />
    Each subClassOf element asserts that C is a subclass of the
    class-expression mentioned in the element. (Each class-expression defines
    a (possibly anonymous) class).<br />
    <strong>Warning:</strong> The <a
    href="http://www.w3.org/TR/2000/CR-rdf-schema-20000327/">RDF Schema
    specification</a> demands that the subclass-relation between classes must
    be acyclic. We believe this to be too restrictive, since a cycle of
    subclass relationships provides a useful way
    to assert equality between classes.  Consequently, DAML+OIL (March 2001) places
    no such restriction on the subClassOf relationship between classes;<br />
  </li>
  <li><a name="disjointWith-def" id="disjointWith-def"></a>zero or more
    <code>daml:disjointWith</code> elements (each containing a <a
    href="#Class1">class-expression</a>).<br />
    Each disjointWith element asserts that C is disjoint with the
    class-expression in the element (ie. C must have no instances in common
    with it);<br />
  </li>
  <li><a name="disjointUnionOf-def" id="disjointUnionOf-def"></a>zero or more
    <code>daml:disjointUnionOf</code> elements (each containing a list of <a
    href="#Class1">class-expressions</a>).<br />
    Each disjointUnionOf element asserts that C has the same instances as the
    disjoint union of the class-expressions element. More precisely: all of
    the classes defined by the class-expressions of a disjointUnionOf element
    must be pairwise disjoint (i.e. there can be no individual that is an
    instance of more than one of the class expressions in the list.), and
    their union must be equal to C;<br />
  </li>
  <li><a name="sameClassAs-def" id="sameClassAs-def"></a>zero or more
    <code>daml:sameClassAs</code> elements (each containing a <a
    href="#Class1">class-expression</a>).<br />
    Each 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);<br />
  </li>
  <li><a name="equivalentTo-def" id="equivalentTo-def"></a>  zero or more
    <code>daml:equivalentTo</code> elements (each
    containing a <a href="#Class1">class
    expression</a>)<br />
    When applied to a class, the equivalentTo element has
    the same semantics as the sameClassAs element.<br />
    <strong>Warning: </strong>the
    use of sameClassAs is favoured over the use of equivalentTo, since
    sameClassAs is declared as a subProperty of subClassOf, while equivalentTo
    is not. This makes the meaning of sameClassAs at least partly available to
    an RDF Schema-only agent, while the meaning of equivalentTo is completely
    opaque to such an agent.<br />
  </li>
  <li>zero or more <a href="#Boolean">boolean combinations</a> of class
    expressions. <br />
    The class C must be equivalent to the class defined by each of the boolean
    class expression,<br />
    and</li>
  <li>zero or more <a href="#Enumerated">enumeration</a> elements. <br />
    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).</li>
</ul>

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

<h3><a name="Class1" id="Class1">Class expressions</a></h3>

<p>A class expression is the name used in this document for either</p>
<ul>
  <li>a class name (a URI), or</li>
  <li>an <a href="#Enumerated">enumeration</a>, enclosed in
    <code>&lt;daml:Class&gt;...&lt;/daml:Class&gt;</code> tags, or</li>
  <li>a <a href="#Restriction">property-restriction</a>, or</li>
  <li>or a <a href="#Boolean">boolean combination</a> of class expressions,
    enclosed in <code>&lt;rdfs:Class&gt;...&lt;/rdfs:Class&gt;</code>
  tags</li>
</ul>

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

<p>Two class names are already predefined, namely the classes
<a name="Thing" id="Thing"><code>daml:Thing</code></a>
and <code>daml:Nothing</code>. Every
object is a member of <code>daml:Thing</code>, and no object is a member
<code>daml:Nothing</code>. Consequently, every class is a subclass of
<code>daml:Thing</code> and <code>daml:Nothing</code> is a subclass of
every class.</p>


<h3><a name="Enumerated" id="Enumerated">Enumerations</a></h3>

<p><a name="oneOf-def" id="oneOf-def"></a>An enumeration is a
<code>daml:oneOf</code> element, containing a list of the objects
that are its <a href="#Instances">instances</a>. <br />
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:<br />
</p>
<pre>&lt;daml:oneOf parseType="daml:collection"&gt;
  &lt;daml:Thing rdf:about="#Eurasia"/&gt;
  &lt;daml:Thing rdf:about="#Africa"/&gt;
  &lt;daml:Thing rdf:about="#North_America"/&gt;
  &lt;daml:Thing rdf:about="#South_America "/&gt;
  &lt;daml:Thing rdf:about="#Australia"/&gt;
  &lt;daml:Thing rdf:about="#Antarctica"/&gt;
&lt;/oneOf&gt;</pre>

<h3><a name="Restriction" id="Restriction">Property restrictions</a></h3>

<p>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,
<a name="ObjectRestriction" id="ObjectRestriction">ObjectRestriction</a>,
works on
<a href="#ObjectProperty">object properties</a>, i.e., properties that
relate objects to other objects.
The second kind,
<a name="DatatypeRestriction" id="DatatypeRestriction">DatatypeRestriction</a>,
works on
<a href="#DatatypeProperty">datatype properties</a>, 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 restrictions nor datatype restrictions, but these restrictions are not
handled within DAML+OIL.
</p>

<p>
<a name="Restriction-def" id="Restriction-def"></a>
<a name="onProperty-def" id="onProperty-def"></a>
A <code>daml:Restriction</code> element contains an
<code>daml:onProperty</code> element, which refers to a property name (a
URI) (we will refer to this property as P) and one or more of the
following</p>
<ul>
  <li>elements indicating the type of restriction:
    <ul>
      <li><a name="toClass-def" id="toClass-def"></a>a <code>daml:toClass</code>
        element (which contains a <a href="#Class1">class expression</a>
	).<br />
	A toClass 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;<br />
      </li>
      <li><a name="hasValue-def" id="hasValue-def"></a>a
      <code>daml:hasValue</code>
        element (which contains (a reference to) <a href="#Instances">an
	individual object</a> or a <a
	href="#Values">datatype value</a>).<br />
        A 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;<br />
      </li>
      <li><a name="hasClass-def" id="hasClass-def"></a>A
      <code>daml:hasClass</code>
        element (which contains a <a href="#Class1">class expression</a>
	or a <a href="#Datatype">datatype
	references</a>).<br />
        A hasClass 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.</li>
    </ul>
    Notice that a toClass 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
    hasClass 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.<br />
    Also notice that the correspondence of toClass with the universal
    quantifier means that a toClass 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 toClass restriction demands that all
    values of P belong to class P, and if no such values exist, the
    restriction is trivially true.<br />
  </li>
  <li>elements containing a non-negative integer (to which we will refer as N)
    indicating an unqualified cardinality restriction:
    <ul>
      <li><a name="cardinality-def" id="cardinality-def"></a>a
        <code>daml:cardinality</code> element.<br />
        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;<br />
      </li>
      <li><a name="maxCardinality-def" id="maxCardinality-def"></a>a
        <code>daml:maxCardinality</code> element.<br />
        This defines the class of all objects that have at most N
	distinct values for the property P;<br />
      </li>
      <li><a name="minCardinality-def" id="minCardinality-def"></a>a
        <code>daml:minCardinality</code> element.<br />
        This defines the class of all objects that have at least N
	distinct values for the property P.<br />
      </li>
    </ul>
  </li>
  <li>elements containing a non-negative integer (to which we will refer as
    N)indicating a qualified cardinality restriction, and containing a <a
    name="hasClassQ-def" id="hasClassQ-def"></a> <code>daml:hasClassQ</code>
    element, containing a <a href="#Class1">class expression</a> or a
    <a href="#Datatype">datatype references</a>:
    <ul>
      <li><a name="cardinalityQ-def" id="cardinalityQ-def"></a>a
        <code>daml:cardinalityQ</code> element.<br />
        This defines the class of all objects that have exactly N
	distinct values for the property P that are instances of the class
	expression or datatype
        (and possibly other values not belonging to the class expression
	or datatype). In
        other words: x is an instance of the defined class (x satisfies the
        restriction) if and only if there are exactly N distinct values y such
        that (x,y) is an instance of P and y is an instance of the class
        expression or datatype;<br />
      </li>
      <li><a name="maxCardinalityQ-def" id="maxCardinalityQ-def"></a>a
        <code>daml:maxCardinalityQ</code> element.<br />
        This defines the class of all objects that have at most N
	distinct values for the property P that are instances of the class
	expression or datatype
        (and possibly other values not belonging to the class expression
	or datatype);<br />
      </li>
      <li><a name="minCardinalityQ-def" id="minCardinalityQ-def"></a>a
        <code>daml:minCardinalityQ</code> element.<br />
        This defines the class of all objects that have at least N
	distinct values for the property P that are instances of the class
	expression or datatype
        (and possibly other values not belonging to the class
      expression or datatype).</li>
    </ul>
    <p>Of course a cardinality constraint is simply shorthand for a pair of
    minCardinality and maxCardinality constraints with equal values of N (and
    similarly for cardinalityQ). <br />
    <strong><a name="Warning" id="Warning">Warning</a>:</strong> in order to
    avoid "exposed content" (i.e., to hide DAML+OIL annotations from
    browsers), it is necessary to write cardinality constraints in an
    alternative RDF format. See <sup><a
    href="#Cardinalit">Cardinality Syntax Note</a></sup>for
    an example of this.</p>
  </li>
</ul>

<p>When there are multiple restrictions listed
as part of a single Restriction element, the property P has to satisfy all of
the restrictions (i.e., multiple restrictions are read as a
conjunction).</p>

<p>Notice that the restrictedBy element which was
associated with slot-restrictions in earlier versions of the language has now
been removed, since it is completely synonymous with subClassOf.</p>

<h3><a name="Boolean" id="Boolean">Boolean combination of class
expressions</a></h3>

<p>A boolean combination of class expressions can be constructed from:</p>
<ul>
  <li><a name="intersectionOf-def" id="intersectionOf-def"></a>an
    <code>daml:intersectionOf</code> element, containing a list of <a
    href="#Class1">class expressions.</a> <br />
    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;<br />
  </li>
  <li><a name="unionOf-def" id="unionOf-def"></a>a <code>daml:unionOf</code>
    element, containing a list of <a href="#Class1">class
    expressions.</a> <br />
    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;</li>
  <li><a name="complementOf-def" id="complementOf-def"></a>a
    <code>daml:complementOf</code> element, containing a single <a
    href="#Class1">class expression.</a><br />
    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.</li>
</ul>

<p>Note that arbitrarily complex combinations of these expressions can be
formed.  See <sup><a
href="#Boolean1">Boolean Note</a></sup>for an example of
this.</p>

<h3><a name="Property-def" id="Property-def"></a><a name="Property"
id="Property">Property elements</a></h3>

<p>A <code>rdf:Property</code> 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
properties, which relate objects to other objects, and are instances of
<a name="ObjectProperty"
id="ObjectProperty"><tt>ObjectProperty</tt></a>;
or
datatype properties, which relate objects to datatype
values, and are instances of
<a name="DatatypeProperty"
id="DatatypeProperty"><tt>DatatypeProperty</tt></a>.
</p>

<p>
A property element contains:
</p>
<ul>
  <li><a name="subPropertyOf-def" id="subPropertyOf-def"></a>zero or more
    <code>rdfs:subPropertyOf</code> elements, each containing a property
    name.<br />
    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;<br />
  </li>
  <li><a name="domain-def" id="domain-def"></a>zero or more
    <code>rdfs:domain</code> elements (each containing a <a
    href="#Class1">class expression</a>).<br />
    Each 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. <br />
    <strong>Warning:</strong> This is contrary to the semantics of the domain
    element in the <a
    href="http://www.w3.org/TR/2000/CR-rdf-schema-20000327/">RDF Schema
    specification</a>, which we believe to be flawed. Note that unlike any of
    the <a href="#Restriction">property restrictions</a> mentioned above, these
    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, 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;<br />
    Because of this, domain elements should be used with
    great care in DAML+OIL.</li>
  <li><a name="range-def" id="range-def"></a>zero or more
    <code>rdfs:range</code>
    elements (each containing a <a href="#Class1">class expression</a>).<br />
    Each 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.<br />
    <strong>Warning:</strong> Although the <a
    href="http://www.w3.org/TR/2000/CR-rdf-schema-20000327/">RDF Schema
    specification</a> only allows one range restriction for each property, it
    seems quite natural to allow multiple range restrictions. These would then
    again be interpreted as saying that the range of P must be the
    intersection of all the class expressions. Furthermore, as with domain
    restrictions, range restrictions are global, by virtue of RDF Schema;<br
    />
    Because of this, range elements should be used with
    great care in DAML+OIL.</li>
  <li><a name="samePropertyAs-def" id="samePropertyAs-def"></a>zero or more
    <code>daml:samePropertyAs</code> elements (each containing a property
    name).<br />
    Each samePropertyAs element asserts that P is equivalent to the named
    property (i.e. they must have the same instances),<br />
  </li>
  <li>zero or more <code>equivalentTo</code> elements (each
    containing a property name).<br />
    When applied to a property, the equivalentTo element
    has the same semantics as the samePropertyAs element;<br />
    <strong>Warning:</strong> the use of samePropertyAs is
    favoured over the use of equivalentTo, since samePropertyAs is declared as
    a subProperty of subPropertyOf, while equivalentTo is not. This makes the
    meaning of samePropertyAs at least partly available to an RDF Schema-only
    agent, while the meaning of equivalentTo is completely opaque to such an
    agent.<br />
    and<br />
  </li>
  <li><a name="inverseOf-def" id="inverseOf-def"></a>zero or more
    <code>daml:inverseOf</code> elements (each containing a property name),
    for properties only.<br />
    Each 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.</li>
</ul>

<p>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:</p>
<ul>
  <li><a name="TransitiveProperty-def" id="TransitiveProperty-def"></a>a
    <code>daml:TransitiveProperty</code> element, which is a
    subclass of <tt>ObjectProperty</tt>.<br />
    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;<br />
  </li>
  <li><a name="UniqueProperty-def" id="UniqueProperty-def"></a>a
    <a name="UniqueProp" id="UniqueProp"><code>daml:UniqueProperty</code></a>
    element.<br />
    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 maxCardinality restriction of 1,<br />
    or</li>
  <li><a name="UnambigousProperty-def" id="UnambigousProperty-def"></a>an
    <code>daml:UnambigousProperty</code> element, which is a
    subclass of <tt>ObjectProperty</tt>.<br />
    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. Notice that the
    inverse property of a UniqueProperty is always an UnambigousProperty and
    vice versa.</li>
</ul>

<p>Notice that UniqueProperty and UnambiguousProperty
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 <a href="#Restriction">property
restrictions</a>, which are part of a
class element, and are only enforced on the property when applied to that
class.<br />
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.<br />
<strong>Warning:</strong> If a transitive property (or any of its
superproperties) is used in a cardinality constraint, then class consistency
is no longer necessarily decidable. Of course, UniqueProperty is a a particular case of a
cardinality constraint.</p>


<h3><a name="Instances" id="Instances">Instances</a></h3>

<p>Instances of both classes
(i.e., objects) and of properties (i.e., pairs) are written in
<a href="http://www.w3.org/TR/REC-rdf-syntax/">RDF</a> and
<a href="http://www.w3.org/TR/2000/CR-rdf-schema-20000327/">RDF Schema</a>
syntax.
<br />
See the specification of these languages for more details on the various
syntactic forms that are allowed. Here we list just some of the most common
notations:<br />
</p>
<pre>&lt;continent rdf:ID="Asia"/&gt;

&lt;rdf:Description rdf:ID="Asia"&gt;
  &lt;rdf:type&gt;
   &lt;rdfs:Class rdf:about="#continent"/&gt;
  &lt;/rdf:type&gt;
&lt;/rdf:Description&gt;

&lt;rdf:Description rdf:ID="India"&gt;
  &lt;is_part_of rdf:resource="#Asia"/&gt;
&lt;/rdf:Description&gt;</pre>

<p>
There is no unique name assumption for objects in DAML+OIL.
To state that objects are the same, a
<a name="sameIndividualAs-def"><code>daml:sameIndividualAs</code></a> element
is used.
(Note that <code>daml:equivalentTo</code> can be also used here, but
<code>daml:sameIndividual</code> is preferred.
To state that objects are distinct,
a <a name="differentIndividualFrom-def"><code>daml:differentIndividualFrom</code></a>
element is used.
The situation is different for datatype values, where XML Schema Datatype
identity is used.
</p>

<h3><a name="Values" id="Values">Datatype Values</a></h3>

<p>
Datatype values are written in a manner that is valid RDF syntax, but which
is given a special semantics in DAML+OIL.
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 <tt>rdf:type</tt> of the value, and the
lexical representation is the <tt>rdf:value</tt> of the value.
So the decimal 10.5 could be input as
<tt>&lt;xsd:decimal rdf:value="10.5"&gt;</tt>
provided that <tt>xsd</tt> was defined as the URI of the XML Schema
Datatype specification.
</p>

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

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


<h2><a name="3">3. rdf:parseType="daml:collection"</a></h2>

<p>DAML+OIL needs to represent unordered collections of items
(also known as bags, or multisets) in a number of constructions, such as
intersectionOf, unionOf, oneOf, and disjointUnionOf.
DAML+OIL exploits the rdf:parseType attribute to extend the syntax for RDF
with a convenient notation for such collections. Whenever an element has the
rdf:parseType attribute with value "daml:collection", the enclosed elements
must be interpreted as elements in a list structure, constructed using the
elements List, first, rest and nil.</p>

<p>For example, the statement</p>
<pre>&lt;oneOf rdf:parseType="daml:collection"&gt;
  &lt;Thing rdf:about="#red"/&gt;
  &lt;Thing rdf:about="#white"/&gt;
  &lt;Thing rdf:about="#blue"/&gt;
&lt;/oneOf&gt;</pre>

<p>should be interpreted as the following construction (also
known as a consed-pair construction, from Lisp-lore):</p>
<pre>&lt;List&gt;
 &lt;first&gt;
  &lt;Thing rdf:about="#red"&gt;
 &lt;/first&gt;
 &lt;rest&gt;
  &lt;List&gt;
   &lt;first&gt;
    &lt;Thing rdf:about="#white"&gt;
   &lt;/first&gt;
   &lt;rest&gt;
    &lt;List&gt;
     &lt;first&gt;
      &lt;Thing rdf:about="#blue"&gt;
     &lt;/first&gt;
     &lt;rest&gt;
      &lt;List rdf:resource="http://www.w3.org/2001/10/daml+oil#nil"&gt;
     &lt;/rest&gt;
    &lt;/List&gt;
   &lt;/rest&gt;
  &lt;/List&gt;
 &lt;/rest&gt;
&lt;/List&gt;</pre>

<p>Current RDF parsers (<a
href="http://www.w3.org/TR/1999/REC-rdf-syntax-19990222/">RDF specification of
February '99</a>) will not support the daml:collection parseType. In order to
process DAML+OIL documents, such parsers will have to be extended, or a
separate preprocessing stage is required which translates the first form above
into the second before the DAM+OIL code is given as input to the RDF
parser.</p>

<p>Note that structures of parseType daml:collection are
intended to represent <em>unordered</em> collections, even
though the RDF datastructure imposes a specific order on the elements.</p>

<h2><a name="appa" id="appa">Appendix A. Index of all language elements</a></h2>
<ul>
  <li><a href="#cardinality-def">cardinality</a></li>
  <li><a href="#cardinalityQ-def">cardinalityQ</a></li>
  <li><a href="#Class-def">Class</a></li>
  <li><a href="#complementOf-def">complementOf</a></li>
  <li><a href="#Datatype">Datatype</a></li>
  <li><a href="#DatatypeProperty">DatatypeProperty</a></li>
  <li><a href="#DatatypeRestriction">DatatypeRestriction</a></li>
  <li><a href="#Values">Datatype value</a></li>
  <li><a href="#differentIndividualFrom-def">differentIndividualFrom</a></li>
  <li><a href="#disjointUnionOf-def">disjointUnionOf</a></li>
  <li><a href="#disjointWith-def">disjointWith</a></li>
  <li><a href="#domain-def">domain</a></li>
  <li><a href="#equivalentTo-def">equivalentTo</a></li>
  <li><a href="#hasClass-def">hasClass</a></li>
  <li><a href="#hasClassQ-def">hasClassQ</a></li>
  <li><a href="#hasValue-def">hasValue</a></li>
  <li><a href="#imports-def">imports</a></li>
  <li><a href="#intersectionOf-def">intersectionOf</a></li>
  <li><a href="#inverseOf-def">inverseOf</a></li>
  <li><a href="#maxCardinality-def">maxCardinality</a></li>
  <li><a href="#maxCardinalityQ-def">maxCardinalityQ</a></li>
  <li><a href="#minCardinality-def">minCardinality</a></li>
  <li><a href="#minCardinalityQ-def">minCardinalityQ</a></li>
  <li><a href="#ObjectClass">ObjectClass</a></li>
  <li><a href="#ObjectProperty">ObjectProperty</a></li>
  <li><a href="#ObjectRestriction">ObjectRestriction</a></li>
  <li><a href="#oneOf-def">oneOf</a></li>
  <li><a href="#onProperty-def">onProperty</a></li>
  <li><a href="#Ontology-def">Ontology</a></li>
  <li><a href="#Property-def">Property</a></li>
  <li><a href="#range-def">range</a></li>
  <li><a href="#Restriction-def">Restriction</a></li>
  <li><a href="#sameClassAs-def">sameClassAs</a></li>
  <li><a href="#sameIndividualAs-def">sameIndividualAs</a></li>
  <li><a href="#samePropertyAs-def">samePropertyAs</a></li>
  <li><a href="#subClassOf-def">subClassOf</a></li>
  <li><a href="#subPropertyOf-def">subPropertyOf</a></li>
  <li><a href="#toClass-def">toClass</a></li>
  <li><a href="#TransitiveProperty-def">TransitiveProperty</a></li>
  <li><a href="#UnambigousProperty-def">UnambigousProperty</a></li>
  <li><a href="#unionOf-def">unionOf</a></li>
  <li><a href="#UniqueProperty-def">UniqueProperty</a></li>
  <li><a href="#versionInfo-def">versionInfo</a></li>
</ul>

<h2><a name="appb" id="appb"></a>Appendix B. Notes</h2>
<dl>

  <dt><a name="Syntax" id="Syntax"></a>Syntax Note:</dt>
    <dd>As a simple example of an alternative syntactic
      form resulting in the same set of RDF triples, consider the statement in
      this document that "a DAML+OIL class definition consists at least of an
      rdfs:class element", which suggests the following syntactic form:

      <pre>&lt;rdfs:Class ID="Continents"/&gt; </pre>
      <br />
      <p>However, the following RDF statement:</p>
      <pre>&lt;rdf:Description ID="Continents"&gt;
  &lt;rdf:Type resource="http://www.w3.org/2000/01/rdf-schema#Class"/&gt;
&lt;/rdf:Description&gt; </pre>
      <p><br />
      results in exactly the same set of RDF triples, and is therefore
      perfectly allowed as a class definition.</p>
      <p>Another example is the two notations that we
      discuss for cardinality constraints <a
      href="#Cardinalit">below</a>. Again, both these forms
      result in the same set of RDF triples, and are thus equivalent.<br />
      <br />
      </p>
    </dd>

  <dt><a name="Mixing" id="Mixing">Mixing
  Note</a>:</dt>
    <dd>For example, take the class definition for Person
      from <a href="daml+oil-ex.daml">daml+oil-ex.daml</a>, and then
      add
      <pre>&lt;rdf:Description about="#Person"&gt;
     &lt;Creator&gt;Ora Lassila&lt;/Creator&gt;
&lt;/rdf:Description&gt;</pre>
      <p><br />
      then 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).<br />
      <br />
      </p>
    </dd>

  <dt><a name="Cardinalit" id="Cardinalit">Cardinality
  Syntax Note</a>:</dt>
    <dd>As an example of content-hiding syntax for
      cardinality expressions, instead of the standard notation:<br />

      <pre>&lt;Restriction&gt;
  &lt;onProperty rdf:resource="#father"/&gt;
  &lt;cardinality&gt;1&lt;/cardinality&gt;
&lt;/Restriction&gt;</pre>
      <p>we would have to write<br />
      </p>
      <pre>&lt;Restriction cardinality="1"&gt;
  &lt;onProperty rdf:resource="#father"/&gt;
&lt;/Restriction&gt; </pre>
      <p>to avoid any exposed content. The cardinality
      elements are the only ones for which this alternative notation is
      required to avoid exposed content. (See <a
      href="http://www.w3.org/TR/1999/REC-rdf-syntax-19990222/#abbreviatedSyntax">
      the section on abbreviated syntax</a>in
      the RDF specification for more details on this notation).<br />
      </p>
    </dd>

  <dt><a name="Boolean1" id="Boolean1">Boolean
  Note</a>:</dt>
    <dd>As an example of a combination of boolean
      operators, the expression "neither meat nor fish" could be written
      as:<br />

      <pre>&lt;complementOf&gt;
 &lt;Class&gt;
  &lt;unionOf parseType="daml:collection"&gt;
   &lt;Class rdf:resource="#meat"/&gt;
   &lt;Class rdf:resource="#fish"/&gt;
  &lt;/unionOf&gt;
 &lt;/Class&gt;
&lt;/complementOf&gt;</pre>
      <br />
    </dd>

</dl>

<h2><a name="appc" id="appc"></a>Appendix C. http://www.w3.org/2001/10/daml+oil</h2>

<pre>
&lt;!-- $Revision: 1.6 $ of $Date: 2001/12/18 22:12:09 $. --&gt;

&lt;rdf:RDF
  xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
  xmlns:daml="http://www.w3.org/2001/10/daml+oil#"
  xmlns     ="http://www.w3.org/2001/10/daml+oil#"
&gt;

&lt;rdf:Description rdf:about=""&gt;
  &lt;versionInfo&gt;$Id: NOTE-daml+oil-reference-20011218.html,v 1.6 2001/12/18 22:12:09 connolly Exp $&lt;/versionInfo&gt;
  &lt;imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/&gt;
&lt;/rdf:Description&gt;

&lt;!-- (meta) classes of "object" and datatype classes  --&gt;

&lt;rdfs:Class rdf:ID="Class"&gt;
  &lt;rdfs:label&gt;Class&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    The class of all "object" classes
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subClassOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/&gt;
&lt;/rdfs:Class&gt;

&lt;rdfs:Class rdf:ID="Datatype"&gt;
  &lt;rdfs:label&gt;Datatype&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    The class of all datatype classes
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subClassOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/&gt;
&lt;/rdfs:Class&gt;

&lt;!-- Pre-defined top/bottom thing/nothing most/least-general (object) classes. --&gt;

&lt;Class rdf:ID="Thing"&gt;
  &lt;rdfs:label&gt;Thing&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    The most general (object) class in DAML.
    This is equal to the union of any class and its complement.
  &lt;/rdfs:comment&gt;
  &lt;unionOf rdf:parseType="daml:collection"&gt;
    &lt;rdfs:Class rdf:about="#Nothing"/&gt;
    &lt;rdfs:Class&gt;
      &lt;complementOf rdf:resource="#Nothing"/&gt;
    &lt;/rdfs:Class&gt;
  &lt;/unionOf&gt;
&lt;/Class&gt;

&lt;Class rdf:ID="Nothing"&gt;
  &lt;rdfs:label&gt;Nothing&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;the class with no things in it.&lt;/rdfs:comment&gt;
  &lt;complementOf rdf:resource="#Thing"/&gt;
&lt;/Class&gt;

&lt;!-- Terms for building classes from other classes. --&gt;

&lt;rdf:Property rdf:ID="equivalentTo"&gt; &lt;!-- equals? equiv? renames? --&gt;
  &lt;rdfs:label&gt;equivalentTo&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for equivalentTo(X, Y), read X is an equivalent term to Y.
  &lt;/rdfs:comment&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="sameClassAs"&gt;
  &lt;rdfs:label&gt;sameClassAs&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for sameClassAs(X, Y), read X is an equivalent class to Y.
    cf OIL Equivalent
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subPropertyOf rdf:resource="#equivalentTo"/&gt;
  &lt;rdfs:subPropertyOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#subClassOf"/&gt;
  &lt;rdfs:domain rdf:resource="#Class"/&gt;
  &lt;rdfs:range rdf:resource="#Class"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="samePropertyAs"&gt;
  &lt;rdfs:label&gt;samePropertyAs&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for samePropertyAs(P, R), read P is an equivalent property to R.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subPropertyOf rdf:resource="#equivalentTo"/&gt;
  &lt;rdfs:subPropertyOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#subPropertyOf"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="sameIndividualAs"&gt;
  &lt;rdfs:label&gt;sameIndividualAs&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for sameIndividualAs(a, b), read a is the same individual as b.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subPropertyOf rdf:resource="#equivalentTo"/&gt;
  &lt;rdfs:domain rdf:resource="#Thing"/&gt;
  &lt;rdfs:range rdf:resource="#Thing"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="disjointWith"&gt;
  &lt;rdfs:label&gt;disjointWith&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for disjointWith(X, Y) read: X and Y have no members in common.
    cf OIL Disjoint
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Class"/&gt;
  &lt;rdfs:range rdf:resource="#Class"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="differentIndividualFrom"&gt;
  &lt;rdfs:label&gt;differentIndividualFrom&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for differentIndividualFrom(a, b), read a is not the same individual as b.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Thing"/&gt;
  &lt;rdfs:range rdf:resource="#Thing"/&gt;
&lt;/rdf:Property&gt;


&lt;!-- NOTE: the Disjoint class has been deleted: use disjointWith --&gt;
&lt;!-- or disjointUnionOf instead. --&gt;

&lt;rdf:Property rdf:ID="unionOf"&gt;
  &lt;rdfs:label&gt;unionOf&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for unionOf(X, Y) read: X is the union of the classes in the list Y;
    i.e. if something is in any of the classes in Y, it's in X, and vice versa.
    cf OIL OR
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Class"/&gt;
  &lt;rdfs:range rdf:resource="#List"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="disjointUnionOf"&gt;
  &lt;rdfs:label&gt;disjointUnionOf&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for disjointUnionOf(X, Y) read: X is the disjoint union of the classes in
    the list Y: (a) for any c1 and c2 in Y, disjointWith(c1, c2),
    and (b) unionOf(X, Y). i.e. if something is in any of the classes in Y, it's
    in X, and vice versa.
    cf OIL disjoint-covered
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Class"/&gt;
  &lt;rdfs:range rdf:resource="#List"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="intersectionOf"&gt;
  &lt;rdfs:label&gt;intersectionOf&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for intersectionOf(X, Y) read: X is the intersection of the classes in the list Y;
    i.e. if something is in all the classes in Y, then it's in X, and vice versa.
    cf OIL AND
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Class"/&gt;
  &lt;rdfs:range rdf:resource="#List"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="complementOf"&gt;
  &lt;rdfs:label&gt;complementOf&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for complementOf(X, Y) read: X is the complement of Y; if something is in Y,
    then it's not in X, and vice versa.
    cf OIL NOT
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Class"/&gt;
  &lt;rdfs:range rdf:resource="#Class"/&gt;
&lt;/rdf:Property&gt;

&lt;!-- Term for building classes by enumerating their elements --&gt;

&lt;rdf:Property rdf:ID="oneOf"&gt;
  &lt;rdfs:label&gt;oneOf&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
     for oneOf(C, L) read everything in C is one of the
     things in L;
     This lets us define classes by enumerating the members.
     cf OIL OneOf
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Class"/&gt;
  &lt;rdfs:range rdf:resource="#List"/&gt;
&lt;/rdf:Property&gt;

&lt;!-- Terms for building classes by restricting their properties. --&gt;

&lt;rdfs:Class rdf:ID="Restriction"&gt;
  &lt;rdfs:label&gt;Restriction&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    something is in the class R if it satisfies the attached restrictions,
    and vice versa.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subClassOf rdf:resource="#Class"/&gt;
&lt;/rdfs:Class&gt;

&lt;rdf:Property rdf:ID="onProperty"&gt;
  &lt;rdfs:label&gt;onProperty&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P), read:
    R is a restricted with respect to property P.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="toClass"&gt;
  &lt;rdfs:label&gt;toClass&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P) and toClass(R, X), read:
    i is in class R if and only if for all j, P(i, j) implies type(j, X).
    cf OIL ValueType
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="hasValue"&gt;
  &lt;rdfs:label&gt;hasValue&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P) and hasValue(R, V), read:
    i is in class R if and only if P(i, V).
    cf OIL HasFiller
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="hasClass"&gt;
  &lt;rdfs:label&gt;hasClass&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P) and hasClass(R, X), read:
    i is in class R if and only if for some j, P(i, j) and type(j, X).
    cf OIL HasValue
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/&gt;
&lt;/rdf:Property&gt;

&lt;!-- Note that cardinality restrictions on transitive properties, or     --&gt;
&lt;!-- properties with transitive sub-properties, compromise decidability. --&gt;

&lt;rdf:Property rdf:ID="minCardinality"&gt;
  &lt;rdfs:label&gt;minCardinality&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P) and minCardinality(R, n), read:
    i is in class R if and only if there are at least n distinct j with P(i, j).
    cf OIL MinCardinality
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="maxCardinality"&gt;
  &lt;rdfs:label&gt;maxCardinality&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P) and maxCardinality(R, n), read:
    i is in class R if and only if there are at most n distinct j with P(i, j).
    cf OIL MaxCardinality
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="cardinality"&gt;
  &lt;rdfs:label&gt;cardinality&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P) and cardinality(R, n), read:
    i is in class R if and only if there are exactly n distinct j with P(i, j).
    cf OIL Cardinality
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="hasClassQ"&gt;
  &lt;rdfs:label&gt;hasClassQ&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    property for specifying class restriction with cardinalityQ constraints
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="minCardinalityQ"&gt;
  &lt;rdfs:label&gt;minCardinality&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P), minCardinalityQ(R, n) and hasClassQ(R, X), read:
    i is in class R if and only if there are at least n distinct j with P(i, j)
    and type(j, X).
    cf OIL MinCardinality
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="maxCardinalityQ"&gt;
  &lt;rdfs:label&gt;maxCardinality&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P), maxCardinalityQ(R, n) and hasClassQ(R, X), read:
    i is in class R if and only if there are at most n distinct j with P(i, j)
    and type(j, X).
    cf OIL MaxCardinality
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="cardinalityQ"&gt;
  &lt;rdfs:label&gt;cardinality&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for onProperty(R, P), cardinalityQ(R, n) and hasClassQ(R, X), read:
    i is in class R if and only if there are exactly n distinct j with P(i, j)
    and type(j, X).
    cf OIL Cardinality
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#Restriction"/&gt;
  &lt;rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/&gt;
&lt;/rdf:Property&gt;

&lt;!-- Classes and Properties for different kinds of Property --&gt;

&lt;rdfs:Class rdf:ID="ObjectProperty"&gt;
  &lt;rdfs:label&gt;ObjectProperty&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    if P is an ObjectProperty, and P(x, y), then y is an object.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/&gt;
&lt;/rdfs:Class&gt;

&lt;rdfs:Class rdf:ID="DatatypeProperty"&gt;
  &lt;rdfs:label&gt;DatatypeProperty&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    if P is a DatatypeProperty, and P(x, y), then y is a data value.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/&gt;
&lt;/rdfs:Class&gt;

&lt;rdf:Property rdf:ID="inverseOf"&gt;
  &lt;rdfs:label&gt;inverseOf&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for inverseOf(R, S) read: R is the inverse of S; i.e.
    if R(x, y) then S(y, x) and vice versa.
    cf OIL inverseRelationOf
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#ObjectProperty"/&gt;
  &lt;rdfs:range rdf:resource="#ObjectProperty"/&gt;
&lt;/rdf:Property&gt;

&lt;rdfs:Class rdf:ID="TransitiveProperty"&gt;
  &lt;rdfs:label&gt;TransitiveProperty&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    if P is a TransitiveProperty, then if P(x, y) and P(y, z) then P(x, z).
    cf OIL TransitiveProperty.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subClassOf rdf:resource="#ObjectProperty"/&gt;
&lt;/rdfs:Class&gt;

&lt;rdfs:Class rdf:ID="UniqueProperty"&gt;
  &lt;rdfs:label&gt;UniqueProperty&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    compare with maxCardinality=1; e.g. integer successor:
    if P is a UniqueProperty, then if P(x, y) and P(x, z) then y=z.
    cf OIL FunctionalProperty.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/&gt;
&lt;/rdfs:Class&gt;

&lt;rdfs:Class rdf:ID="UnambiguousProperty"&gt;
  &lt;rdfs:label&gt;UnambiguousProperty&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    if P is an UnambiguousProperty, then if P(x, y) and P(z, y) then x=z.
    aka injective. e.g. if firstBorne(m, Susan)
    and firstBorne(n, Susan) then m and n are the same.
  &lt;/rdfs:comment&gt;
  &lt;rdfs:subClassOf rdf:resource="#ObjectProperty"/&gt;
&lt;/rdfs:Class&gt;

&lt;!-- List terminology. --&gt;

&lt;rdfs:Class rdf:ID="List"&gt;
  &lt;rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq"/&gt;
&lt;/rdfs:Class&gt;

&lt;List rdf:ID="nil"&gt;
  &lt;rdfs:comment&gt;
     the empty list; this used to be called Empty.
  &lt;/rdfs:comment&gt;
&lt;/List&gt;

&lt;rdf:Property rdf:ID="first"&gt;
  &lt;rdfs:domain rdf:resource="#List"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="rest"&gt;
  &lt;rdfs:domain rdf:resource="#List"/&gt;
  &lt;rdfs:range rdf:resource="#List"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="item"&gt;
  &lt;rdfs:comment&gt;
    for item(L, I) read: I is an item in L; either first(L, I)
    or item(R, I) where rest(L, R).
  &lt;/rdfs:comment&gt;
  &lt;rdfs:domain rdf:resource="#List"/&gt;
&lt;/rdf:Property&gt;

&lt;!-- A class for ontologies themselves... --&gt;

&lt;rdfs:Class rdf:ID="Ontology"&gt;
  &lt;rdfs:label&gt;Ontology&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    An Ontology is a document that describes
    a vocabulary of terms for communication between
    (human and) automated agents.
  &lt;/rdfs:comment&gt;
&lt;/rdfs:Class&gt;

&lt;rdf:Property rdf:ID="versionInfo"&gt;
  &lt;rdfs:label&gt;versionInfo&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    generally, a string giving information about this
    version; e.g. RCS/CVS keywords
  &lt;/rdfs:comment&gt;
&lt;/rdf:Property&gt;

&lt;!-- Importing, i.e. assertion by reference --&gt;

&lt;rdf:Property rdf:ID="imports"&gt;
  &lt;rdfs:label&gt;imports&lt;/rdfs:label&gt;
  &lt;rdfs:comment&gt;
    for imports(X, Y) read: X imports Y;
    i.e. X asserts the* contents of Y by reference;
    i.e. if imports(X, Y) and you believe X and Y says something,
    then you should believe it.
    Note: "the contents" is, in the general case,
    an il-formed definite description. Different
    interactions with a resource may expose contents
    that vary with time, data format, preferred language,
    requestor credentials, etc. So for "the contents",
    read "any contents".
  &lt;/rdfs:comment&gt;
&lt;/rdf:Property&gt;

&lt;!-- Importing terms from RDF/RDFS --&gt;

&lt;!-- first, assert the contents of the RDF schema by reference --&gt;
&lt;Ontology rdf:about=""&gt;
  &lt;imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/&gt;
&lt;/Ontology&gt;

&lt;rdf:Property rdf:ID="subPropertyOf"&gt;
  &lt;samePropertyAs  rdf:resource="http://www.w3.org/2000/01/rdf-schema#subPropertyOf"/&gt;
&lt;/rdf:Property&gt;

&lt;rdfs:Class rdf:ID="Literal"&gt;
  &lt;sameClassAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/&gt;
&lt;/rdfs:Class&gt;

&lt;rdfs:Class rdf:ID="Property"&gt;
  &lt;sameClassAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/&gt;
&lt;/rdfs:Class&gt;

&lt;rdf:Property rdf:ID="type"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#type"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="value"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#value"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="subClassOf"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#subClassOf"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="domain"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#domain"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="range"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#range"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="label"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#label"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="comment"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#comment"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="seeAlso"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#seeAlso"/&gt;
&lt;/rdf:Property&gt;

&lt;rdf:Property rdf:ID="isDefinedBy"&gt;
  &lt;samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#isDefinedBy"/&gt;
  &lt;rdfs:subPropertyOf rdf:resource="#seeAlso"/&gt;
&lt;/rdf:Property&gt;

&lt;/rdf:RDF&gt;
</pre>


<hr />
<h2><a id="acknowledgments" name="acknowledgments">Acknowledgments</a></h2>

<p>
The following individuals were also involved in preparing the DAML+OIL (March
2001) release. See individual documents and previous releases for additional
information.
</p>
<ul>
<li> <a href="http://www.w3.org/People/Berners-Lee/">Tim Berners-Lee</a></li>
<li> <a href="http://rdfweb.org/people/danbri/">Dan Brickley</a></li>
<li> <a href="http://www.daml.org/people/mdean/">Mike Dean</a></li>
<li> <a href="http://www-db.stanford.edu/~stefan/"> Stefan Decker</a></li>
<li> <a href="http://www.cs.vu.nl/~dieter/">Dieter Fensel</a></li>
<li> <a href="http://www.coginst.uwf.edu/~phayes/">Pat Hayes</a></li>
<li> <a href="http://www.cse.lehigh.edu/~heflin/">Jeff Heflin</a></li>
<li> <a href="http://www.cs.umd.edu/users/hendler/">Jim Hendler</a></li>
<li> <a href="http://www.lassila.org/">Ora Lassila</a></li>
</ul>
<p>
The contributions of participants on the <a
href="http://lists.w3.org/Archives/Public/www-rdf-logic/">www-rdf-logic@w3.org</a>
email list are also acknowledged.
</p>

<p>
This work was supported in part by the <a href="http://www.darpa.mil/"> US
Defense Advanced Research Projects  Agency </a> under the auspices of the
<a href="http://www.daml.org/">  DARPA Agent Markup Language (DAML) Project
</a>, <a href="http://www.cs.umd.edu/users/hendler/">Prof. James
Hendler</a>, program manager.
</p>

<h2><a id="references" name="references">References</a></h2>

<ol>
  <li><i><a href="http://www.w3.org/TR/daml+oil-model">A Model-Theoretic
	  Semantics for DAML+OIL (March 2001)</a></i></li>
  <li><i><a href="http://www.w3.org/TR/daml+oil-axioms">An Axiomatic Semantics for RDF,
	  RDF-S, and DAML+OIL (March 2001) </a></i></li>
  <li><i><a href="http://www.w3.org/TR/daml+oil-walkthru/">Annotated DAML+OIL Ontology
    Markup</a></i></li>
  <li><i><a href="http://www.w3.org/2001/10/daml+oil">DAML+OIL revised language specification
		</a></i></li>
  <li><i><a href="daml+oil-ex.daml">A sample ontology</a></i></li>
  <li><i><a href="daml+oil-ex-dt.xsd">Datatype definitions for sample
 	ontology</a></i></li>
</ol>

</body>
</html>