OWL Guide

This version:

11 Jul 2002

Previous version:

None

Authors:

Michael K. Smith, Electronic Data Systems, michael.smith@eds.com
Deborah McGuinness, Stanford University, dlm@ksl.stanford.edu
Lynn Andrea Stein, Olin University, lynn.stein@olin.edu
Raphael Volz, Forschungszentrum Informatik (FZI), volz@fzi.de
Christopher Welty, IBM Corporation, welty@us.ibm.com

Acknowledgement:

This document represents the work of many people, in particular the members of the W3C Web Ontology Working Group and the original authors of the DAML+OIL Walkthru.

Copyright © 2002 EDS, Deborah L. McGuinness, Lynn Andrea Stein, Ora Lassila, IBM, All Rights Reserved. Distribution policies are governed by the W3C intellectual property terms.

---

Abstract

The OWL Web Ontology Language is being designed by the W3C Web Ontology Working Group in order to provide a language that can be used for applications that need to understand the logical content of information instead of struggling to deduce the meaning of some human-readable version of that information. The OWL language can be used to define term vocabularies and properties of entities and relations between entities in these vocabularies.

This document provides a guide to the use of the OWL language to

1. formalize a domain by defining classes and properties of those classes,
2. apply the formalization to assert properties of instances of these classes and,
3. reason about these concepts to the degree permitted by the formal semantics of the OWL language.

OWL Guide

Contents

• Introduction
• Capability
• Structure of Document
• The Structure of Ontologies Was Housekeeping. I still like this up front, for exactly the point that Raphael mentioned, immediate gratification. I am hoping this document will provide some cookbook-like support.
• Namespaces
• Ontology headers
• Importing ontologies (w/ forward pointer to Ontology Mapping)
• Basics
• Simple Classes, Individuals, Datatypes
• Defining simple hierarchical named classes (class, subClassOf)
• Defining individuals (individual)
• Datatypes (user-defined XML Schema datatypes)
• Simple Properties
• Defining properties (property, subPropertyOf, domain, range)
• Properties of individuals
• Property Characteristics and Restrictions
• inverseOf, transitive, symmetric, functional
• unambiguousProperty, allValuesFrom, someValueFrom
• simple cardinality
• Ontology mapping
• sameClassAs, samePropertyAs
• sameIndividualAs, differentIndividualFrom
• Complex Classes and Properties
• Complex Classes (axioms and constructive classes)
• Class relations
• oneOf (enumerated classes)
• Disjoint Classes
• sameClassAs, subClassOf applied to class expressions
• unionOf, intersectionOf, complementOf
• Complex Property axioms
• Full cardinality
• hasValue
• Status
• References

Introduction

Include goals here. Agent based reasoning, retrieval, ....

First there was RDF, Dublin Core. Then various attempts to go further. See references. DAML+OIL [ref] was selected as our starting point.

Relation to RDF. Aliasing of RDF tags.

A more complete description of OWL is provided in the requirements, summary, reference, and semantics documents referenced in this document.

Capability

Briefly, what you can do. More powerful than RDF, not as powerful as first order predicate calculus. OWL is based on description logics [@@ ref]. Formal basis [@@ Formal Model].

Structure of Document

Ontology structure, basic classes and properties, complex classe and properties, appendices(???), references.

The Structure of Ontologies

In this document we present examples using the OWL XML syntax [OWL XML Syntax], assuming this will be familiar to the largest audience. The standard for interchange of OWL knowledge bases between tools depends on RDF triples [RDF]. The XML and RDF formats are part of the standard. Other notations have been formulated, in particular a UML version [UML Syntax].

Distributed ontologies [forward reference???]

Namespaces

<rdf:RDF
  xml:base  ="http://www.w3c.org/2003/??/owl-guide"
  xmlns:oex ="http://www.w3c.org/2003/??/owl-guide#"
  xmlns:owl="http://www.w3c.org/2003/??/owl#"
  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:oxd ="http://www.w3c.org/2003/??/owl-guide-dt#"/>

So in this document, the rdf: prefix should be understood as referring to things drawn from the namespace called http://www.w3.org/1999/02/22-rdf-syntax-ns#. This is a conventional RDF declaration appearing verbatim at the beginning of almost every rdf document.^xmlns:rdf

The fourth declaration says that in this document, elements prefixed with owl: should be understood as referring to things drawn from the namespace called http://www.w3c.org/2003/??/owl# . This is a conventional OWL declaration, required to introduce the owl vocabulary.

The fifth declaration says that in this document, elements prefixed with oex: should be understood as referring to things drawn from the namespace called http://www.w3c.org/2003/??/owl-guide#, i.e., the location of this document itself.

The sixth declaration says that in this document, elements prefixed with exd: should be understood as referring to things drawn from the namespace called http://www.w3c.org/2003/??/owl-guide-dt#, which is a sibling document to this document itself, containing XML Schema datatype definitions used in this document. This OWL documents has a separate document containing XML Schema datatype definitions.

If you look at the bottom of this document, you'll see the matching closing tag, </rdf:RDF>.

Ontology headers

The first thing we do inside this document is to assert that it is an ontology.

<owl:Ontology rdf:about="">

This assertion is formulaic; the about attribute will typically be empty, indicating that the subject of this assertion is this document, if no xml:base declaration was previously made. Otherwise the subject of this assertion is the value specified by the xml:base property.^{Same-document reference}

 ...
  <comment>An example OWL ontology</comment>
  <versionInfo>$Id: OwlGuide.html,v 1.0 2002/07/17 16:12:00 mksmith $</versionInfo>
  <imports resource="http://www.w3.org/@@/OwlGuide.xml"/>
 ...

<versionInfo> is a standard tag intended to provide a consistent hook for version control systems working with ontologies.

<imports> provides an include-style mechanism. Importing another ontology brings in the entire set of definitions. Namespace issues? . Note that OWL provides a number of mechanisms to tie both the current ontology and imported ontologies together (see also ontology mapping.

The Basics

Simple Classes, Individuals, Datatypes

Most uses of an ontology depend ultimately upon the ability to reason about individuals (objects?). In order to do this in a useful fashion we need to have a mechanism to describe the classes (types?)that individuals belong to and the properties that they inherit by virtue of class membership. We can always assert specific properties about individuals, but the power of ontologies comes from class-based reasoning.

Defining simple hierarchical named classes (class, subClassOf)

  <Class ID="WINE-REGION">
  <Class ID="FRENCH-REGION">
    <subClassOf resource="#WINE-REGION"/>
  </Class>
  <Class ID="WINERY">

  <Class ID="CONSUMABLE-THING"/>

  <Class ID="POTABLE-LIQUID">
    <subClassOf resource="#CONSUMABLE-THING"/>
    ...
  </Class>

  <Class ID="WINE">
    <subClassOf resource="#POTABLE-LIQUID"/>
    ...
    <subClassOf>
      <Restriction>
        <onProperty resource="#REGION"/> <allValuesFrom resource="#WINE-REGION"/>
      </Restriction>
    </subClassOf>
  </Class>

  <Description ID="ALSACE">
    <type resource="#FRENCH-REGION"/>
  </Description>

<!-- $Revision: 1.2 $ of $Date: 2001/03/18 22:44:50 $. -->

<xsd:schema xmlns:xsd ="http://www.w3.org/2000/10/XMLSchema#">

<xsd:simpleType name="over12">
  <!-- over12 is an XMLS datatype based on decimal -->
  <!-- with the added restriction that values must be >= 13 -->
  <xsd:restriction base="xsd:decimal">
  <xsd:minInclusive value="13"/>
  </xsd:restriction>
</xsd:simpleType>

<xsd:simpleType name="over17">
  <!-- over17 is an XMLS datatype based on positiveIntege -->
  <!-- with the added restriction that values must be >= 18 -->
  <xsd:restriction base="xsd:positiveInteger">
  <xsd:minInclusive value="18"/>
  </xsd:restriction>
</xsd:simpleType>

<xsd:simpleType name="over59">
  <!-- over59 is an XMLS datatype based on positiveIntege -->
  <!-- with the added restriction that values must be >= 59 -->
  <xsd:restriction base="xsd:positiveInteger">
  <xsd:minInclusive value="60"/>
  </xsd:restriction>
</xsd:simpleType>

<xsd:simpleType name="clothingsize">
  <!-- clothingsize is an XMLS union datatype -->
  <!-- values of clothingsize may be either integers or strings -->
  <xsd:union>
     <xsd:simpleType>
       <xsd:restriction base='integer'/>
     </xsd:simpleType>
     <xsd:simpleType>
       <xsd:restriction base='string'/>
     </xsd:simpleType>
  </xsd:union>
</xsd:simpleType>

<xsd:simpleType name="XSDEnumerationHeight">
  <!-- This is an XMLS datatype valid values for which are the strings -->
  <!-- "short", "medium" and "tall". -->
  <xsd:restriction base="string">
    <xsd:enumeration value="short"/>
    <xsd:enumeration value="medium"/>
    <xsd:enumeration value="tall"/>
  </xsd:restriction>
</xsd:simpleType>

</xsd:schema>

<owl:Class rdf:ID="Adult">
  <owl:intersectionOf rdf:parseType="owl:collection">
    <owl:Class rdf:about="#Person"/>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#age"/>
      <owl:hasClass rdf:resource="http://www.w3c.org/2002/10/OwlGuide-dt#over17"/>
    </owl:Restriction>
  </owl:intersectionOf>
</owl:Class>

<owl:Class rdf:ID="Senior">
  <owl:intersectionOf rdf:parseType="owl:collection">
    <owl:Class rdf:about="#Person"/>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#age"/>
      <owl:hasClass rdf:resource="http://www.w3c.org/2002/10/OwlGuide-dt#over59"/>
    </owl:Restriction>
  </owl:intersectionOf>
</owl:Class>

  <Property ID="REGION">
    <functional />
    <range resource="#WINE-REGION"/>
    <domain resource="#WINE"/>
  </Property>