DAML+OIL

Status: W3C Reference Description vom 18. Dezember 2001
Version: 1.0
Homepage: http://www.w3.org/TR/daml+oil-reference
Verfasser: W3C

Das Hauptziel der W3C Arbeitsgruppe war die Entwicklung einer standardisierten, auf XML basierenden Ontologiesprache zur Beschreibung von Ontologien für das Semantic Web, die die semantische Bedeutung der Metasprachen RDF und RDF-Schema erweitert. Mit DAML+OIL ist es möglich, unterschiedliche Ontologien zu entwickeln und diese miteinander zu verknüpfen. Die Sprache besitzt eine klare, wohldefinierte Semantik und ist somit für Maschinen lesbar und semantisch interpretierbar und findet ihre Weiterentwicklung in OWL.

Syntax und Typenmodell

DAML+OIL baut auf bereits bestehende Web-Technologien wie XML und URI auf und ist in RDF geschrieben. Sie kann daher als eine spezifische Art von RDF-Markup angesehen werden. Das in DAML+OIL implementierte Typenmodell unterscheidet zwischen Objekten und Datentypen. Objekte sind Instanzen von Klassen im Sinne von DAML oder RDFS. Datentypen bestehen aus den XML-Schema-Datentypen. DAML+OIL ist jedoch haupsächlich auf die Kreierung von Klassen zur Beschreibung von Objekten innerhalb einer
Ontologie ausgerichtet.

Sprachaufbau

Im folgenden wird eine Ontologie in DAML+OIL zur Beschreibung von Tieren und Menschen definiert. Es wird nacheinander auf die einzelnen Abschnitte eingegangen, die in einer Ontologie vorkommen können. Die Entwicklung einer Ontologie ist ein iterativer Prozess und beinhaltet folgende Schritte:

• Definition der Klassen in der Ontologie
• Definition der Klassenhierarchie
• Festlegung der Klasseneigenschaften und Attriute
• Erzeugung der Instanzen

Typischerweise besteht sie aus folgenden Elementen:

• Header
• Klassen
• Properties
• Instanzen

Header

DAML+OIL hat das Konzept der Namensräume (namespaces) von XML geerbt, dort dient es der
eindeutigen Benennung von Elementen. Über eine URI (Uniform Resource Identifier) wird
jede XMLApplikation identifiziert.

<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:xsd ="http://www.w3.org/2000/10/XMLSchema#"
  xmlns:daml="http://www.w3.org/2001/10/daml+oil#"
  xmlns:exd ="http://www.w3.org/TR/2001/NOTE-daml+oil-walkthru-20011218/daml+oil-ex-dt#"
  xmlns:dex ="http://www.w3.org/TR/2001/NOTE-daml+oil-walkthru-20011218/daml+oil-ex#"
  xmlns     ="http://www.w3.org/TR/2001/NOTE-daml+oil-walkthru-20011218/daml+oil-ex#"
<!-- Body einer DAML-OIL Ontologiedefinition -->
</ rdf:RDF>

Nach der Definition der Namensräume wird innerhalb eines RDF Dokuments mit dem Tag
daml:Ontology erklärt, dass dieses Dokument eine Ontologiedefinition enthält:

<daml:Ontology rdf:about="">
  <daml:versionInfo>Version 0.3</daml:versionInfo>
  <rdfs:comment>An example ontology</rdfs:comment>
  <daml:imports rdf:resource="http://www.w3.org/2001/10/daml+oil"/>
</daml:Ontology>

Klassen

Eine Grundlage einer jeden DAML+OIL Ontologie sind Klassen, mit ihnen werden die Elemente beziehungsweise Objekte innerhalb eines Wissensbereichs modelliert, für die die Ontologie entworfen wurde. Die Klassen können untereinander in Beziehung stehen oder von einander abgeleitet sein. Auf diese Weise wird mit Hilfe von Klassen innerhalb einer Ontologie die Beziehung einzelner Objekte in der realen Welt untereinander wiedergespiegelt.

In DAML+OIL wird jedes Objekt der Grundgesamtheit durch eine entsprechende Klasse, die
einen eindeutigen Namen besitzt, repräsentiert. Über den Namen (ID) wird die Klasse
später innerhalb der Ontologie eindeutig identifiziert.
Klassen werden mit dem Tag Class markiert. Die Tags label und comment besitzen keinerlei
logische Bedeutung, sondern dienen nur der Beschreibung.

<daml:Class rdf:ID="Animal">
  <rdfs:label>Animal</rdfs:label>
  <rdfs:comment>
    This class of animals is illustrative of a number of ontological idioms.
  </rdfs:comment>
</daml:Class>

Klassen können auch voneinander abgeleitet werden - dies geschieht mit dem Element
rdfs:subClassOf. Eine Klasse kann mehrere Oberklassen besitzen, von der sie abgeleitet
ist.

<daml:Class rdf:ID="Male">
  <rdfs:subClassOf rdf:resource="#Animal"/>
</daml:Class>
<daml:Class rdf:ID="Female">
  <rdfs:subClassOf rdf:resource="#Animal"/>
  <daml:disjointWith rdf:resource="#Male"/>
</daml:Class>

In diesem Beispiel werden Male und Female als Unterklassen von Animal mit dem Element
rdfs:subClassOf definiert. Zusätzlich wird definiert, dass die Klasse Male echt
verschieden (disjointWith) von der Klasse Female ist.

Weitere Klassendefinitionen:

• sameClassAs: Zwei Klassen sind gleich – sie besitzen die gleichen Instanzen.
• equivalentTo: Angewendet auf zwei Klassen besitzt equivalentTo die gleiche Semantik wie sameClassAs. Ein Programm, das nur RDFS versteht, kennt jedoch dieses Element nicht, das sameClassAs Element dagegen schon. Aus diesem Grund wird es empfohlen, diesen Tag nicht zu benutzen.
• disjointWith: Die Klassen sind echt verschieden – es existiert keine Instanz der einen Klasse, die gleichzeitig auch Instanz der anderen Klasse ist.
• disjointUnionOf: Eine Klasse ist die Vereinigung von echt paarweise verschieden Klassen.

boolsche Kombinationen:

• intersectionOf: Eine Liste von Elementen, die UND-verknüpft sind – alle Ausdrücke müssen gelten.
• unionOf: Eine Liste von Elementen, die ODER-verknüpft sind – alle Ausdrücke können gelten, aber nicht alle müssen erfüllt sein.
• complementOf: Dieser Ausdruck beschreibt die Negation eines Objekts – das hier aufgeführte Objekt ist nicht Bestandteil der Klasse.

Properties

Eine Eigenschaft kann als binäre Relation zwischen zwei Items verstanden werden. Bei den Eigenschaft werden zwei Arten unterschieden:

• ObjectProperty
• DatatypeProperty

Eine ObjectProperty beschreibt eine Relation zwischen zwei Objekten, eine DatatypeProperty eine Relation zwischen einem Objekt und einem Datentypen.

Man kann innerhalb der animal Klasse eine Relation zwischen Tieren mit der
Eigenschaft hasParent herstellen .

<daml:ObjectProperty rdf:ID="hasParent">
  <rdfs:domain rdf:resource="#Animal"/>
  <rdfs:range rdf:resource="#Animal"/>
</daml:ObjectProperty>

Auch Eigenschaften können voneinander abgeleitet werden - das geschieht mit dem Tag
subPropertyOf. Im folgenden wird von der eben definierten Eigenschaft hasParent
abgeleitet und eine hasFather Property definiert.

<daml:ObjectProperty rdf:ID="hasFather">
  <rdfs:subPropertyOf rdf:resource="#hasParent"/>
  <rdfs:range rdf:resource="#Male"/>
</daml:ObjectProperty>

DatatypeProperties stehen für Relationen zwischen einem Objekt und einem Datentyp,
der durch ein XML-Schema bereitgestellt wird.
Zu den XMLSchema Datentypen gehören u.a. die folgenden Datentypen: integer,
nonNegativeInteger, nonPositiveInteger, long, byte, time...

<daml:DatatypeProperty rdf:ID="age">
  <rdfs:comment>
    age is a DatatypeProperty whose range is xsd:decimal.
    age is also a UniqueProperty (can only have one age)
  </rdfs:comment>
  <rdf:type rdf:resource="http://www.w3.org/2001/10/daml+oil#UniqueProperty"/>
  <rdfs:range rdf:resource="http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger"/>
</daml:DatatypeProperty>

Weitere Elemente von Properties:

• domain: Die Property darf nur Elemente dieser Klasse angewendet werden.
• range: Beschränkung des Wertebereichs
• samePropertyAs: Zwei Properties sind gleich, bzw. weisen die gleichen Instanzen auf.
• inverseOf: Umkehrrelation

Properties mit beschränkende Eigenschaften:

• TransitivePropterty: Ist eine Subclass von ObjectProperty und besagt, dass Property P transitiv ist, wenn die Paare (x,y) und (y,z) Elemente von P sind, dann ist auch das Paar (x,z) Element von P.
• UniqueProperty: P darf nur einen eindeutigen Wert für jede Instanz besitzen. Diese Property entspricht einer Property mit der zusätzlichen Beschränkung von maxCardinality auf 1.
• UnambigousProperty: Ist eine Subclass von ObjectProperty und besagt, dass der Wert einer Property eideutig sein muß. Diese Property ist das Inverse zu UniqueProperty und umgekehrt.
  
  

Im folgenden Beispiel wird eine neue Ontologie Klasse Person definiert, die von der
Klasse animal abgeleitet ist. Beschränkungen werden in DAML+OIL mit rdfs:Restriction
eingeleitet. Außerdem wird eine anonyme Oberklasse definiert, die eine einzige
Restriktion besitzt, dass jede Person nur Eltern vom Typ Person haben darf.

<daml:Class rdf:ID="Person">
  <rdfs:subClassOf rdf:resource="#Animal"/>
  <rdfs:subClassOf>
    <rdfs:Restriction>
      <daml:onProperty rdf:resource="#hasParent"/>
      <daml:toClass rdf:resource="#Person"/>
    </rdfs:Restriction>
  </rdfs:subClassOf>
</daml:Class>

Weitere Restriktionen:

• cardinality: Genau N unterschiedliche Werte müssen für diese Property vorhanden sein.
• minCardinality: Mindestens N unterschiedliche Werte müssen für diese Property vorhanden sein.
• maxCardinality: Maximal N unterschiedliche Werte müssen für diese Property vorhanden sein.
• cardinalityQ: Wie cardinality, nur mit der zusätzlichen Eigenschaft, dass die Kardinalität nur für den angegebenen Typ innerhalb der Property gilt.
• minCardinalityQ: Wie minCardinality, nur mit der zusätzlichen Eigenschaft, dass die Kardinalität nur für den angegebenen Typ innerhalb der Property gilt.
• maxCardinalityQ: Wie maxCardinality, nur mit der zusätzlichen Eigenschaft, dass die Kardinalität nur für den angegebenen Typ innerhalb der Property gilt.

Werden bei rdfs:Restriction mehrere Attribute in der obigen Form angeführt, müssen immer alle Bedingungen erfüllt sein. Die gesamte Property ist nicht erfüllt, sobald auch nur eine Bedingung nicht erfüllt ist.

Im folgenden Beispiel wird die Property hasMother definiert. Die Mutter
muß weiblich sein, und es darf aufgrund des Elements UniqueProperty nur
genau eine Mutter vorhanden sein.

<daml:UniqueProperty rdf:ID="hasMother">
  <rdfs:subPropertyOf rdf:ressource="#hasParent"/>
  <rdfs:range rdf:resource="#Female"/>
</daml:UniqueProperty>

Instanzen

Instanzen von Klassen und Eigenschaften werden in RDF und RDF Schema Syntax geschrieben. Im Beispiel wird eine Instanz der Klasse Person angelegt.

<Person rdf:ID="Joe">
  <rdfs:label>Joe</rdfs:label>
  <rdfs:comment>Joe is a person and one parent is John.</rdfs:comment>
  <hasParent rdf:resource="John"/>
</Person>

Die Listings stammen aus dem Walkthru des W3C.