©2001 Dan Connolly, Frank van Harmelen, Ian Horrocks, Deborah L. McGuinness, Lynn Andrea Stein, and Lucent Technologies, Inc.. All Rights Reserved. Distribution policies are governed by the W3C intellectual property terms.
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 OIL. The language has a clean and well defined semantics.
This document is a submission to the World Wide Web Consortium from Lucent Technologies (see Submission Request, W3C Staff Comment).
Please send comments to Peter F. Patel-Schneider pfps@research.bell-labs.com, or, preferably, to the publicly archived distribution list, www-rdf-logic@w3.org [archive].
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.
A list of current W3C technical documents can be found at the Technical Reports page.
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.
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.
As with any set of RDF triples, DAML+OIL triples can be represented in many different syntactic forms (as described in the RDF specification). The current document uses a specific RDF syntactic form for these triples. However, it is also allowed to use any other syntactic RDF form that results in the same underlying set of RDF triples as the syntax used in this document. Such other syntactic form would then carry exactly the same prescribed meaning as the equivalent syntactic form used in this document. See Syntax Note for an example of this.
As stated above, DAML+OIL assigns a specific meaning to certain RDF triples. The model-theoretic semantics 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 http://www.w3.org/2001/10/daml+oil. 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 Mixing Note 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.
A DAML+OIL ontology is made up of several components, some of which are optional, and some of which may be repeated. See the index for a listing of all these components. 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.
A DAML+OIL ontology consists of zero or more headers, followed by zero or more class elements, property elements, and instances.
An daml:Ontology
element contains zero or more version information
and imports elements.
<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>
The
daml:versionInfo
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.
Each daml:imports
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.
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.
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.
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 daml:Class, a subclass of rdfs:Class. 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 daml:Datatype. Datatypes are not DAML+OIL individual objects.
A class element, daml:Class
, contains (part of) the definition
of an object class.
A class element refers to a class name (a URI), (we will refer to this class
as C) and contains
rdfs:subClassOf
elements (each containing a class-expression). daml:disjointWith
elements (each containing a class-expression).daml:disjointUnionOf
elements (each containing a list of class-expressions).daml:sameClassAs
elements (each containing a class-expression).daml:equivalentTo
elements (each
containing a class
expression)Notice that the first two elements state necessary but not sufficient
conditions for class membership. The final four elements state both necessary
and sufficient conditions.
A class expression is the name used in this document for either
<daml:Class>...</daml:Class>
tags, or<rdfs:Class>...</rdfs:Class>
tagsEach class expression either refers to a named class, namely the class that is identified by the URI, or implicitly defines an anonymous class, respectively the class that contains exactly the enumerated elements, or the class of all instances which satisfy the property-restriction, or the class that satisfies the boolean combination of such expressions.
Two class names are already predefined, namely the classes
daml:Thing
and daml:Nothing
. Every
object is a member of daml:Thing
, and no object is a member
daml:Nothing
. Consequently, every class is a subclass of
daml:Thing
and daml:Nothing
is a subclass of
every class.
An enumeration is a
daml:oneOf
element, containing a list of the objects
that are its instances.
This enables us to define a class by exhaustively enumerating its elements.
The class defined by the oneOf element contains exactly the enumerated
elements, no more, no less. For example:
<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>
A property restriction is a special kind of class expression. It implicitly defines an anonymous class, namely the class of all objects that satisfy the restriction. There are two kinds of restrictions. The first kind, ObjectRestriction, works on object properties, i.e., properties that relate objects to other objects. The second kind, DatatypeRestriction, works on datatype properties, i.e., properties that relate objects to datatype values. Both kinds of restrictions are created using the same syntax, with the usual difference being whether a class element or a datatype reference is used. It is also possible to create restrictions that are neither restrictions nor datatype restrictions, but these restrictions are not handled within DAML+OIL.
A daml:Restriction
element contains an
daml:onProperty
element, which refers to a property name (a
URI) (we will refer to this property as P) and one or more of the
following
daml:toClass
element (which contains a class expression
).daml:hasValue
element (which contains (a reference to) an
individual object or a datatype value).daml:hasClass
element (which contains a class expression
or a datatype
references).daml:cardinality
element.daml:maxCardinality
element.daml:minCardinality
element.daml:hasClassQ
element, containing a class expression or a
datatype references:
daml:cardinalityQ
element.daml:maxCardinalityQ
element.daml:minCardinalityQ
element.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).
Warning: 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 Cardinality Syntax Notefor
an example of this.
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).
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.
A boolean combination of class expressions can be constructed from:
daml:intersectionOf
element, containing a list of class expressions. daml:unionOf
element, containing a list of class
expressions. daml:complementOf
element, containing a single class expression.Note that arbitrarily complex combinations of these expressions can be formed. See Boolean Notefor an example of this.
A rdf:Property
element refers to a property name (a URI)
(to which
we will refer as P).
Properties that are used in property restrictions should be either
properties, which relate objects to other objects, and are instances of
ObjectProperty;
or
datatype properties, which relate objects to datatype
values, and are instances of
DatatypeProperty.
A property element contains:
rdfs:subPropertyOf
elements, each containing a property
name.rdfs:domain
elements (each containing a class expression).rdfs:range
elements (each containing a class expression).daml:samePropertyAs
elements (each containing a property
name).equivalentTo
elements (each
containing a property name).daml:inverseOf
elements (each containing a property name),
for properties only.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:
daml:TransitiveProperty
element, which is a
subclass of ObjectProperty.daml:UniqueProperty
element.daml:UnambigousProperty
element, which is a
subclass of ObjectProperty.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 property
restrictions, which are part of a
class element, and are only enforced on the property when applied to that
class.
A property is a binary relation that may or may not be defined in the
ontology. If it is not defined, then it is assumed to be a binary relation
with no globally applicable constraints, i.e. any pair with first element
an object and second element an object or datatype value
could be an instance of the property.
Warning: If 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.
Instances of both classes
(i.e., objects) and of properties (i.e., pairs) are written in
RDF and
RDF Schema
syntax.
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:
<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>
There is no unique name assumption for objects in DAML+OIL.
To state that objects are the same, a
daml:sameIndividualAs
element
is used.
(Note that daml:equivalentTo
can be also used here, but
daml:sameIndividual
is preferred.
To state that objects are distinct,
a daml:differentIndividualFrom
element is used.
The situation is different for datatype values, where XML Schema Datatype
identity is used.
Datatype values are written in a manner that is valid RDF syntax, but which is given a special semantics in 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 rdf:type of the value, and the lexical representation is the rdf:value of the value. So the decimal 10.5 could be input as <xsd:decimal rdf:value="10.5"> provided that xsd was defined as the URI of the XML Schema Datatype specification.
As a nod to backward compatability, literals that occur outside this sort of construction are interpreted as any of the XML Schema Datatype values with this lexical representation. These values are mostly unusable unless some typing information is available, such as a range for a property.
The question of whether any XML Schema datatype can be used in such constructions, or whether only certain XML Schema dataypes can be so used (such as only the predefined datatypes), remains open.
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.
For example, the statement
<oneOf rdf:parseType="daml:collection"> <Thing rdf:about="#red"/> <Thing rdf:about="#white"/> <Thing rdf:about="#blue"/> </oneOf>
should be interpreted as the following construction (also known as a consed-pair construction, from Lisp-lore):
<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>
Current RDF parsers (RDF specification of February '99) 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.
Note that structures of parseType daml:collection are intended to represent unordered collections, even though the RDF datastructure imposes a specific order on the elements.
<rdfs:Class ID="Continents"/>
However, the following RDF statement:
<rdf:Description ID="Continents"> <rdf:Type resource="http://www.w3.org/2000/01/rdf-schema#Class"/> </rdf:Description>
results in exactly the same set of RDF triples, and is therefore
perfectly allowed as a class definition.
Another example is the two notations that we
discuss for cardinality constraints below. Again, both these forms
result in the same set of RDF triples, and are thus equivalent.
<rdf:Description about="#Person"> <Creator>Ora Lassila</Creator> </rdf:Description>
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).
<Restriction> <onProperty rdf:resource="#father"/> <cardinality>1</cardinality> </Restriction>
we would have to write
<Restriction cardinality="1"> <onProperty rdf:resource="#father"/> </Restriction>
to avoid any exposed content. The cardinality
elements are the only ones for which this alternative notation is
required to avoid exposed content. (See
the section on abbreviated syntaxin
the RDF specification for more details on this notation).
<complementOf> <Class> <unionOf parseType="daml:collection"> <Class rdf:resource="#meat"/> <Class rdf:resource="#fish"/> </unionOf> </Class> </complementOf>
<!-- $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>
The following individuals were also involved in preparing the DAML+OIL (March 2001) release. See individual documents and previous releases for additional information.
The contributions of participants on the www-rdf-logic@w3.org email list are also acknowledged.
This work was supported in part by the US Defense Advanced Research Projects Agency under the auspices of the DARPA Agent Markup Language (DAML) Project , Prof. James Hendler, program manager.