You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1515 lines
65 KiB
1515 lines
65 KiB
<!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">
|
|
©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><Ontology rdf:about="">
|
|
<versionInfo>$Id: NOTE-daml+oil-reference-20011218.html,v 1.6 2001/12/18 22:12:09 connolly Exp $</versionInfo>
|
|
<rdfs:comment>An example ontology</rdfs:comment>
|
|
<imports rdf:resource="http://www.w3.org/2001/10/daml+oil"/>
|
|
</Ontology></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><daml:Class>...</daml:Class></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><rdfs:Class>...</rdfs:Class></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><daml:oneOf parseType="daml:collection">
|
|
<daml:Thing rdf:about="#Eurasia"/>
|
|
<daml:Thing rdf:about="#Africa"/>
|
|
<daml:Thing rdf:about="#North_America"/>
|
|
<daml:Thing rdf:about="#South_America "/>
|
|
<daml:Thing rdf:about="#Australia"/>
|
|
<daml:Thing rdf:about="#Antarctica"/>
|
|
</oneOf></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><continent rdf:ID="Asia"/>
|
|
|
|
<rdf:Description rdf:ID="Asia">
|
|
<rdf:type>
|
|
<rdfs:Class rdf:about="#continent"/>
|
|
</rdf:type>
|
|
</rdf:Description>
|
|
|
|
<rdf:Description rdf:ID="India">
|
|
<is_part_of rdf:resource="#Asia"/>
|
|
</rdf:Description></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><xsd:decimal rdf:value="10.5"></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><oneOf rdf:parseType="daml:collection">
|
|
<Thing rdf:about="#red"/>
|
|
<Thing rdf:about="#white"/>
|
|
<Thing rdf:about="#blue"/>
|
|
</oneOf></pre>
|
|
|
|
<p>should be interpreted as the following construction (also
|
|
known as a consed-pair construction, from Lisp-lore):</p>
|
|
<pre><List>
|
|
<first>
|
|
<Thing rdf:about="#red">
|
|
</first>
|
|
<rest>
|
|
<List>
|
|
<first>
|
|
<Thing rdf:about="#white">
|
|
</first>
|
|
<rest>
|
|
<List>
|
|
<first>
|
|
<Thing rdf:about="#blue">
|
|
</first>
|
|
<rest>
|
|
<List rdf:resource="http://www.w3.org/2001/10/daml+oil#nil">
|
|
</rest>
|
|
</List>
|
|
</rest>
|
|
</List>
|
|
</rest>
|
|
</List></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><rdfs:Class ID="Continents"/> </pre>
|
|
<br />
|
|
<p>However, the following RDF statement:</p>
|
|
<pre><rdf:Description ID="Continents">
|
|
<rdf:Type resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
|
|
</rdf:Description> </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><rdf:Description about="#Person">
|
|
<Creator>Ora Lassila</Creator>
|
|
</rdf:Description></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><Restriction>
|
|
<onProperty rdf:resource="#father"/>
|
|
<cardinality>1</cardinality>
|
|
</Restriction></pre>
|
|
<p>we would have to write<br />
|
|
</p>
|
|
<pre><Restriction cardinality="1">
|
|
<onProperty rdf:resource="#father"/>
|
|
</Restriction> </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><complementOf>
|
|
<Class>
|
|
<unionOf parseType="daml:collection">
|
|
<Class rdf:resource="#meat"/>
|
|
<Class rdf:resource="#fish"/>
|
|
</unionOf>
|
|
</Class>
|
|
</complementOf></pre>
|
|
<br />
|
|
</dd>
|
|
|
|
</dl>
|
|
|
|
<h2><a name="appc" id="appc"></a>Appendix C. http://www.w3.org/2001/10/daml+oil</h2>
|
|
|
|
<pre>
|
|
<!-- $Revision: 1.6 $ of $Date: 2001/12/18 22:12:09 $. -->
|
|
|
|
<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#"
|
|
>
|
|
|
|
<rdf:Description rdf:about="">
|
|
<versionInfo>$Id: NOTE-daml+oil-reference-20011218.html,v 1.6 2001/12/18 22:12:09 connolly Exp $</versionInfo>
|
|
<imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>
|
|
</rdf:Description>
|
|
|
|
<!-- (meta) classes of "object" and datatype classes -->
|
|
|
|
<rdfs:Class rdf:ID="Class">
|
|
<rdfs:label>Class</rdfs:label>
|
|
<rdfs:comment>
|
|
The class of all "object" classes
|
|
</rdfs:comment>
|
|
<rdfs:subClassOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="Datatype">
|
|
<rdfs:label>Datatype</rdfs:label>
|
|
<rdfs:comment>
|
|
The class of all datatype classes
|
|
</rdfs:comment>
|
|
<rdfs:subClassOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
|
|
</rdfs:Class>
|
|
|
|
<!-- Pre-defined top/bottom thing/nothing most/least-general (object) classes. -->
|
|
|
|
<Class rdf:ID="Thing">
|
|
<rdfs:label>Thing</rdfs:label>
|
|
<rdfs:comment>
|
|
The most general (object) class in DAML.
|
|
This is equal to the union of any class and its complement.
|
|
</rdfs:comment>
|
|
<unionOf rdf:parseType="daml:collection">
|
|
<rdfs:Class rdf:about="#Nothing"/>
|
|
<rdfs:Class>
|
|
<complementOf rdf:resource="#Nothing"/>
|
|
</rdfs:Class>
|
|
</unionOf>
|
|
</Class>
|
|
|
|
<Class rdf:ID="Nothing">
|
|
<rdfs:label>Nothing</rdfs:label>
|
|
<rdfs:comment>the class with no things in it.</rdfs:comment>
|
|
<complementOf rdf:resource="#Thing"/>
|
|
</Class>
|
|
|
|
<!-- Terms for building classes from other classes. -->
|
|
|
|
<rdf:Property rdf:ID="equivalentTo"> <!-- equals? equiv? renames? -->
|
|
<rdfs:label>equivalentTo</rdfs:label>
|
|
<rdfs:comment>
|
|
for equivalentTo(X, Y), read X is an equivalent term to Y.
|
|
</rdfs:comment>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="sameClassAs">
|
|
<rdfs:label>sameClassAs</rdfs:label>
|
|
<rdfs:comment>
|
|
for sameClassAs(X, Y), read X is an equivalent class to Y.
|
|
cf OIL Equivalent
|
|
</rdfs:comment>
|
|
<rdfs:subPropertyOf rdf:resource="#equivalentTo"/>
|
|
<rdfs:subPropertyOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#subClassOf"/>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="samePropertyAs">
|
|
<rdfs:label>samePropertyAs</rdfs:label>
|
|
<rdfs:comment>
|
|
for samePropertyAs(P, R), read P is an equivalent property to R.
|
|
</rdfs:comment>
|
|
<rdfs:subPropertyOf rdf:resource="#equivalentTo"/>
|
|
<rdfs:subPropertyOf rdf:resource="http://www.w3.org/2000/01/rdf-schema#subPropertyOf"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="sameIndividualAs">
|
|
<rdfs:label>sameIndividualAs</rdfs:label>
|
|
<rdfs:comment>
|
|
for sameIndividualAs(a, b), read a is the same individual as b.
|
|
</rdfs:comment>
|
|
<rdfs:subPropertyOf rdf:resource="#equivalentTo"/>
|
|
<rdfs:domain rdf:resource="#Thing"/>
|
|
<rdfs:range rdf:resource="#Thing"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="disjointWith">
|
|
<rdfs:label>disjointWith</rdfs:label>
|
|
<rdfs:comment>
|
|
for disjointWith(X, Y) read: X and Y have no members in common.
|
|
cf OIL Disjoint
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="differentIndividualFrom">
|
|
<rdfs:label>differentIndividualFrom</rdfs:label>
|
|
<rdfs:comment>
|
|
for differentIndividualFrom(a, b), read a is not the same individual as b.
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Thing"/>
|
|
<rdfs:range rdf:resource="#Thing"/>
|
|
</rdf:Property>
|
|
|
|
|
|
<!-- NOTE: the Disjoint class has been deleted: use disjointWith -->
|
|
<!-- or disjointUnionOf instead. -->
|
|
|
|
<rdf:Property rdf:ID="unionOf">
|
|
<rdfs:label>unionOf</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#List"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="disjointUnionOf">
|
|
<rdfs:label>disjointUnionOf</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#List"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="intersectionOf">
|
|
<rdfs:label>intersectionOf</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#List"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="complementOf">
|
|
<rdfs:label>complementOf</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#Class"/>
|
|
</rdf:Property>
|
|
|
|
<!-- Term for building classes by enumerating their elements -->
|
|
|
|
<rdf:Property rdf:ID="oneOf">
|
|
<rdfs:label>oneOf</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#List"/>
|
|
</rdf:Property>
|
|
|
|
<!-- Terms for building classes by restricting their properties. -->
|
|
|
|
<rdfs:Class rdf:ID="Restriction">
|
|
<rdfs:label>Restriction</rdfs:label>
|
|
<rdfs:comment>
|
|
something is in the class R if it satisfies the attached restrictions,
|
|
and vice versa.
|
|
</rdfs:comment>
|
|
<rdfs:subClassOf rdf:resource="#Class"/>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="onProperty">
|
|
<rdfs:label>onProperty</rdfs:label>
|
|
<rdfs:comment>
|
|
for onProperty(R, P), read:
|
|
R is a restricted with respect to property P.
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="toClass">
|
|
<rdfs:label>toClass</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="hasValue">
|
|
<rdfs:label>hasValue</rdfs:label>
|
|
<rdfs:comment>
|
|
for onProperty(R, P) and hasValue(R, V), read:
|
|
i is in class R if and only if P(i, V).
|
|
cf OIL HasFiller
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="hasClass">
|
|
<rdfs:label>hasClass</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
|
|
</rdf:Property>
|
|
|
|
<!-- Note that cardinality restrictions on transitive properties, or -->
|
|
<!-- properties with transitive sub-properties, compromise decidability. -->
|
|
|
|
<rdf:Property rdf:ID="minCardinality">
|
|
<rdfs:label>minCardinality</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="maxCardinality">
|
|
<rdfs:label>maxCardinality</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="cardinality">
|
|
<rdfs:label>cardinality</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="hasClassQ">
|
|
<rdfs:label>hasClassQ</rdfs:label>
|
|
<rdfs:comment>
|
|
property for specifying class restriction with cardinalityQ constraints
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="minCardinalityQ">
|
|
<rdfs:label>minCardinality</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="maxCardinalityQ">
|
|
<rdfs:label>maxCardinality</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="cardinalityQ">
|
|
<rdfs:label>cardinality</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<!-- Classes and Properties for different kinds of Property -->
|
|
|
|
<rdfs:Class rdf:ID="ObjectProperty">
|
|
<rdfs:label>ObjectProperty</rdfs:label>
|
|
<rdfs:comment>
|
|
if P is an ObjectProperty, and P(x, y), then y is an object.
|
|
</rdfs:comment>
|
|
<rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="DatatypeProperty">
|
|
<rdfs:label>DatatypeProperty</rdfs:label>
|
|
<rdfs:comment>
|
|
if P is a DatatypeProperty, and P(x, y), then y is a data value.
|
|
</rdfs:comment>
|
|
<rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="inverseOf">
|
|
<rdfs:label>inverseOf</rdfs:label>
|
|
<rdfs:comment>
|
|
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
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#ObjectProperty"/>
|
|
<rdfs:range rdf:resource="#ObjectProperty"/>
|
|
</rdf:Property>
|
|
|
|
<rdfs:Class rdf:ID="TransitiveProperty">
|
|
<rdfs:label>TransitiveProperty</rdfs:label>
|
|
<rdfs:comment>
|
|
if P is a TransitiveProperty, then if P(x, y) and P(y, z) then P(x, z).
|
|
cf OIL TransitiveProperty.
|
|
</rdfs:comment>
|
|
<rdfs:subClassOf rdf:resource="#ObjectProperty"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="UniqueProperty">
|
|
<rdfs:label>UniqueProperty</rdfs:label>
|
|
<rdfs:comment>
|
|
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.
|
|
</rdfs:comment>
|
|
<rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="UnambiguousProperty">
|
|
<rdfs:label>UnambiguousProperty</rdfs:label>
|
|
<rdfs:comment>
|
|
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.
|
|
</rdfs:comment>
|
|
<rdfs:subClassOf rdf:resource="#ObjectProperty"/>
|
|
</rdfs:Class>
|
|
|
|
<!-- List terminology. -->
|
|
|
|
<rdfs:Class rdf:ID="List">
|
|
<rdfs:subClassOf rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq"/>
|
|
</rdfs:Class>
|
|
|
|
<List rdf:ID="nil">
|
|
<rdfs:comment>
|
|
the empty list; this used to be called Empty.
|
|
</rdfs:comment>
|
|
</List>
|
|
|
|
<rdf:Property rdf:ID="first">
|
|
<rdfs:domain rdf:resource="#List"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="rest">
|
|
<rdfs:domain rdf:resource="#List"/>
|
|
<rdfs:range rdf:resource="#List"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="item">
|
|
<rdfs:comment>
|
|
for item(L, I) read: I is an item in L; either first(L, I)
|
|
or item(R, I) where rest(L, R).
|
|
</rdfs:comment>
|
|
<rdfs:domain rdf:resource="#List"/>
|
|
</rdf:Property>
|
|
|
|
<!-- A class for ontologies themselves... -->
|
|
|
|
<rdfs:Class rdf:ID="Ontology">
|
|
<rdfs:label>Ontology</rdfs:label>
|
|
<rdfs:comment>
|
|
An Ontology is a document that describes
|
|
a vocabulary of terms for communication between
|
|
(human and) automated agents.
|
|
</rdfs:comment>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="versionInfo">
|
|
<rdfs:label>versionInfo</rdfs:label>
|
|
<rdfs:comment>
|
|
generally, a string giving information about this
|
|
version; e.g. RCS/CVS keywords
|
|
</rdfs:comment>
|
|
</rdf:Property>
|
|
|
|
<!-- Importing, i.e. assertion by reference -->
|
|
|
|
<rdf:Property rdf:ID="imports">
|
|
<rdfs:label>imports</rdfs:label>
|
|
<rdfs:comment>
|
|
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".
|
|
</rdfs:comment>
|
|
</rdf:Property>
|
|
|
|
<!-- Importing terms from RDF/RDFS -->
|
|
|
|
<!-- first, assert the contents of the RDF schema by reference -->
|
|
<Ontology rdf:about="">
|
|
<imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>
|
|
</Ontology>
|
|
|
|
<rdf:Property rdf:ID="subPropertyOf">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#subPropertyOf"/>
|
|
</rdf:Property>
|
|
|
|
<rdfs:Class rdf:ID="Literal">
|
|
<sameClassAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="Property">
|
|
<sameClassAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="type">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#type"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="value">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#value"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="subClassOf">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#subClassOf"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="domain">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#domain"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="range">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#range"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="label">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#label"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="comment">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#comment"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="seeAlso">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#seeAlso"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="isDefinedBy">
|
|
<samePropertyAs rdf:resource="http://www.w3.org/2000/01/rdf-schema#isDefinedBy"/>
|
|
<rdfs:subPropertyOf rdf:resource="#seeAlso"/>
|
|
</rdf:Property>
|
|
|
|
</rdf:RDF>
|
|
</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>
|
|
|