Reference description of the
DAML+OIL+DT ontology markup language

Abstract Objects and Datatype Values

DAML+OIL+DT is mostly concerned with the creation of classes that describe (or define) part of the abstract domain. Such classes are called abstract classes and are elements of daml:Class, a subclass of rdfs:Class. DAML+OIL+DT also allows the use of XML Schema datatypes to describe (or define) part of the datatype domain. These datatypes are used within DAML+OIL+DT simply by including their URIs within a DAML+OIL+DT ontology. They are (implicitly) elements of daml:Datatype.

Class element

A Class element refers to a class name (a URI), (we will refer to this class as C) and contains

• zero or more subClassOf elements (each containing a class-expression).
  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).
  Warning: The RDF Schema specification 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, +DT places no such restriction on the subClassOf relationship between classes;
  
• zero or more disjointWith elements (each containing a class-expression).
  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);
  
• zero or more disjointUnionOf elements (each containing a list of class-expressions).
  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;
  
• zero or more sameClassAs elements (each containing a class-expression).
  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);
  
• zero or more equivalentToelements (each containing a class expression)
  When applied to a class, the equivalentTo element has the same semantics as the sameClassAs element.
  Warning: 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.
  
• zero or more boolean combinations of class expressions.
  The class C must be equivalent to the class defined by each of the boolean class expression,
  and
• zero or more enumeration elements.
  Each enumeration element asserts that C contains exactly the instances enumerated in the element (i.e: no more, no less). Although it is formally allowed to have multiple such assertions about C, as soon as two of the enumerations are not equivalent, the class C immediately becomes inconsistent (since C cannot be equivalent to both of these enumerations at once).

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

Class expression

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

• a class name (a URI), or
• an enumeration, enclosed in <rdfs:Class>...</rdfs:Class> tags, or
• a property-restriction, or
• or a boolean combination of class expressions, enclosed in <rdfs:Class>...</rdfs:Class> tags

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

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

Enumeration

An enumeration is a oneOf element, containing a list of 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:

<oneOf parseType="daml:collection">
  <Thing rdf:resource="#Eurasia"/>
  <Thing rdf:resource="#Africa"/>
  <Thing rdf:resource="#North_America"/>
  <Thing rdf:resource="#South_America "/>
  <Thing rdf:resource="#Australia"/>
  <Thing rdf:resource="#Antarctica"/>
</oneOf>

Property restriction

A property restriction is a special kind of class expression. It implicitly defines an anonymous class, namely the class of all instances that satisfy the restriction. There are two kinds of restrictions. The first kind, AbstractRestriction works on abstract properties, i.e., properties that relate abstract objects to other abstract objects. The second kind DatatypeRestriction works on Datatype properties, i.e., properties that relate abstract 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. <\span>

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

• elements indicating the type of restriction:
  • a toClass element (which contains a class expression ).
    A toClass element defines the class or datatype of all instances for whom the values of property P all belong to the class expression. In other words, it defines the class of instances 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;
    
  • a hasValue element (which contains (a reference to) an instance or a datatype value).
    A hasValue element defines the class of all instances for whom the property P has at least one value equal to the named instance or datatype value (and perhaps other values as well). In other words, if we call the instance y, then it defines the class of instances x for which (x,y) is an instance of P;
    
  • A hasClass element (which contains a class expression or a datatype references).
    A hasClass element defines the class of all instances 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 instances x for which there is at least one instance y of the class-expression or datatype such that (x,y) is an instance of P. This does not exclude that there are other instances (x,y') of P for which y' does not belong to the class expression or datatype.
  Notice that 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.
  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. After all, the toClass restriction demands that all values of P belong to class P, and if no such values exist, the restriction is trivially true.
  
• elements containing a non-negative integer (to which we will refer as N) indicating an unqualified cardinality restriction:
  • a cardinality element.
    This defines the class of all instances 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;
    
  • a maxCardinality element.
    This defines the class of all instances that have at most N distinct values for the property P;
    
  • a minCardinality element.
    This defines the class of all instances that have at least N distinct values for the property P.
    
• elements containing a non-negative integer (to which we will refer as N)indicating a qualified cardinality restriction, and containing a hasClassQ element, containing a class expression or a datatype references:
  • a cardinalityQ element.
    This defines the class of all instances 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;
    
  • a maxCardinalityQ element.
    This defines the class of all instances 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);
    
  • a minCardinalityQ element.
    This defines the class of all instances 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).

  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+DT annotations from browsers), it is necessary to write cardinality constraints in an alternative RDF format. See ^{Cardinality Syntax Note}for 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.

Boolean combination of class expressions

A boolean combination of class expressions can be constructed from:

• an intersectionOf element, containing a list of class expressions.
  This defines the class that consists of exactly all the instances that are common to all class expressions from the list. It is analogous to logical conjunction;
  
• a unionOf element, containing a list of class expressions.
  This defines the class that consists exactly of all the instances that belong to at least one of the class expressions from the list. It is analogous to logical disjunction;
• a complementOf element, containing a single class expression.
  This defines the class that consists of exactly all instances that do not belong to the class expression. It is analogous to logical negation.

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

Property element

A Property element refers to a property name (a URI) (to which we will refer as P). Properties that can be used in property restrictions must be either abstract properties, which relate abstract objects to other abstract objects, and are instances of AbstractProperty; or datatype properties, which relate abstract objects to datatype values, and are instances of DatatypeProperty.

A property element contains:

• zero or more subPropertyOf elements, each containing a property name.
  Each subPropertyOf element states that P is a subproperty of the property named in the element. This means that every pair (x,y) that is an instance of P is also an instance of the named property;
  
• zero or more domain elements (each containing a class expression).
  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.
  Warning: This is contrary to the semantics of the domain element in the RDF Schema specification, which we believe to be flawed. Note that unlike any of the property restrictions 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;
  Because of this, the use of domain elements in DAML+OIL+DT is deprecated.
• zero or more range elements (each containing a class expression).
  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.
  Warning: Although the RDF Schema specification 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;
  Because of this, the use of range elements in DAML+OIL+DT is deprecated.
• zero or more samePropertyAs elements (each containing a property name).
  Each samePropertyAs element asserts that P is equivalent to the named property (i.e. they must have the same instances),
  
• zero or more equivalentTo elements (each containing a property name).
  When applied to a property, the equivalentTo element has the same semantics as the samePropertyAs element;
  Warning: 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.
  and
  
• zero or more inverseOf elements (each containing a property name), for abstract properties only.
  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.

Instead of a Property element, it is also possible to use any of the following elements, each of which assert additional information about the property:

• a TransitiveProperty element, which is a subclass of AbstractProperty.
  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;
  
• a UniqueProperty element.
  This asserts that P can only have one (unique) value y for each instance x, i.e: there cannot be two distinct instances y1 and y2 such that the pairs (x,y1) and (x,y2) are both instances of P. Of course, this is a shorthand notation for the maxcardinality restriction of 1,
  or
• an UnambigousProperty element, which is a subclass of AbstractProperty.
  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.

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 of individuals 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.

Instance

Instances of both abstract classes (i.e. individuals) and of properties (i.e. relations, pairs of individuals) 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>

<oneOf rdf:parseType="daml:collection">
  <Thing rdf:resource="#red"/>
  <Thing rdf:resource="#white"/>
  <Thing rdf:resource="#blue"/>
</oneOf>

<List>
 <first>
  <Thing rdf:resource="#red">
 </first>
 <rest>
  <List>
   <first>
    <Thing rdf:resource="#white">
   </first>
   <rest>
    <List>
     <first>
      <Thing rdf:resource="#blue">
     </first>
     <rest>
      <List rdf:resource="http://www.daml.org/2000/12/DAML+OIL+DT#nil">
     </rest>
    </List>
   </rest>
  </List>
 </rest>
</List>