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.
3980 lines
164 KiB
3980 lines
164 KiB
<?xml version="1.0" encoding="iso-8859-1" ?>
|
|
<!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>
|
|
<title>OWL Web Ontology Language Reference</title>
|
|
<meta name="RCSId" content="$Id: Overview.html,v 1.4 2003/04/01 22:52:36 connolly Exp $"/>
|
|
<style type="text/css">
|
|
.issue {background-color: yellow}
|
|
.postponedissue {background-color: yellow}
|
|
.def code
|
|
.future {background-color: pink}
|
|
.draftedit {background-color: white}
|
|
.draftdelete {background-color: white}
|
|
.note { margin-left: 4em }
|
|
</style>
|
|
<link href="http://www.w3.org/StyleSheets/TR/W3C-WD.css"
|
|
type="text/css" rel="stylesheet" />
|
|
</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>OWL Web Ontology Language <br/> Reference</h1>
|
|
|
|
<h2>W3C Working Draft 31 March 2003</h2>
|
|
|
|
<dl>
|
|
<dt>This version:</dt>
|
|
|
|
<dd><a href="http://www.w3.org/TR/2003/WD-owl-ref-20030331/">http://www.w3.org/TR/2003/WD-owl-ref-20030331/</a></dd>
|
|
|
|
<dt>Latest version:</dt>
|
|
|
|
<dd><a href="http://www.w3.org/TR/owl-ref/">http://www.w3.org/TR/owl-ref/</a></dd>
|
|
|
|
|
|
<dt>Previous version:</dt>
|
|
|
|
<dd><a href="http://www.w3.org/TR/2003/WD-owl-ref-20030221/">http://www.w3.org/TR/2003/WD-owl-ref-20030221/</a></dd>
|
|
|
|
<dt>Editors:</dt>
|
|
|
|
<dd>
|
|
<a href="http://www.daml.org/people/mdean/">Mike Dean</a><br />
|
|
<a href="http://www.swi.psy.uva.nl/usr/Schreiber/home.html">Guus Schreiber</a><br />
|
|
</dd>
|
|
|
|
<dt>Authors:</dt>
|
|
|
|
<dd>
|
|
<a href="http://www.cs.vu.nl/~frankh/"> Frank van Harmelen</a><br />
|
|
<a href="http://www.cs.umd.edu/users/hendler/">Jim Hendler</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"><a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright"> Copyright</a> © 2003 <a href="http://www.w3.org/"><acronym title="World Wide Web Consortium">W3C</acronym></a><sup>®</sup> (<a href="http://www.lcs.mit.edu/"><acronym title="Massachusetts Institute of Technology">MIT</acronym></a>, <a href="http://www.ercim.org/"><acronym title="European Research Consortium for Informatics and Mathematics">ERCIM</acronym></a>, <a href="http://www.keio.ac.jp/">Keio</a>), All Rights Reserved. W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a>, <a href="http://www.w3.org/Consortium/Legal/copyright-documents">document use</a> and <a href="http://www.w3.org/Consortium/Legal/copyright-software">software licensing</a> rules apply.</p>
|
|
|
|
<hr />
|
|
</div>
|
|
|
|
<h2><a id="abstract" name="abstract">Abstract</a></h2>
|
|
|
|
<p>The Web Ontology Language OWL is a semantic markup language for publishing
|
|
and sharing ontologies on the World Wide Web. OWL is developed as a vocabulary
|
|
extension of
|
|
RDF (the Resource Description Framework) and is derived from the DAML+OIL Web
|
|
Ontology Language. This document contains a structured informal description
|
|
of the full set of OWL language constructs and is meant to serve as
|
|
a reference for OWL users who want to construct OWL ontologies. </p>
|
|
|
|
<div class="status">
|
|
<h2><a id="status" name="status">Status of this document</a></h2>
|
|
|
|
<p>This is a <a
|
|
href="http://www.w3.org/Consortium/Process-20010719/tr.html#last-call">Last
|
|
Call Working Draft</a>. The <a
|
|
href="http://www.w3.org/TR/2002/WD-owl-ref-20020729/">first release
|
|
of this document</a> was 29 July 2002 and the <a
|
|
href="http://www.w3.org/2001/sw/WebOnt">Web Ontology Working Group</a>
|
|
has made its best effort to address <a
|
|
href="http://lists.w3.org/Archives/Public/public-webont-comments/">comments
|
|
recieved</a> since then, releasing several drafts and resolving a <a
|
|
href="http://www.w3.org/2001/sw/WebOnt/webont-issues.html">list of
|
|
issues</a> meanwhile. The working group seeks confirmation that
|
|
comments have been addressed to the satisfaction of the community.</p>
|
|
|
|
|
|
<p>
|
|
Comments on this document are due <span class="commentsDue date">9 May
|
|
2003</span>. They should be sent to <a
|
|
href="mailto:public-webont-comments@w3.org">public-webont-comments@w3.org</a>,
|
|
a mailing list with a <a
|
|
href="http://lists.w3.org/Archives/Public/public-webont-comments/">public
|
|
archive</a>. General discussion of related technology is welcome in <a
|
|
href="http://lists.w3.org/Archives/Public/www-rdf-logic/">www-rdf-logic</a>.
|
|
</p>
|
|
|
|
|
|
<p>
|
|
This document has been produced as part of the <a
|
|
href="http://www.w3.org/2001/sw/">W3C Semantic Web Activity</a> (<a
|
|
href="http://www.w3.org/2001/sw/Activity">Activity Statement</a>).
|
|
A list of <a rel="disclosure"
|
|
href="http://www.w3.org/2001/sw/WebOnt/discl">patent disclosures
|
|
related to this work</a> is maintained by W3C, regardless of whether
|
|
any such disclosures have been made or not.</p>
|
|
|
|
<p>
|
|
<em>This is a W3C Working
|
|
Draft for review by W3C members and other interested parties. It is a draft
|
|
document and may be updated, replaced, or obsoleted by other documents at any
|
|
time. It is inappropriate to use W3C Working Drafts as reference materials or to
|
|
cite them as other than "work in progress." A list of <a
|
|
href="http://www.w3.org/TR/">current W3C
|
|
Recommendations and other technical documents</a> can be found at http://www.w3.org/TR/.</em>
|
|
</p>
|
|
</div>
|
|
|
|
|
|
<h2><a id="acknowledge" name="acknowledge">Acknowledgments</a></h2>
|
|
|
|
<p>Parts of this document are derived from the DAML+OIL (March 2001) Reference
|
|
Description [<cite><a href="#ref-daml">DAML+OIL</a></cite>] which was
|
|
submitted as part of the
|
|
<a href="http://www.w3.org/Submission/2001/12/">DAML+OIL W3C Note
|
|
</a>.
|
|
The sponsors of this document and its
|
|
predecessor documents are gratefully acknowledged.
|
|
</p>
|
|
<p>Jeremy Carroll, Jim Hendler, Brian McBride and
|
|
Peter Patel-Schneider provided
|
|
substantive reviews and contributed text to this document. Jeff Heflin
|
|
contributed the section on deprecation. Jerome Euzenat
|
|
contributed the example for an enumerated datatype.
|
|
</p>
|
|
<p>
|
|
This document is the result of extensive discussions within the
|
|
<a href="http://www.w3.org/2001/sw/WebOnt/">Web Ontology Working Group
|
|
</a>as a whole. The members of this group working group included:
|
|
Yasser al Safadi, Jean-Francois Baget, James Barnette, Sean
|
|
Bechhofer, Jonathan Borden, Frederik Brysse, Stephen Buswell, Peter
|
|
Crowther, Jos De Roo, David De Roure, Mike Dean, Larry Eshelman,
|
|
Jerome Euzenat, Dieter Fensel, Tim Finin, Nicholas Gibbins, Pat
|
|
Hayes, Jeff Heflin, Ziv Hellman, James Hendler, Bernard Horan,
|
|
Masahiro Hori, Ian Horrocks, Francesco Iannuzzelli, Mario Jeckle,
|
|
Ruediger Klein, Ora Lassila, Alexander Maedche, Massimo Marchiori,
|
|
Deborah McGuinness, Libby Miller, Enrico Motta, Leo Obrst, Laurent
|
|
Olivry , Peter Patel-Schneider, Martin Pike, Marwan Sabbouh, Guus
|
|
Schreiber, Shimizu Noboru, Michael Sintek, Michael Smith, Ned
|
|
Smith, John Stanton, Lynn Andrea Stein, Herman ter Horst, Lynne R.
|
|
Thompson, David Trastour, Frank van Harmelen, Raphael Volz, Evan
|
|
Wallace, Christopher Welty, and John Yanosy.
|
|
</p>
|
|
|
|
|
|
<h2><a id="contents" name="contents">Contents</a></h2>
|
|
|
|
<ul class="toc">
|
|
<li><a href="#abstract">Abstract</a></li>
|
|
<li><a href="#status">Status of this document</a></li>
|
|
<li><a href="#acknowledge">Acknowledgments</a></li>
|
|
<li><a href="#Intro">1. Introductory remarks</a>
|
|
<ul class="toc">
|
|
<li><a href="#Purpose">1.1 Purpose of this document</a></li>
|
|
<li><a href="#Sublanguages">1.2 OWL Full/DL/Lite</a></li>
|
|
<li><a href="#Syntax">1.3 OWL syntax</a></li>
|
|
<li><a href="#Semantics">1.4 OWL and RDF semantics</a></li>
|
|
<li><a href="#Examples">1.5 A note about the examples</a></li>
|
|
<li><a href="#Privacy">1.6 Data aggregation and privacy</a></li>
|
|
<li><a href="#AppendixList">1.7 Appendices of this document</a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#OWLDocument">2. OWL document</a>
|
|
<ul class="toc">
|
|
<li><a href="#DocumentContent">2.1 Content</a></li>
|
|
<li><a href="#owl-uri-namespace">2.2 OWL URI vocabulary and namespace</a></li>
|
|
<li><a href="#MIMEType">2.3 MIME type</a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#Class">3. Classes</a>
|
|
<ul class="toc">
|
|
<li><a href="#ClassDescription">3.1 Class descriptions</a>
|
|
<ul class="toc">
|
|
<li><a href="#EnumeratedClass">3.1.1 Enumeration</a></li>
|
|
<li><a href="#Restriction">3.1.2 Property restriction</a>
|
|
<ul class="toc">
|
|
<li><a href="#ValueRestriction">3.1.2.1 Value constraints</a>
|
|
<ul class="toc">
|
|
<li><a href="#allValuesFrom-def">owl:allValuesFrom</a></li>
|
|
<li><a href="#someValuesFrom-def">owl:someValuesFrom</a></li>
|
|
<li><a href="#hasValue-def">owl:hasValue</a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#CardinalityRestriction">3.1.2.2 Cardinality
|
|
constraints</a>
|
|
<ul class="toc">
|
|
<li><a href="#maxCardinality-def">owl:maxCardinality</a></li>
|
|
<li><a href="#minCardinality-def">owl:minCardinality</a></li>
|
|
<li><a href="#cardinality-def">owl:cardinality</a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#Boolean">3.1.3 Intersection, union and complement</a>
|
|
<ul class="toc">
|
|
<li><a href="#intersectionOf-def">owl:intersectionOf</a></li>
|
|
<li><a href="#unionOf-def">owl:unionOf</a></li>
|
|
<li><a href="#complementOf-def">owl:complementOf</a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#ClassAxioms">3.2 Class axioms</a>
|
|
<ul class="toc">
|
|
<li><a href="#subClassOf-def">3.2.1 rdfs:subClassOf</a></li>
|
|
<li><a href="#equivalentClass-def">3.2.2 owl:equivalentClass</a></li>
|
|
<li><a href="#DescriptionAxiom">3.2.3 Axioms for complete classes without
|
|
using owl:equivalentClass</a></li>
|
|
<li><a href="#disjointWith-def">3.2.4 owl:disjointWith</a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#Property">4. Properties</a>
|
|
<ul class="toc">
|
|
<li><a href ="#RDFSProperty">4.1 RDF Schema property constructs</a>
|
|
<ul class="toc">
|
|
<li><a href="#subPropertyOf-def">rdfs:subPropertyOf</a></li>
|
|
<li><a href="#domain-def">rdfs:domain</a></li>
|
|
<li><a href="#range-def">rdfs:range</a></li>
|
|
</ul></li>
|
|
<li><a href="#PropertyRelation">4.2 Relations to other properties</a>
|
|
<ul class="toc">
|
|
<li><a href="#equivalentProperty-def">owl:equivalentProperty</a></li>
|
|
<li><a href="#inverseOf-def">owl:inverseOf</a></li>
|
|
</ul></li>
|
|
<li><a href="#PropertyCardinality">4.3 Global cardinality restrictions on properties</a>
|
|
<ul class="toc">
|
|
<li><a href="#FunctionalProperty-def">owl:FunctionalProperty</a></li>
|
|
<li><a href="#InverseFunctionalProperty-def">owl:InverseFunctionalProperty</a></li>
|
|
</ul></li>
|
|
<li><a href="#PropertyLogic">4.4 Logical characteristics of properties</a>
|
|
<ul class="toc">
|
|
<li><a href="#TransitiveProperty-def">owl:TransitiveProperty</a></li>
|
|
<li><a href="#SymmetricProperty-def">owl:SymmetricProperty</a></li>
|
|
</ul></li>
|
|
</ul></li>
|
|
<li><a href="#Individual">5. Individuals</a>
|
|
<ul class="toc">
|
|
<li><a href="#IndividualAxiom">5.1 Individual axioms ("facts")</a></li>
|
|
<li><a href="#IndividualIdentity">5.2 Individual identity</a>
|
|
<ul class="toc">
|
|
<li><a href="#sameIndividualAs-def">owl:sameAs and owl:sameIndividualAs</a></li>
|
|
<li><a href="#differentFrom-def">owl:differentFrom</a></li>
|
|
<li><a href="#AllDifferent-def">owl:AllDifferent</a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#Datatype">6. Datatypes</a>
|
|
<ul class="toc">
|
|
<li><a href="#rdf-datatype">6.1 RDF Datatypes</a></li>
|
|
<li><a href="#EnumeratedDatatype">6.2 Enumerated datatype using
|
|
owl:oneOf</a></li>
|
|
<li><a href="#DatatypeSupport">6.3 Support for datatype reasoning</a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#Header">7. Annotations, ontology header, imports and version information</a>
|
|
<ul class="toc">
|
|
<li><a href="#Annotations">7.1 Annotations</a></li>
|
|
<li><a href="#Ontology-def">7.2 Ontology header</a></li>
|
|
<li><a href="#imports-def">7.3 Importing ontologies</a></li>
|
|
<li><a href="#VersionInformation">7.4 Version information</a>
|
|
<ul class="toc">
|
|
<li><a href="#versionInfo-def">owl:versionInfo</a></li>
|
|
<li><a href="#priorVersion-def">owl:priorVersion</a></li>
|
|
<li><a href="#backwardCompatibleWith-def">owl:backwardCompatibleWith</a></li>
|
|
<li><a href="#incompatibleWith-def">owl:incompatibleWith</a></li>
|
|
<li><a href="#Deprecation">owl:DeprecatedClass and owl:DeprecatedProperty</a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#Sublanguage-def">8. OWL Lite/DL/Full constructs</a>
|
|
<ul class="toc">
|
|
<li><a href="#OWLFull">8.1 OWL Full</a></li>
|
|
<li><a href="#OWLDL">8.2 OWL DL</a></li>
|
|
<li><a href="#OWLLite">8.3 OWL Lite</a></li>
|
|
</ul></li>
|
|
<li>Appendix A: <a href="#appA">Index of all language elements</a></li>
|
|
<li>Appendix B: <a href="#appB">RDF Schema of OWL</a></li>
|
|
<li>Appendix C: <a href="#appC">OWL Quick Reference</a></li>
|
|
<li>Appendix D: <a href="#appD">Changes from DAML+OIL</a></li>
|
|
<li><a href="#References">References</a></li>
|
|
</ul>
|
|
|
|
|
|
<hr/>
|
|
|
|
<h2><a name="Intro"></a>1. Introductory remarks </h2>
|
|
|
|
<h3><a name="Purpose"></a>1.1 Purpose of this document</h3>
|
|
|
|
<p>This document gives a systematic, compact and informative description
|
|
of all the modelling primitives of OWL, using the RDF/XML
|
|
exchange syntax for OWL. We expect this document to
|
|
serve as a reference guide for users of the OWL language. Readers
|
|
unfamiliar with OWL may wish to first consult the OWL Overview
|
|
document
|
|
[<cite><a href="#ref-overview">OWL Overview</a></cite>],
|
|
and subsequently the OWL Guide
|
|
[<cite><a href="#ref-guide">OWL Guide</a></cite>]
|
|
for a more narrative description and examples of the use of
|
|
the language.</p>
|
|
|
|
<p>This document assumes the reader is familiar with the basic concepts of
|
|
RDF [<cite><a href="#ref-rdf-concepts">RDF Concepts</a></cite>] and has a
|
|
working knowledge of the RDF/XML syntax
|
|
[<cite><a href="#ref-rdf-xml-syntax">RDF/XML Syntax</a></cite>] and of RDF
|
|
Schema [<cite><a href="#ref-rdf-schema">RDF Schema</a></cite>].</p>
|
|
|
|
<p>The normative reference on the precise syntax of the OWL language
|
|
constructs can be found in the OWL
|
|
Semantics and Abstract Syntax document [<cite><a
|
|
href="#ref-abstract-syntax">OWL S&AS</a></cite>]. This
|
|
document also contains a precise definition of the meaning of the
|
|
language constructs in the form of a model-theoretic semantics.</p>
|
|
|
|
<p>Uses cases and requirements for the OWL language are described in the OWL
|
|
requirements document
|
|
[<cite><a href="#ref-requirements">OWL Use Cases and Requirements</a></cite>].
|
|
Test cases for OWL tools are specified in the Test document
|
|
[<cite><a href="#ref-test-cases">OWL Test Cases</a></cite>] .
|
|
</p>
|
|
|
|
|
|
<h3><a name="Sublanguages" id="Sublanguages"></a>1.2 OWL Full/DL/Lite </h3>
|
|
|
|
<p>As also discussed in the
|
|
OWL Overview document
|
|
[<cite><a href="#ref-overview">OWL Overview</a></cite>],
|
|
and subsequently the OWL Guide
|
|
[<cite><a href="#ref-guide">OWL Guide</a></cite>],
|
|
the OWL language provides two specific subsets that we believe will
|
|
be of use to implementors and language users. OWL Lite was
|
|
designed for easy implementation and to provide users with a
|
|
functional subset that will get them started in the use of OWL.
|
|
OWL DL (where DL stands for "Description Logic")
|
|
was designed to support the existing
|
|
Description Logic business segment and to provide a language subset
|
|
that has desirable computational properties for reasoning systems.
|
|
The complete OWL language (called OWL Full to distinguish it from the
|
|
subsets) relaxes some of the constraints on OWL DL so as to make available
|
|
features which may be of use to many database and knowledge
|
|
representation systems, but which violate the constraints of
|
|
Description Logic reasoners.</p>
|
|
|
|
<p>OWL Full and OWL DL support the same set of OWL language constructs.
|
|
Their difference lies in restrictions on the use of some of those
|
|
features and on the use of RDF features.
|
|
OWL Full allows free mixing of OWL with RDF Schema and,
|
|
like RDF Schema, does not enforce a strict separation of classes,
|
|
properties, individuals and data values. OWL DL puts constraints on the mixing
|
|
with RDF and requires disjointness of classes, properties, individuals
|
|
and data values. The main reason for having the OWL DL sublanguage is
|
|
that tool builders have developed powerful reasoning systems which
|
|
support ontologies constrained by the restrictions required for OWL
|
|
DL. For the formal definitions of the differences between OWL Full
|
|
and OWL DL the reader is referred to the Semantics and Abstract Syntax
|
|
document
|
|
[<cite><a href="#ref-abstract-syntax">OWL S&AS</a></cite>].
|
|
<a href="#OWLDL">Sect. 8.2 OWL DL</a>
|
|
summarizes the
|
|
differences between OWL Full and OWL DL.</p>
|
|
|
|
<p>OWL Lite is a sublanguage of OWL DL that supports only a subset of the
|
|
OWL language constructs. OWL Lite is particularly targeted at tool
|
|
builders, who want to support OWL, but want to start with a
|
|
relatively simple basic set of language features.
|
|
OWL Lite abides by the same semantic restrictions as OWL DL,
|
|
allowing reasoning engines to guarantee certain desirable properties.
|
|
A summary of the language constructs allowed in OWL Lite is given in
|
|
Section 8.3 <a href="#OWLLite">"OWL Lite constructs"</a>.
|
|
For a
|
|
more formal description of the subset of OWL language constructs
|
|
supported by OWL Lite the reader is referred to the Semantics and
|
|
Abstract Syntax document
|
|
[<cite><a href="#ref-abstract-syntax">OWL S&AS</a></cite>]. </p>
|
|
|
|
<p class="note">
|
|
NOTE: RDF users upgrading to OWL should be aware that OWL Lite is <em>not</em>
|
|
simply an extension of RDF Schema. OWL Lite is a a light
|
|
version of OWL DL and puts
|
|
constraints on the use of the RDF vocabulary (<em>e.g.</em>, disjointness of
|
|
classes,
|
|
properties, etc.). OWL Full is designed for maximal RDF compatibility and is
|
|
therefore the natural place to start for RDF users. When opting for either OWL
|
|
DL or OWL Lite one should consider whether the advantages of OWL DL/Lite
|
|
(<em>e.g.</em>, reasoning support) outweigh
|
|
the DL/Lite restrictions on the use of OWL and RDF constructs.
|
|
</p>
|
|
|
|
|
|
<h3><a name="Syntax"></a>1.3 OWL syntax </h3>
|
|
|
|
<p>
|
|
An OWL ontology is encoded and written as an RDF graph
|
|
[<cite><a href="#ref-rdf-concepts">RDF Concepts</a></cite>],
|
|
which is in turn a set of RDF triples.
|
|
As with any RDF graph, an OWL ontology graph can be
|
|
written in many different syntactic forms (as described in the
|
|
RDF/XML Syntax Specification (Revised)
|
|
[<cite><a href="#ref-rdf-xml-syntax">RDF/XML Syntax</a></cite>]).
|
|
This document (as does the Guide document)
|
|
uses some specific syntactic forms of RDF/XML for representing triples.
|
|
However, the meaning of an OWL ontology is solely determined by the
|
|
RDF graph. Thus, it is allowable to use any syntactic RDF
|
|
forms, as long as these
|
|
result in the same underlying set of RDF triples.
|
|
Such other syntactic forms would then carry exactly the same
|
|
prescribed meaning as the syntactic form used in this
|
|
document. </p>
|
|
|
|
<p>As a simple example of an alternative syntactic
|
|
form resulting in the same RDF graph, consider
|
|
the following RDF/XML syntax:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="Continent"/>
|
|
</pre>
|
|
|
|
<p>The following RDF/XML syntax:</p>
|
|
|
|
<pre>
|
|
<rdf:Description rdf:about="#Continent">
|
|
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
|
|
</rdf:Description>
|
|
</pre>
|
|
|
|
<p>encodes the same set of RDF triples, and therefore
|
|
would convey the same meaning.</p>
|
|
|
|
<h3><a name="Semantics"></a>1.4 OWL and RDF semantics</h3>
|
|
|
|
<p>OWL is a vocabulary extension of RDF. Thus any RDF graph forms an OWL
|
|
Full ontology. Further, the meaning given to an RDF graph by OWL includes the
|
|
meaning given to the graph by RDF. OWL Full
|
|
ontologies can thus include arbitrary
|
|
RDF content, which is treated in a manner consistent with its treatment by RDF.
|
|
OWL assigns an additional meaning to certain RDF triples. The
|
|
OWL Semantics and Abstract Syntax document
|
|
[<cite><a href="#ref-abstract-syntax">OWL
|
|
S&AS</a></cite>] specifies exactly which triples are assigned a
|
|
specific meaning, and what this meaning is.</p>
|
|
|
|
<p class="note">
|
|
NOTE: As remarked before,
|
|
OWL DL and OWL Lite extend the RDF vocabulary, but also put restrictions
|
|
on the use of this vocabulary.
|
|
</p>
|
|
|
|
|
|
<h3><a name="Examples">1.5 A note about the examples</a></h3>
|
|
|
|
<p>For readability purposes the examples in this document assume the
|
|
XML entities <code>&rdf;</code>, <code>&rdfs;</code>,
|
|
<code>&owl;</code> and <code>&xsd;</code> (for XML Schema datatypes)
|
|
are defined in the same way
|
|
as in <a href="#appB">Appendix B</a>. The same assumption holds for the
|
|
corresponding namespaces <code>rdf:</code>, <code>rdfs:</code>,
|
|
<code>owl:</code> and <code>xsd:</code>.</p>
|
|
|
|
<p>The examples in this document are meant to serve as illustrations of the
|
|
use of OWL language constructs. They do not form one consistent ontology. For
|
|
an extended example the reader is referred to the Guide document
|
|
[<cite><a href="#ref-guide">OWL Guide</a></cite>]. </p>
|
|
|
|
<h3><a id="Privacy" name="Privacy">1.6 Data Aggregation and Privacy</a></h3>
|
|
|
|
<p>
|
|
OWL's ability to express ontological information about individuals
|
|
appearing in multiple documents supports linking of data from diverse
|
|
sources in a principled way. The underlying semantics provides
|
|
support for inferences over this data that may yield unexpected
|
|
results. In particular, the ability to express equivalences using
|
|
<a href="#sameIndividualAs-def">owl:sameIndiviidualAs</a>
|
|
can be used to state that seemingly
|
|
different individuals are actually the same.
|
|
Similarly,
|
|
<a href="#InverseFunctionalProperty-def">owl:InverseFunctionalProperty</a>
|
|
can be used to link
|
|
individuals together.
|
|
For example, if a property such as <code>SocialSecurityNumber</code>
|
|
is an
|
|
<code>owl:InverseFunctionalProperty</code>, then two separate individuals
|
|
could be inferred to be identical based on having the same value of
|
|
that property. When individuals are determined to be the same by such
|
|
means, information about them from different sources can be
|
|
merged. This <em>aggregation</em> can be used to determine facts that
|
|
are not <em>directly</em> represented in any one source.
|
|
</p>
|
|
|
|
|
|
<h3><a name="AppendixList">1.7 Appendices to this document</a></h3>
|
|
|
|
<p>
|
|
This document has a set of appendices containing additional information.
|
|
</p>
|
|
|
|
<p>Links in this document that are attached to definitions of
|
|
language constructs provide access to the
|
|
OWL Semantics and Abstract Syntax
|
|
[<cite><a href="#ref-abstract-syntax">OWL S&AS</a></cite>].
|
|
<a href="#appA">Appendix A</a> contains a
|
|
systematic set of links for each language construct to the
|
|
corresponding sections in the Guide and the S&AS documents.</p>
|
|
|
|
<p><a href="#appB">Appendix B</a>
|
|
contains an RDF schema for the OWL language constructs.
|
|
This schema defines the OWL language constructs in terms of RDF Schema
|
|
classes and properties.
|
|
This schema
|
|
provides the basis for the RDF/XML syntax of OWL. Conventionally, classes
|
|
have a leading uppercase character; properties a leading
|
|
lowercase character. Thus, <code>owl:Ontology</code> is a class, and
|
|
<code>owl:imports</code> is a property.
|
|
<a href="#appC">Appendix C</a> gives a tabular overview of all
|
|
OWL language constructs in
|
|
terms of the built-in OWL classes and properties (the latter
|
|
with their domain and
|
|
range).</p>
|
|
|
|
<p class="note">
|
|
NOTE: The RDF Schema file for OWL is not expected to be imported explicitly
|
|
(<em>i.e. </em> with <code>owl:imports</code>) into an ontology. The schema
|
|
has an informative status and is
|
|
meant to provide the classes and properties to be used in the RDF/XML syntax.
|
|
This schema does not make distinctions between OWL Full, OWL DL and OWL Lite. People
|
|
that do import this schema should expect the resulting ontology to be an OWL
|
|
Full ontology.</p>
|
|
|
|
<p>For readers familiar with DAML+OIL, <a href="#appD">Appendix D </a> lists
|
|
many of the changes between DAML+OIL and OWL.</p>
|
|
|
|
|
|
<h2><a name="OWLDocument"></a>2. OWL document</h2>
|
|
|
|
Information in OWL is gathered into ontologies, which can then be
|
|
stored as documents in the World Wide Web. One aspect of OWL, the
|
|
importing of ontologies, depends on this ability to store OWL
|
|
ontologies in the Web.
|
|
|
|
<h3><a name="DocumentContent">2.1 Content</a></h3>
|
|
|
|
<p>An OWL document consists of optional
|
|
<a href="#Header">ontology headers</a> (generally at most one)
|
|
plus any number of
|
|
<a href="#Class">class axioms</a>, <a
|
|
href="#Property">property axioms</a>,
|
|
and <a href="#Individual">facts about individuals</a>.
|
|
Please note that "axiom" is the formal term used in the S&AS
|
|
document. These axioms are somewhat more informally called
|
|
"definitions" in the Guide and Overview documents.</p>
|
|
|
|
<p class="note">
|
|
NOTE: OWL does not impose any order on OWL components.
|
|
Humans writing ontologies are likely to use some sort of ordering, for example
|
|
putting the ontology header in the beginning, but this has no impact on the
|
|
meaning. Tools should not assume any order.
|
|
</p>
|
|
|
|
<p>As with any RDF document, the OWL code should be subelements of
|
|
an <code>rdf:RDF</code> element.
|
|
This enclosing element generally holds XML namespace and base declarations.
|
|
Also, an OWL ontology document often starts with several entity declarations.
|
|
For a typical example of this sort of information, see the <a
|
|
href="http://www.w3.org/TR/owl-guide/wine.owl">wine.owl</a> file,
|
|
which contains the example wine ontology
|
|
discussed in the Guide document.</p>
|
|
|
|
|
|
<h3><a name="owl-uri-namespace">2.2 OWL built-in vocabulary</a></h3>
|
|
|
|
<p>
|
|
The built-in vocabulary for OWL all comes from the OWL namespace </p>
|
|
|
|
<p class="note">
|
|
<code>http://www.w3.org/2002/07/owl#</code>
|
|
</p>
|
|
|
|
<p>conventionally associated with the namespace name <code>owl</code>.
|
|
It is
|
|
recommended that ontologies not use names from this namespace except
|
|
for the built-in vocabulary. OWL tool builders should feel free to
|
|
signal a warning if other names from this namespace are used, but
|
|
should otherwise continue as normal.</p>
|
|
|
|
|
|
<h3><a name="MIMEType">2.3 MIME type</a></h3>
|
|
|
|
<p>
|
|
The Web Ontology Working Group has not requested a separate MIME type for OWL
|
|
documents. Instead, we recommend to use the MIME type requested by the RDF Core
|
|
Working Group, namely <code>application/rdf+xml</code>
|
|
[<cite><a href="#ref-rdf-concepts">RDF Concepts</a></cite>],
|
|
or alternatively the
|
|
XML MIME type <code>application/xml</code>.</p>
|
|
|
|
<p>As file extension, we recommend to use either <code>.rdf</code> or
|
|
<code>.owl</code>.
|
|
</p>
|
|
|
|
|
|
<!--
|
|
SECTION 3: Classes
|
|
-->
|
|
|
|
<h2><a name="Class" id="Class">3. Classes</a></h2>
|
|
|
|
<p>Classes provide an abstraction mechanism for grouping resources with
|
|
similar characteristics. Like RDF classes, every OWL
|
|
class is associated with a set of individuals, called the <em>class
|
|
extension</em>. The individuals in the class extension are called the
|
|
<em>instances</em> of the class. A class has an intensional meaning
|
|
(the underlying concept) which is related but not equal to its class
|
|
extension. Thus, two classes may have the same class extension, but still be
|
|
different classes.</p>
|
|
|
|
<p>When in this document we use wording such as "a class of individuals
|
|
..", this should be read as the "a class with a class extension containing
|
|
individuals ...".
|
|
</p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL Lite and OWL DL an individual can never be at the same time a
|
|
class: classes and individuals form disjoint domains (as do properties and data
|
|
values). OWL Full allows the freedom of RDF Schema: a class may act as an
|
|
instance of another (meta)class (the same holds for properties).</p>
|
|
|
|
|
|
<p>OWL classes are described through "class descriptions", which can be
|
|
combined into "class axioms". We first describe class descriptions and
|
|
subsequently turn to class axioms. </p>
|
|
|
|
<h3><a name="ClassDescription" id="ClassDescription">3.1 Class descriptions</a></h3>
|
|
|
|
<p>A class description is the term used in this document (and in the OWL
|
|
Semantics and Abstract Syntax) for the basic building blocks of class axioms
|
|
(informally called class definitions in the Overview and Guide documents).
|
|
OWL distinguishes six types of class descriptions:
|
|
</p>
|
|
<ol>
|
|
<li>a class identifier (a URI reference)</li>
|
|
<li>an exhaustive <a href="#EnumeratedClass">enumeration</a> of individuals
|
|
that together form the instances of a class</li>
|
|
<li>a <a href="#Restriction">property restriction</a></li>
|
|
<li>the <a href="#intersectionOf-def">intersection</a> of two or more class
|
|
descriptions</li>
|
|
<li>the <a href="#unionOf-def">union</a> of two or more class
|
|
descriptions</li>
|
|
<li>the <a href="#complementOf-def">complement</a> of a class description</li>
|
|
</ol>
|
|
|
|
<p>The first type describes a class through a name.
|
|
The other five types of class descriptions define an
|
|
anonymous class, respectively
|
|
a class that contains exactly the enumerated
|
|
individuals (2nd type),
|
|
a class of all individuals which satisfy a
|
|
particular property restriction (3rd type),
|
|
or a class that satisfies boolean combinations of
|
|
class descriptions (4th, 5th and 6th type).
|
|
Intersection, union and complement can be respectively seen as
|
|
the logical AND, OR and NOT operators.
|
|
The four latter types of class descriptions lead to nested class
|
|
descriptions and can thus in theory lead to arbitrarily complex class
|
|
descriptions. In practice, the level of nesting is usually limited. </p>
|
|
|
|
<p>A type 1 class description is syntactically represented as an named
|
|
instance of
|
|
<code>owl:Class</code>, a subclass of <code>rdfs:Class</code>:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="Human"/>
|
|
</pre>
|
|
|
|
<p>This will assert the triple <code>"Human rdf:type owl:Class ."</code>.</p>
|
|
|
|
<p class="note">NOTE: In OWL Lite and OWL DL, <code>owl:Class</code>
|
|
must be used for all class descriptions. </p>
|
|
|
|
<p class="note">NOTE:
|
|
<code>owl:Class</code> is defined as a subclass of
|
|
<code>rdfs:Class</code>. The rationale for having a separate OWL
|
|
class construct lies in the restrictions on OWL
|
|
DL (and thus also on OWL Lite), which imply that not all RDFS classes are legal
|
|
OWL DL classes. In OWL Full these restrictions do not exist and therefore
|
|
<code>owl:Class</code> and <code>rdfs:Class</code> are the same there. </p>
|
|
|
|
|
|
<p>The other five forms of class descriptions are represented as anonymous
|
|
instances of <code>owl:Class</code> (a blank node with the <code>rdf:type
|
|
owl:Class</code>).</p>
|
|
|
|
<p class="note">NOTE:
|
|
If one provides an RDF identifier for class descriptions of the
|
|
type 2-6, this has the extra effect of providing a way of
|
|
referring to the class description by its name, <em>i.e.,</em> as a class
|
|
description of type 1.
|
|
See Section <a href="#DescriptionAxiom">3.2.3</a> for details.</p>
|
|
|
|
<p>Two OWL class identifiers are predefined, namely the classes <a name="Thing-def"
|
|
id="Thing-def"></a> <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_Thing_semantics">owl:Thing</a></span>
|
|
and <a name="Nothing-def" id="Nothing-def"></a> <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_Nothing_semantics">owl:Nothing</a></span>.
|
|
The class extension of <code>owl:Thing</code> is the set of all individuals in
|
|
the domain of discourse. The class extension of <code>owl:Nothing</code> is the
|
|
empty set. Consequently, every OWL class is a
|
|
subclass of <code>owl:Thing</code> and <code>owl:Nothing</code> is a subclass
|
|
of every class (for the meaning of the subclass relation, see the section on <a
|
|
href="#subClassOf-def"><code>rdfs:subClassOf</code></a>).</p>
|
|
|
|
<p class="note">
|
|
NOTE: <code>owl:Nothing</code> is not included in OWL Lite.</p>
|
|
|
|
<h4><a name="EnumeratedClass" id="EnumeratedClass">3.1.1 Enumeration</a></h4>
|
|
|
|
<p>A <a name="oneOf-def" id="oneOf-def"></a> class description of the
|
|
"enumeration" kind is defined with the
|
|
<span class="def"><a href="http://www.w3.org/TR/owl-semantics/direct#owl_oneOf_semantics">owl:oneOf</a></span>
|
|
property, which points to a list of individuals
|
|
that are the <a href="#Individual">instances</a> of the class.
|
|
This enables a class to be defined by
|
|
exhaustively enumerating its instances.
|
|
The class extension of the class defined with
|
|
<code>owl:oneOf</code>
|
|
contains exactly the enumerated
|
|
individuals, no more, no less. The list of individuals is typically
|
|
represented with the help of the RDF construct
|
|
<code>rdf:parseType="Collection"</code>, which provides a convenient shorthand for
|
|
writing down a set of list elements.
|
|
For example, the following RDF/XML syntax
|
|
defines a class of all continents:</p>
|
|
|
|
<pre>
|
|
<owl:Class>
|
|
<owl:oneOf rdf:parseType="Collection">
|
|
<owl:Thing rdf:about="#Eurasia"/>
|
|
<owl:Thing rdf:about="#Africa"/>
|
|
<owl:Thing rdf:about="#NorthAmerica"/>
|
|
<owl:Thing rdf:about="#SouthAmerica"/>
|
|
<owl:Thing rdf:about="#Australia"/>
|
|
<owl:Thing rdf:about="#Antarctica"/>
|
|
</owl:oneOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p> The RDF/XML syntax <code><owl:Thing rdf:about="..."/></code>
|
|
refers to some individual (remember:
|
|
all individuals are by definition instances of
|
|
<code>owl:Thing</code>).</p>
|
|
|
|
<p>In the section on datatypes we will see another use of
|
|
the <code>owl:oneOf</code> construct, namely to define an <a
|
|
href="#EnumeratedDatatype">enumeration of data values</a>.</p>
|
|
|
|
<p class="note">NOTE: Enumeration is not part of OWL Lite</p>
|
|
|
|
<h4><a name="Restriction" id="Restriction">3.1.2 Property restrictions</a></h4>
|
|
|
|
<p>A property restriction is a special kind of class
|
|
description. It defines an anonymous class, namely a class of
|
|
all individuals that satisfy the restriction.
|
|
OWL distinguishes two kinds of restrictions: value constraints and cardinality
|
|
constraints.</p>
|
|
|
|
<p>A <a href="#ValueRestriction">value constraint</a> puts constraints on the
|
|
value range of the property <em>when applied to this particular class
|
|
description</em>.
|
|
For example, we might want to
|
|
refer to those individuals whose value of the property <code>adjacentTo</code>
|
|
should be a <code>Region</code>,
|
|
and then use this within a class axiom, perhaps
|
|
even a class axiom for <code>Region</code> itself.
|
|
Note that this is very different from <code>rdfs:range</code>, which is
|
|
applied to all situations in which the property is used.</p>
|
|
|
|
<p>A <a href="#CardinalityRestriction">cardinality
|
|
constraint</a> puts constraints on the number of values a property can take,
|
|
<em>in the context of this particular class description</em>.
|
|
For example, we might want to say that for a soccer team the
|
|
<code>hasPlayer</code>
|
|
property has 11 values. For a basketball team the same property
|
|
would have only 5 values. </p>
|
|
|
|
<p>OWL also supports a limited set of constructs for defining global property
|
|
cardinality, namely the <a href="#FunctionalProperty-def">owl:FunctionalProperty</a> and
|
|
the <a href="#InverseFunctionalProperty-def"> owl:InverseFunctionalProperty</a>
|
|
definitions (see the section on properties).</p>
|
|
|
|
<p>Property restrictions have the following general form:</p>
|
|
|
|
<pre>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="(some property)" />
|
|
(precisely one value or cardinality constraint, see below)
|
|
</owl:Restriction>
|
|
</pre>
|
|
|
|
<p>The class
|
|
<a name="Restriction-def" id="Restriction-def"></a><span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_Restriction_semantics">owl:Restriction</a></span>
|
|
is defined as a subclass of <a href="#Class-def"><code>owl:Class</code></a>.
|
|
A restriction class should
|
|
have exactly one triple linking
|
|
the restriction to a particular property, using the <a
|
|
name="onProperty-def" id="onProperty-def"></a><span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_onProperty_semantics"> owl:onProperty</a></span>
|
|
property. The restriction class should also have exactly
|
|
one triple that represents the value constraint <em>c.q.</em> cardinality
|
|
constraint on the property under consideration, <em>e.g.</em>, that the
|
|
cardinality of the property is exactly 1. </p>
|
|
|
|
<p>Property restrictions can be applied both to <a
|
|
href="#DatatypeProperty-def">datatype properties</a> (properties for which the
|
|
range value is a data literal) and <a href="#ObjectProperty-def">object
|
|
properties</a> (properties for which the range value is an individual). For
|
|
more information about this distinction, see the section on
|
|
<a href="#Property">properties</a>. </p>
|
|
|
|
<h5><a name="ValueRestriction">3.1.2.1 Value constraints</a></h5>
|
|
|
|
<h6><a name="allValuesFrom-def" id="allValuesFrom-def">owl:allValuesFrom</a></h6>
|
|
|
|
<p>The value constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_allValuesFrom_semantics">owl:allValuesFrom</a></span>
|
|
is a built-in OWL
|
|
property that links a restriction class to either a <a
|
|
href="#ClassDescription">class description</a> or a <a href="#DataRange">data
|
|
range</a>. A restriction containing an <code>owl:allValuesFrom</code>
|
|
constraint is used to describe a class of all individuals for which all range
|
|
values of the property under consideration are either members of the class
|
|
extension of the class description or are data values within the specified data
|
|
range. In other words, it defines a class of individuals x for which holds
|
|
that if the pair (x,y) is an instance of P (the property concerned), then y
|
|
should be an instance of the class description or a value in the data range,
|
|
respectively. </p>
|
|
|
|
<p>A simple example:</p>
|
|
<pre>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasParent" />
|
|
<owl:allValuesFrom rdf:resource="#Human" />
|
|
</owl:Restriction>
|
|
</pre>
|
|
|
|
<p>This example describes an anonymous OWL class of all individuals for which
|
|
the <code>hasParent</code> property only has range values of class
|
|
<code>Human</code>. Note that this class description does not state that the property
|
|
always has range values of this class; just that this is true for individuals
|
|
of the anonymous restriction class. </p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL Lite the range value of <code>owl:allValuesFrom</code> must be
|
|
a class identifier.</p>
|
|
|
|
<p>An <code><a href="#allValuesFrom-def">owl:allValuesFrom</a></code>
|
|
constraint is analogous to the universal (for-all) quantifier of Predicate
|
|
logic - for each instance of the class or datatype that is being defined, every
|
|
range value for P must fulfill the constraint. Also notice that the
|
|
correspondence of <code><a
|
|
href="#allValuesFrom-def">owl:allValuesFrom</a></code> with the universal
|
|
quantifier means that an <code><a
|
|
href="#allValuesFrom-def">owl:allValuesFrom</a></code> constraint for a
|
|
property P is trivially satisfied for an individual that has no value for
|
|
property P at all. To see why this is so, observe that the <code><a
|
|
href="#allValuesFrom-def">owl:allValuesFrom</a></code> constraint demands that
|
|
all values of P belong to class P, and if no such values exist, the constraint
|
|
is trivially true.</p>
|
|
|
|
<h6><a name="someValuesFrom-def" id="someValuesFrom-def">owl:someValuesFrom</a></h6>
|
|
|
|
<p>The value constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_someValuesFrom_semantics">owl:someValuesFrom</a></span>
|
|
is a built-in OWL property that links a restriction class to a <a
|
|
href="#ClassDescription">class description</a> or a <a
|
|
href="#DataRange">data range</a>. A restriction containing
|
|
an <code>owl:someValuesFrom</code> constraint
|
|
describes a class of all individuals for which at least one value of the
|
|
property concerned is an instance of the class description or a data value in
|
|
the data range. In other words, it defines a class of individuals x for
|
|
which there is at least one y (either an instance of the class description or
|
|
value of the data range) such that the pair (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 description or data range.
|
|
</p>
|
|
|
|
<p>The following example defines a class of individuals which have at least one
|
|
parent who is a physician:</p>
|
|
<pre>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasParent" />
|
|
<owl:someValuesFrom rdf:resource="#Physician" />
|
|
</owl:Restriction>
|
|
</pre>
|
|
|
|
<p>The <code><a href="#someValuesFrom-def">owl:someValuesFrom</a></code>
|
|
constraint is analogous to the existential quantifier of Predicate logic - for
|
|
each instance of the class that is being defined, there exists at
|
|
least one value for P that fulfills the constraint.</p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL Lite the range value of <code>owl:someValuesFrom</code> must be
|
|
a class identifier.</p>
|
|
|
|
|
|
<h6><a name="hasValue-def" id="hasValue-def">owl:hasValue</a></h6>
|
|
|
|
<p>The value constraint <span class="def"><a href="http://www.w3.org/TR/owl-semantics/direct#owl_hasValue_semantics">owl:hasValue</a></span>
|
|
is a built-in OWL property that links a restriction class
|
|
to a value V, which can be either an <a href="#Individual">
|
|
individual</a> or a <a
|
|
href="#Datatype">data value</a>.
|
|
A restriction containing a <code>owl:hasValue</code> constraint
|
|
describes a class of all individuals for
|
|
which the property concerned has at least one value <em>semantically</em>
|
|
equal to V (it may have other values as well).</p>
|
|
|
|
<p class="note">
|
|
NOTE: for datatypes "semantically equal" means that
|
|
the lexical representation of the literals maps to the same
|
|
value. For individuals it means that they
|
|
either have the same URI reference or are defined as being the same
|
|
individual (see <a href="#sameIndividualAs-def">owl:sameIndividualAs</a>).</p>
|
|
|
|
<p class="note">
|
|
NOTE: the value constraint <code>owl:hasValue</code>
|
|
is not included in OWL Lite.</p>
|
|
|
|
<p>The following example describes the class of individuals who have the
|
|
individual referred to as <code>Clinton</code> as their parent:</p>
|
|
|
|
<pre>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasParent" />
|
|
<owl:hasValue rdf:resource="#Clinton" />
|
|
</owl:Restriction>
|
|
</pre>
|
|
|
|
<h5><a name="CardinalityRestriction">3.1.2.2 Cardinality constraints</a></h5>
|
|
|
|
<p>In OWL, like in RDF, it is assumed that any instance of a class may have an
|
|
arbitrary number (zero or more) of values for a particular property. To make a
|
|
property required (at least one), to allow only a specific number of values for
|
|
that property, or to insist that a property must not occur, cardinality
|
|
constraints can be used. OWL provides three constructs for restricting the
|
|
cardinality of properties locally within a class context.</p>
|
|
|
|
<p class="note">
|
|
NOTE: OWL Lite includes the use of all three types of cardinality constraints,
|
|
but only when used with the range values "0" or "1".</p>
|
|
|
|
<h6><a name="maxCardinality-def" id="maxCardinality-def">owl:maxCardinality</a></h6>
|
|
|
|
<p>The cardinality constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_maxCardinality_semantics">
|
|
owl:maxCardinality</a></span>
|
|
is a built-in OWL property that
|
|
links a restriction class to a data value belonging to the range of
|
|
the XML Schema datatype <code>nonNegativeInteger</code>. A restriction
|
|
containing an <code>owl:maxCardinality</code> constraint describes a class of
|
|
all individuals that have <em>at most</em> N distinct range values
|
|
(individuals or data
|
|
values) for the property concerned, where N is the range value of the
|
|
cardinality constraint. Syntactically, the cardinality constraint is represented
|
|
as an RDF property element with the corresponding <code>rdf:datatype</code>
|
|
attribute.</p>
|
|
|
|
<p>The following example describes a class of individuals that have at most
|
|
two parents:</p>
|
|
|
|
<pre>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasParent" />
|
|
<owl:maxCardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:maxCardinality>
|
|
</owl:Restriction>
|
|
</pre>
|
|
|
|
<p>RDF datatyping is discussed in more detail in
|
|
Section <a href="#Datatype">"6. Datatypes"</a>.</p>
|
|
|
|
|
|
<h6><a name="minCardinality-def" id="minCardinality-def">owl:minCardinality</a></h6>
|
|
|
|
<p>The cardinality constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_minCardinality_semantics">
|
|
owl:minCardinality</a></span>
|
|
is a built-in OWL property that
|
|
links a restriction class to a data value belonging to the range of
|
|
the XML Schema datatype <code>nonNegativeInteger</code>. A restriction
|
|
containing an <code>owl:minCardinality</code> constraint describes a class of
|
|
all individuals that have <em>at least</em> N distinct range values
|
|
(individuals or data
|
|
values) for the property concerned, where N is the range value of the
|
|
cardinality constraint. Syntactically, the cardinality constraint is represented
|
|
as an RDF property element with the corresponding <code>rdf:datatype</code>
|
|
attribute.</p>
|
|
|
|
<p>The following example describes a class of individuals that have at least
|
|
two parents:</p>
|
|
|
|
<pre>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasParent" />
|
|
<owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:minCardinality>
|
|
</owl:Restriction>
|
|
</pre>
|
|
|
|
<p>
|
|
Note that an owl:minCardinality of one or more means that a value for the
|
|
property is required of any instance of the class.</p>
|
|
|
|
|
|
<h6><a
|
|
name="cardinality-def" id="cardinality-def">owl:cardinality</a></h6>
|
|
|
|
|
|
<p>The cardinality constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_cardinality_semantics">
|
|
owl:cardinality</a></span>
|
|
is a built-in OWL property that
|
|
links a restriction class to a data value belonging to the range of
|
|
the XML Schema datatype <code>nonNegativeInteger</code>. A restriction
|
|
containing an <code>owl:cardinality</code> constraint describes a class of
|
|
all individuals that have <em> exactly</em> N distinct range values
|
|
(individuals or data
|
|
values) for the property concerned, where N is the range value of the
|
|
cardinality constraint. Syntactically, the cardinality constraint is represented
|
|
as an RDF property element with the corresponding <code>rdf:datatype</code>
|
|
attribute.</p>
|
|
|
|
<p>This construct is in fact redundant as it
|
|
can always be replaced by a pair of matching
|
|
<a href="#minCardinality-def"><code>owl:minCardinality</code></a>
|
|
and
|
|
<a href="#maxCardinality-def"><code>owl:maxCardinality</code></a>
|
|
constraints with the same value. It is included as a convenient shorthand for
|
|
the user.</p>
|
|
|
|
<p>The following example describes a class of individuals that have exactly
|
|
two parents:</p>
|
|
|
|
<pre>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasParent" />
|
|
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:cardinality>
|
|
</owl:Restriction>
|
|
</pre>
|
|
|
|
|
|
<h4><a name="Boolean" id="Boolean">3.1.3 Intersection, union and complement</a></h4>
|
|
|
|
<p>The three forms of class descriptions in this section represent the more
|
|
advanced class constructors that are used in Description Logic. They can be
|
|
viewed as representing the AND, OR and NOT operators on classes.
|
|
The three operators get the standard set-operator
|
|
names: intersection, union and complement. These language constructs also share the
|
|
characteristic that they contain nested class descriptions, either
|
|
one (complement) or more (union, intersection).</p>
|
|
|
|
<h5><a name="intersectionOf-def"
|
|
id="intersectionOf-def">owl:intersectionOf</a></h5>
|
|
|
|
<p>The <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_intersectionOf_semantics">owl:intersectionOf</a></span>
|
|
property links a class to a list of
|
|
<a href="#ClassDescription">class descriptions.</a>
|
|
An <code>owl:intersectionOf</code> statement
|
|
describes a class for which the class extension contains
|
|
precisely those individuals
|
|
that are members of the class extension of
|
|
all class descriptions in the range list. </p>
|
|
|
|
<p>An example:</p>
|
|
|
|
<pre>
|
|
<owl:Class>
|
|
<owl:intersectionOf rdf:parseType="Collection">
|
|
<owl:Class>
|
|
<owl:oneOf rdf:parseType="Collection">
|
|
<owl:Thing rdf:about="#Tosca" />
|
|
<owl:Thing rdf:about="#Salome" />
|
|
</owl:oneOf>
|
|
</owl:Class>
|
|
<owl:Class>
|
|
<owl:oneOf rdf:parseType="Collection">
|
|
<owl:Thing rdf:about="#Turandot" />
|
|
<owl:Thing rdf:about="#Tosca" />
|
|
</owl:oneOf>
|
|
</owl:Class>
|
|
</owl:intersectionOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>In this example the range of the intersection constraint is a list of two
|
|
class descriptions, namely two enumerations, both describing a class
|
|
with two individuals. The resulting intersection is
|
|
a class with one individual, namely
|
|
<code>Tosca</code>. as this is the only individual that is
|
|
common to both enumerations.</p>
|
|
|
|
<p class="note">
|
|
NOTE: This assumes that the three individuals are all
|
|
different. In fact, this is not by definition true in OWL.
|
|
Different URI references may refer to the
|
|
same individuals, because OWL does not have a "unique names" assumption. In
|
|
the
|
|
section on individuals one can find OWL language constructs for making
|
|
constraints about equality and difference of individuals.</p>
|
|
|
|
<p class="note">
|
|
NOTE: OWL Lite is restricted in its use of <code>owl:intersectionOf</code>.
|
|
This is discussed later in this document, see Section <a
|
|
href="#DescriptionAxiom">3.2.3</a>
|
|
</p>
|
|
|
|
<p><code>owl:intersectionOf</code>
|
|
can be viewed as being analogous to logical
|
|
conjunction.</p>
|
|
|
|
<h5><a name="unionOf-def" id="unionOf-def">owl:unionOf</a></h5>
|
|
|
|
|
|
<p>The <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_unionOf_semantics">owl:unionOf</a></span>
|
|
property links a class to a list of
|
|
<a href="#ClassDescription">class descriptions.</a>
|
|
An <code>owl:unionOf</code> statement
|
|
describes an anonymous class for which the class extension contains
|
|
those individuals
|
|
that occur in at least one of the class extensions of the
|
|
class descriptions in the range list. </p>
|
|
|
|
<p>An example:</p>
|
|
|
|
<pre>
|
|
<owl:Class>
|
|
<owl:unionOf rdf:parseType="Collection">
|
|
<owl:Class>
|
|
<owl:oneOf rdf:parseType="Collection">
|
|
<owl:Thing rdf:about="#Tosca" />
|
|
<owl:Thing rdf:about="#Salome" />
|
|
</owl:oneOf>
|
|
</owl:Class>
|
|
<owl:Class>
|
|
<owl:oneOf rdf:parseType="Collection">
|
|
<owl:Thing rdf:about="#Turandot" />
|
|
<owl:Thing rdf:about="#Tosca" />
|
|
</owl:oneOf>
|
|
</owl:Class>
|
|
</owl:unionOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This class description describes a class for which the class extension
|
|
contains three individuals, namely <code>Tosca</code>, <code>Salome</code>, and <code>Turandot</code>
|
|
(assuming they are all different).</p>
|
|
|
|
<p class="note">
|
|
NOTE: <code>owl:unionOf</code> is not part of OWL Lite.
|
|
</p>
|
|
|
|
<p><code>owl:unionOf</code> is analogous to logical disjunction. </p>
|
|
|
|
<h5><a name="complementOf-def" id="complementOf-def">owl:complementOf</a></h5>
|
|
|
|
<p>An
|
|
<span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_complementOf_semantics">owl:complementOf</a></span>
|
|
property links a class to precisely one <a href="#ClassDescription">class
|
|
description</a>.
|
|
The <code>owl:complementOf</code> statement defines a class for which the class
|
|
extension contains exactly those individuals
|
|
that do <em>not</em> belong to the class extension of the
|
|
range class. <code>owl:complementOf</code> is
|
|
analogous to logical negation, but restricted to individuals only. </p>
|
|
|
|
<p>As an example of the use of complement,
|
|
the expression "not meat" could be written
|
|
as:</p>
|
|
|
|
<pre>
|
|
<owl:Class>
|
|
<owl:complementOf>
|
|
<owl:Class rdf:about="#Meat"/>
|
|
</owl:complementOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This extension of this class description contains all individual that do not
|
|
belong to the class <code>Meat</code>.</p>
|
|
|
|
<p class="note">
|
|
NOTE: <code>owl:complementOf</code> is not part of OWL Lite.
|
|
</p>
|
|
|
|
<h3><a name="ClassAxioms" id="ClassAxioms">3.2 Class axioms</a></h3>
|
|
|
|
<p>Class descriptions form the building blocks for defining classes
|
|
through class axioms. The simplest form of a class axiom is a class description
|
|
of type 1, It just states
|
|
the existence of a class, using
|
|
<a name="Class-def" id="Class-def"><code>owl:Class</code></a> with a class identifier.</p>
|
|
|
|
<p>For example, the following
|
|
class axiom declares the URI reference <code>Human</code> to be an OWL
|
|
class:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="Human"/>
|
|
</pre>
|
|
|
|
<p>This is correct OWL, but does not tell us very much about the class
|
|
<code>Human</code>. Class axioms typically contain additional components that
|
|
state necessary and/or sufficient characteristics of a class. OWL contains
|
|
three language constructs for combining class descriptions into class
|
|
axioms:</p>
|
|
|
|
|
|
<ul>
|
|
<li><a href="#subClassOf-def"><code>rdfs:subClassOf</code></a> allows one
|
|
to say that the class extension of a
|
|
class description is a subset of the class extension of another class
|
|
description.</li>
|
|
<li><a href="#equivalentClass-def"><code>owl:equivalentClass</code></a> allows one
|
|
to say that a class description has exactly the
|
|
same class extension as another class description.</li>
|
|
<li><a href="#disjointWith-def"><code>owl:disjointWith</code></a> allows one
|
|
to say that the class extension of a class description has no members in
|
|
common with the class extension of another class description.</li>
|
|
</ul>
|
|
|
|
<p>Syntactically, these three language constructs
|
|
are properties that have a class description as
|
|
both domain and range. We discuss these properties in more
|
|
detail in the following subsections.</p>
|
|
|
|
<p>In addition, OWL allows class axioms in which a class description of the
|
|
enumeration or the set-operator type is given a name. These class axioms are
|
|
semantically equivalent to class axioms with a <code>owl:equivalentClass</code>
|
|
statement, so these will be discussed right after that subsection (see Section
|
|
<a href="#DescriptionAxiom">3.2.3 Axioms for complete classes without
|
|
using owl:equivalentClass</a>).</p>
|
|
|
|
|
|
<h4><a name="subClassOf-def">3.2.1 rdfs:subClassOf</a></h4>
|
|
|
|
<p class="note">
|
|
AXIOM SCHEMA:
|
|
<em>class description</em> <code>rfs:subClassOf</code> <em>class
|
|
description</em> </p>
|
|
|
|
<p>The <code>rfs:subClassOf</code> construct is
|
|
defined as part of RDF Schema
|
|
[<cite><a href="#ref-rdf-schema">RDF Schema</a></cite>]. Its meaning in OWL
|
|
is exactly the same: if the class description C1 is defined as a subclass of
|
|
class description C2, than the set of individuals in the class extension of C1
|
|
should be a subset of the set of individuals in the class extension of C2.
|
|
A class description is by definition a subclass of itself (as the subset may be
|
|
the complete set).</p>
|
|
|
|
<p>An example:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="Opera">
|
|
<rdfs:subClassOf rdf:resource="#MusicalWork" />
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This class axiom declares a subclass relation between two OWL classes that
|
|
are described through their names (<code>Opera</code> and
|
|
<code>MusicalWork</code>).
|
|
Subclass relations provide necessary conditions for belonging to a class. In
|
|
this case, to be an opera the individual also needs to be a musical work.</p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL Lite the domain value of an
|
|
<code>rdfs:subClassOf</code> statement must be a class identifier. The range
|
|
value must be either a class identifier or a property restriction.</p>
|
|
|
|
<p>Class axioms can also use the other types of class descriptions, such as
|
|
property restrictions, enumerations, intersections, unions and complements.
|
|
For any class there may be any number of subClassOf axioms.
|
|
For example, we could add the following axiom about the class <code>Opera</code>:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:about="#Opera">
|
|
<rdfs:subClassOf>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasLibrettist" />
|
|
<owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
|
|
</owl:Restriction>
|
|
</rdfs:subClassOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This class axiom contains
|
|
a property restriction. The example states that <code>Opera</code>
|
|
is a subclass of an anonymous OWL class (remember: <a href="#Restriction-def"><code>owl:Restriction</code></a>
|
|
is a subclass of <code>owl:Class</code>) that has as its class extension
|
|
the set of all individuals
|
|
for which the property <code>hasLibrettist</code> has at least one
|
|
value. Thus, operas should have at least one librettist.</p>
|
|
|
|
|
|
<p>Class axioms can get more complex when class descriptions are nested.
|
|
For example, property restrictions with an
|
|
<a href="#allValuesFrom-def"><code>owl:allValuesFrom</code></a>
|
|
or
|
|
<a href="#someValuesFrom-def"><code>owl:someValuesFrom</code></a>
|
|
statement may point to any class description.
|
|
Consider the following example: </p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="TraditionalItalianOpera">
|
|
<rdfs:subClassOf rdf:resource="#Opera"/>
|
|
<rdfs:subClassOf>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasOperaType"/>
|
|
<owl:someValuesFrom>
|
|
<owl:Class>
|
|
<owl:oneOf rdf:parseType="Collection">
|
|
<owl:Thing rdf:about="#OperaSeria"/>
|
|
<owl:Thing rdf:about="#OperaBuffa"/>
|
|
</owl:oneOf>
|
|
</owl:Class>
|
|
</owl:someValuesFrom>
|
|
</owl:Restriction>
|
|
</rdfs:subClassOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This example shows the use of the <code>owl:oneOf</code> construct.
|
|
The class axiom defines traditional Italian opera as a subclass of
|
|
a class of operas that have as opera type either <em>opera seria</em> or
|
|
<em>opera buffa</em> (without an additional cardinality constraint, it could actually
|
|
have both values).</p>
|
|
|
|
<p>More examples can be found in the Guide document and in the
|
|
corresponding <a href="http://www.w3.org/TR/owl-guide/wine.owl">wine.owl</a>
|
|
file.
|
|
Subclass axioms provide us with partial definitions: they represent necessary
|
|
but not sufficient conditions for establishing class membership of an
|
|
individual. In the next subsection we will see that for defining
|
|
necessary <em>and</em> sufficient conditions OWL provides the
|
|
<a href="#equivalentClass-def"><code>owl:equivalentClass</code></a>
|
|
construct. As a stepping stone to such axioms,
|
|
consider the following example:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="Operetta">
|
|
<rdfs:subClassOf rdf:resource="#MusicalWork"/>
|
|
<rdfs:subClassOf>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasLibrettist" />
|
|
<owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
|
|
</owl:Restriction>
|
|
</rdfs:subClassOf>
|
|
<rdfs:subClassOf>
|
|
<owl:Class>
|
|
<owl:complementOf rdf:resource="#Opera"/>
|
|
</owl:Class>
|
|
</rdfs:subClassOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This class axiom states that an operetta is a musical work, that has a
|
|
librettist and is not an opera. The use of the subclass relation leaves open
|
|
the possibility that there are other musical works that have a librettist and
|
|
are
|
|
not operas. If we had wanted to say that operetta's are <em>exactly</em>
|
|
those musical works that have a librettist but are not operas, we would need to use
|
|
the
|
|
<a href="#equivalentClass-def"><code>owl:equivalentClass</code></a>
|
|
construct.</p>
|
|
|
|
|
|
<h4><a name="equivalentClass-def">3.2.2 owl:equivalentClass</a></h4>
|
|
|
|
<p class="note">
|
|
AXIOM SCHEMA:
|
|
<em>class description</em> <code>owl:equivalentClass</code> <em>class
|
|
description</em> </p>
|
|
|
|
<p>A class axiom may contain (multiple)
|
|
<span class="def"><a href="http://www.w3.org/TR/owl-semantics/direct#owl_sameClassAs_semantics">owl:equivalentClass</a></span>
|
|
statements. The construct <code>owl:equivalentClass</code> is a built-in
|
|
property that links a class description
|
|
to another class description.
|
|
The meaning of such a class axiom is that the two class descriptionss involved
|
|
have the same class extension
|
|
(i.e., both class extensions contain exactly the same set of individuals).</p>
|
|
|
|
<p>In its simplest form, an equivalentClass
|
|
axiom states the equivalence (in terms of their class extension)
|
|
of two named
|
|
classes. An example:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:about="#US_President">
|
|
<equivalentClass rdf:resource="#PrincipalResidentOfWhiteHouse"/>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p class="note">NOTE:
|
|
The use of <code>owl:equivalentClass</code> does not imply class
|
|
equality. Class equality means that the classes have the same intensional
|
|
meaning (denote the same concept). In the example above, the concept of
|
|
"President of the US" is related to, but not equal to the concept of the
|
|
principal resident of a certain estate.
|
|
Real class equality can only be expressed with the <code><a
|
|
href="#sameIndividualAs-def">owl:sameAs</a></code> construct (or its synonym
|
|
<code>owl:sameIndividualAs</code>, see the section on individuals).
|
|
As this requires treating classes as
|
|
individuals, class equality can only be expressed in OWL Full. </p>
|
|
|
|
|
|
<p>Axioms with <code>owl:equivalentClass</code> can also be used to define
|
|
an enumerated class by linking a type 1 class description (a class identifier)
|
|
to a type 2 class description (an enumeration).
|
|
An example:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="DaPonteOperaOfMozart">
|
|
<owl:equivalentClass>
|
|
<owl:Class>
|
|
<owl:oneOf rdf:parseType="Collection">
|
|
<Opera rdf:about="#Nozze_di_Figaro"/>
|
|
<Opera rdf:about="#Don_Giovanni"/>
|
|
<Opera rdf:about="#Cosi_fan_tutte"/>
|
|
</owl:oneOf>
|
|
</owl:Class>
|
|
</owl:equivalentClass>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This class axiom defines the class of operas
|
|
that together represent the "Da Ponte operas of Mozart" (a
|
|
popular subject in musicology). By using the equivalentClass construct
|
|
we can state
|
|
necessary and sufficient conditions for class membership, in this case
|
|
consisting of an enumeration of three individuals, no less, no more.</p>
|
|
|
|
<p class="note">
|
|
NOTE: OWL DL does not put any constraints on the types of class descriptions
|
|
that can be used as domain and range values of an
|
|
<code>owl:equivalentClass</code> statement. In OWL Lite only class identifiers
|
|
and property restrictions are allowed as domain and range values.
|
|
</p>
|
|
|
|
<p class="note">
|
|
NOTE: Although in principle different types of class descriptions are allowed
|
|
as the lefthand-side (domain value) of an equivalentClass statement,
|
|
in practice it usually is some class
|
|
identifier. The is also true for the examples in this section.</p>
|
|
|
|
<p>It is possible to have multiple equivalentClass axioms about the same
|
|
class.
|
|
However, this requires care. Both axioms must lead to the same
|
|
outcome, i.e. exactly the same class extension. For example, an alternate
|
|
equivalentClass axiom for Mozart's "Da Ponte operas" could be the following
|
|
one:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:about="#DaPonteOperaOfMozart">
|
|
<owl:equivalentClass>
|
|
<owl:Class>
|
|
<owl:intersectionOf rdf:parseType="Collection">
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasComposer"/>
|
|
<owl:hasValue rdf:resource="#Wolfgang_Amadeus_Mozart"/>
|
|
</owl:Restriction>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="#hasLibrettist"/>
|
|
<owl:hasValue rdf:resource="#Lorenzo_Da_Ponte"/>
|
|
</owl:Restriction>
|
|
</owl:intersectionOf>
|
|
</owl:Class>
|
|
</owl:equivalentClass>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This states that the class extension of the Da Ponte operas of Mozart
|
|
corresponds exactly to those operas which are composed
|
|
by Mozart and for which the libretto is written by Da Ponte (note: intersection
|
|
= "and"). This denotes indeed the same set of individuals as the previous
|
|
axiom.</p>
|
|
|
|
<p class="note">NOTE: If we wanted to "upgrade" an axiom of the form "A
|
|
subClassOf B" to "A equivalentClass B" (meaning that the class extension of A
|
|
is not just any subset, but in fact the same set as the class extension of B),
|
|
we could add a second subClassOf axiom of the form (B subClassOf A), which by
|
|
definition makes the two class extensions equivalent
|
|
(and thus has the same meaning
|
|
as "A equivalentClass B"). Such subClassOf "cycles" are explicitly allowed. As
|
|
OWL is usable in a distributed environment, this can be a useful
|
|
feature.</p>
|
|
|
|
|
|
<h4><a name="DescriptionAxiom">3.2.3 Axioms for complete classes without
|
|
using owl:equivalentClass</a></h4>
|
|
|
|
<p class="note">
|
|
AXIOM SCHEMA:
|
|
named <em>class description</em> of type 2 (with <code>owl:oneOf</code>) or
|
|
type 4-6 (with <code>owl:intersectionOf</code>, <code>owl:unionOf</code>
|
|
or <code>owl:complementOf</code>
|
|
</p>
|
|
|
|
<p>OWL allows users to define class axioms by giving a name to class
|
|
descriptions of the
|
|
enumeration or set-operator type. Such a class axiom defines necessary and
|
|
sufficient conditions for establishing class membership.
|
|
An example: </p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="DaPonteOperaOfMozart">
|
|
<owl:oneOf rdf:parseType="Collection">
|
|
<owl:Thing rdf:about="#Nozze_di_Figaro"/>
|
|
<owl:Thing rdf:about="#Don_Giovanni"/>
|
|
<owl:Thing rdf:about="#Cosi_fan_tutte"/>
|
|
</owl:oneOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This class axiom should be interpreted as follows: the class extension of
|
|
the class <code>DaPonteOperaOfMozart</code> is
|
|
exactly defined by the enumeration.</p>
|
|
|
|
<p>This class axiom is semantically equivalent to the
|
|
first example in the previous section, which included an additional
|
|
<code>owl:equivalentClass</code> statement. Axioms of this type can also be
|
|
constructed with <code>owl:intersectionOf</code>,
|
|
<code>owl:unionOf</code> and <code>owl:complenentOf</code>.
|
|
An example with a union could be:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:ID="LivingBeing">
|
|
<owl:unionOf rdf:parseType="Collection">
|
|
<owl:Class rdf:about="#Plant"/>
|
|
<owl:Class rdf:about="#Animal"/>
|
|
</owl:unionOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>This class axiom states that the class extension of
|
|
<code>LivingBeing</code> exactly corresponds
|
|
to the union of the class extensions of <code>Plant</code>
|
|
and <code>Animal</code>.</p>
|
|
|
|
<p class="note">
|
|
NOTE: OWL Lite only includes class axioms of this type which are constructed
|
|
with the <code>owl:intersectionOf</code> property. The range values of
|
|
intersectionOf should be class identifiers and/or property restrictions.
|
|
Thus, "complete class" axioms
|
|
using enumeration, complement and
|
|
union are not allowed in OWL Lite. </p>
|
|
|
|
|
|
<h4><a name="disjointWith-def">3.2.4 owl:disjointWith</a></h4>
|
|
|
|
<p class="note">
|
|
AXIOM SCHEMA:
|
|
<em>class description</em> <code>owl:disjointWith</code> <em>class
|
|
description</em> </p>
|
|
|
|
<p>A class axiom may also contain (multiple)
|
|
<span class="def"><a href="http://www.w3.org/TR/owl-semantics/direct#owl_disjointWith_semantics">owl:disjointWith</a></span>
|
|
statements.
|
|
The construct <code>owl:disjointWith</code> is a
|
|
built-in property with a class
|
|
description as domain and range values.
|
|
Each <code>owl:disjointWith</code> statement asserts that
|
|
the class extensions of the two class descriptions
|
|
involved have no individuals in common. Like axioms with
|
|
<code>rdfs:subClassOf</code>, declaring two classes to be disjoint is a partial
|
|
definition: it imposes a necessary but not sufficient condition on the
|
|
class.</p>
|
|
|
|
<p> This is a popular example of class disjointness:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:about="Man">
|
|
<owl:disjointWith rdf:resource="#Woman"/>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>Whether this is actually true is a matter for biologists to
|
|
decide. The following example shows a common use of class disjointness in
|
|
subclass hierarchies:</p>
|
|
|
|
<pre>
|
|
<owl:Class rdf:about="MusicDrama">
|
|
<owl:equivalentClass>
|
|
<owl:Class>
|
|
<owl:unionOf rdf:parseType="Collection">
|
|
<owl:Class rdf:about="#Opera"/>
|
|
<owl:Class rdf:about="#Operetta"/>
|
|
<owl:Class rdf:about="#Musical"/>
|
|
</owl:unionOf>
|
|
</owl:Class>
|
|
</owl:equivalentClass>
|
|
</owl:Class>
|
|
|
|
<owl:Class rdf:about="#Opera">
|
|
<rdfs:subClassOf rdf:resource="#MusicDrama"/>
|
|
</owl:Class>
|
|
|
|
<owl:Class rdf:about="#Operetta">
|
|
<rdfs:subClassOf rdf:resource="#MusicDrama"/>
|
|
<owl:disjointWith rdf:resource="#Opera"/>
|
|
</owl:Class>
|
|
|
|
<owl:Class rdf:about="#Musical">
|
|
<rdfs:subClassOf rdf:resource="#MusicDrama"/>
|
|
<owl:disjointWith rdf:resource="#Opera"/>
|
|
<owl:disjointWith rdf:resource="#Operetta"/>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>Here, <code>owl:disjointWith</code>
|
|
statements are used together with
|
|
<a href="#unionOf-def"><code>owl:unionOf</code></a>
|
|
in order to define a set of mutually disjoint and complete subclasses of a
|
|
superclass. In natural language: every <code>MusicDrama</code> is either an
|
|
opera, an <code>Operetta</code>, or a <code>Musical</code> (the subclass
|
|
partitioning is complete) and individuals belonging to one subclass,
|
|
<em>e.g.</em>,
|
|
<code>Opera</code>, cannot belong to another subclass, <em>e.g.</em>,
|
|
<code>Musical</code> (disjoint or non-overlapping subclasses). This is a common
|
|
modelling notion used in many data-modelling notations. </p>
|
|
|
|
<p class="note">
|
|
NOTE: OWL Lite does not allow the use of <code>owl:disjointWith</code>.
|
|
</p>
|
|
|
|
<!--
|
|
SECTION 4: Properties
|
|
-->
|
|
|
|
<h2><a name="Property" id="Property">4. Properties</a></h2>
|
|
|
|
<p>OWL distinguishes between two types of properties:</p>
|
|
<ul>
|
|
<li><em>Object properties</em> have a value range of
|
|
class individuals, and thus link individuals to individuals.</li>
|
|
<li><em>Datatype properties</em> have a value range of data values, and thus
|
|
link individuals to data values.</li>
|
|
</ul>
|
|
|
|
<p>An object property is defined with the help of an
|
|
<a name="ObjectProperty-def" id="ObjectProperty-def"></a> <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_ObjectProperty_semantics">owl:ObjectProperty</a></span>
|
|
class. A datatype property is defined through an <a
|
|
name="DatatypeProperty-def" id="DatatypeProperty-def"></a> <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_DatatypeProperty_semantics">owl:DatatypeProperty</a></span>
|
|
class. Both <code>owl:ObjectProperty</code> and
|
|
<code>owl:DatatypeProperty</code> are subclasses of the RDF class
|
|
<code>rdf:Property</code> (see <a href="#appB">Appendix B</a>).
|
|
</p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL Full, object properties and datatype properties are
|
|
not disjoint. Because data values can be treated as individuals, datatype
|
|
properties are effectively subclasses of object properties.
|
|
In OWL Full <code>owl:ObjectProperty</code> is equivalent to
|
|
<code>rdf:Property</code> In practice, this
|
|
mainly has consequences for the use of
|
|
<a href="#InverseFunctionalProperty-def"><code>owl:InverseFunctionalProperty</code></a>.
|
|
See also the OWL Full characterization in Section <a
|
|
href="#OWLFull">8.1</a>.</p>
|
|
|
|
<p>
|
|
A property axiom defines characteristics of a property.
|
|
In its simplest form, a property axiom just defines the existence of
|
|
a property. For example:</p>
|
|
|
|
<pre>
|
|
<owl:ObjectProperty rdf:ID="hasParent"/>
|
|
</pre>
|
|
|
|
<p>This defines a property with the restriction that the range values should be
|
|
individuals.</p>
|
|
|
|
<p>Often, property axioms define additional characteristics of properties. OWL
|
|
supports the following constructs for property axioms:</p>
|
|
|
|
<ul>
|
|
<li>RDF Schema constructs: <code>rdfs:subPropertyOf</code>,
|
|
<code>rdfs:domain</code> and <code>rdfs:range</code></li>
|
|
<li>relations to other properties: <code>owl:equivalentProperty</code> and
|
|
<code>owl:inverseOf</code></li>
|
|
<li>global cardinality constraints: <code>owl:FunctionalProperty</code> and
|
|
<code>owl:InverseFunctionalProperty</code></li>
|
|
<li>logical property characteristics: <code>owl:SymmetricProperty</code> and
|
|
<code>owl:TransitiveProperty</code></li>
|
|
</ul>
|
|
|
|
|
|
<p>In the next subsections, the various types of property axioms are
|
|
discussed in more detail.</p>
|
|
|
|
<p class="note">NOTE: In this section we use the term "property extension" in
|
|
a similar fashion to "class extension". The property extension is the set of
|
|
instances that is associated with the property. Instances of properties are not
|
|
single elements, but subject-object pairs of property statements. In relational
|
|
database
|
|
terms, property instances would be called "tuples" of a binary relation (the
|
|
property). </p>
|
|
|
|
|
|
<h3><a name ="RDFSProperty">4.1 RDF Schema constructs</a></h3>
|
|
|
|
<p>The constructs in this section are discussed in detail in the RDF Schema
|
|
document [<cite><a href="#ref-rdf-schema">RDF Schema</a></cite>]. The
|
|
description in this section provides a synopsis of these constructs and
|
|
provides some OWL-specific aspects and examples. </p>
|
|
|
|
|
|
<h4><a name="subPropertyOf-def"
|
|
id="subPropertyOf-def">rdfs:subPropertyOf</a></h4>
|
|
|
|
<p>A <code>rdfs:subPropertyOf</code> axiom defines that the property
|
|
is a subproperty of some other property.
|
|
Formally this means that if P1 is a subproperty of P2, then the property
|
|
extension of P1 (a set of pairs) should be a subset of the property extension
|
|
of P2 (also a set of pairs).</p>
|
|
|
|
<p>An example:</p>
|
|
|
|
<pre>
|
|
<owl:ObjectProperty rdf:ID="hasMother">
|
|
<rdfs:subPropertyOf rdf:resource="#hasParent"/>
|
|
</owl:ObjectProperty>
|
|
</pre>
|
|
|
|
<p>This states that all instances (pairs) contained in the property extension
|
|
of the property "hasMother" are also members of the property extension of the
|
|
property "hasParent".</p>
|
|
|
|
<p>Subproperty axioms can be applied to both datatype properties and object
|
|
properties.</p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL DL the domain and range value of a subproperty axiom
|
|
must be either both datatype properties or both object properties.</p>
|
|
|
|
<h4><a name="domain-def" id="domain-def">rdfs:domain</a></h4>
|
|
|
|
<p>For a property one can define (multiple)
|
|
<code>rdfs:domain</code> axiom.
|
|
Syntactically, <code>rdfs:domain</code> is a built-in
|
|
property that links a property
|
|
(some instance of the class <code>rdf:Property</code>)
|
|
to a <a href="#ClassDescription">class
|
|
description</a>.
|
|
An <code>rdfs:domain</code> axiom asserts that the domain values of this
|
|
property must belong to the class extension of
|
|
the class description.
|
|
</p>
|
|
|
|
<p>Multiple <code>rdfs:domain</code>
|
|
axioms are allowed and should be interpreted as a conjunction: these
|
|
restrict the domain of the property to those individuals that belong to the
|
|
<em>intersection</em> of the class descriptions. If one would want to say
|
|
that multiple classes can act as domain, one should use a class description
|
|
of the <a href="#unionOf-def"><code>owl:unionOf</code></a> form.
|
|
For example, if we want to say that the domain of the property
|
|
<code>hasBankAccount</code> can be either a <code>Person</code> or a <code>Corporation</code>, we would need to
|
|
say something like this:</p>
|
|
|
|
<pre>
|
|
<owl:ObjectProperty rdf:ID="hasBankAccount">
|
|
<rdfs:domain>
|
|
<owl:Class>
|
|
<owl:unionOf rdf:parseType="Collection">
|
|
<owl:Class rdf:about="#Person"/>
|
|
<owl:Class rdf:about="#Corporation"/>
|
|
</owl:unionOf>
|
|
</owl:Class>
|
|
</rdfs:domain>
|
|
</owl:ObjectProperty>
|
|
</pre>
|
|
|
|
<p>The <code>rdfs:domain</code> restrictions are global, meaning that they
|
|
cannot be used for an individual for which the class is not explicitly included
|
|
in the domain restriction. Because of this feature, <code>rdfs:domain</code>
|
|
axioms should be used with care.</p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL Lite the range value of a <code>rdfs:domain</code> axiom
|
|
must be a class identifier.
|
|
</p>
|
|
|
|
<h4><a name="range-def" id="range-def">rdfs:range</a></h4>
|
|
|
|
<p>For a property one can define (multiple)
|
|
<code>rdfs:range</code> axioms.
|
|
Syntactically, <code>rdfs:range</code> is a built-in
|
|
property that links a property
|
|
(some instance of the class <code>rdf:Property</code>) to
|
|
to either a <a href="#ClassDescription">class
|
|
description</a> or a <a href="#DataRange">data range</a>.
|
|
An <code>rdfs:range</code> axiom asserts that the range values of this
|
|
property must belong to the class extension of
|
|
the class description or to data values in the specified data range.</p>
|
|
|
|
<p>Multiple range
|
|
restrictions are interpreted as stating that the range of the property is the
|
|
<em>intersection</em> of all ranges (i.e.,
|
|
the intersection of the class extension of the class descriptions
|
|
c.q. the intersection of the data ranges). Similar to
|
|
<a href="#domain-def"><code>rdfs:domain</code></a>,
|
|
multiple alternative
|
|
ranges can be specified by using a class description of the
|
|
<a href="#unionOf-def"><code>owl:unionOf</code></a> form (see the previous subsection). </p>
|
|
|
|
<p>Note that, unlike any of the <a href="#ValueRestriction">value
|
|
constraints</a> described in the section on class descriptions,
|
|
<code>rdfs:range</code> restrictions are
|
|
global. Value constraints such as <a href="#allValuesFrom-def"><code>owl:allValuesFrom</code></a>
|
|
are used in a class description and are only
|
|
enforced on the property when applied to that class. In contrast,
|
|
<code>rdfs:range</code> restrictions apply to the property irrespective of the
|
|
class to which it is applied.
|
|
Thus, <code>rdfs:range</code> should be
|
|
used with care.</p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL Lite the range value of a <code>rdfs:range</code> axiom must be a
|
|
class identifier.
|
|
</p>
|
|
|
|
<h3><a name="PropertyRelation">4.2 Relations to other properties</a></h3>
|
|
|
|
<h4><a name="equivalentProperty-def" id="equivalentProperty-def">owl:equivalentProperty</a></h4>
|
|
|
|
|
|
<p>The <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_samePropertyAs_semantics">owl:equivalentProperty</a></span>
|
|
construct can be used to state that two properties have the same property
|
|
extension. Syntactically, <code>owl:equivalentProperty</code> is a property
|
|
with as both domain and range an instance of <code>rdf:Property</code>.</p>
|
|
|
|
<p class="note">NOTE: Property equivalence is not the same as property
|
|
equality. Equivalent properties have the same "values" (i.e.,
|
|
the same property extension),
|
|
but may have different intensional meaning (i.e., denote different concepts).
|
|
Property equality should be expressed with the <a
|
|
href="#sameIndividualAs-def"><code>owl:sameAs</code></a> construct. As this
|
|
requires that properties are treated as individuals, such axioms are only
|
|
allowed in OWL Full.</p>
|
|
|
|
|
|
<h4><a name="inverseOf-def" id="inverseOf-def">owl:inverseOf</a></h4>
|
|
|
|
<p>Properties have a direction, from domain to range. In practice, people often
|
|
find it useful to define relations in both directions: persons own
|
|
cars, cars are owned by persons.
|
|
The <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_inverseOf_semantics">owl:inverseOf</a></span>
|
|
construct can be used to define such an inverse relation between
|
|
properties.</p>
|
|
|
|
<p>Syntactically, <code>owl:inverseOf</code> is a property that takes instances
|
|
of <code>owl:ObjectProperty</code> as domain and range values.
|
|
An axiom of the
|
|
form <code>P1 owl:inverseOf P2</code> asserts
|
|
that for every pair
|
|
(x,y) in the property extension of P1, there is a pair (y,x) in the class
|
|
extension of P2, and vice versa. Thus, <code>owl:inverseOf</code> is a
|
|
symmetric property.</p>
|
|
|
|
<p>An example:</p>
|
|
|
|
<pre>
|
|
<owl:ObjectProperty rdf:ID="hasChild">
|
|
<owl:inverseOf rdf:resource="#hasParent"/>
|
|
</owl:ObjectProperty>
|
|
</pre>
|
|
|
|
|
|
<h3><a name="PropertyCardinality">4.3 Global cardinality constraints on
|
|
properties</a></h3>
|
|
|
|
<h4><a name="FunctionalProperty-def"
|
|
id="FunctionalProperty-def">owl:FunctionalProperty</a></h4>
|
|
|
|
<p>A functional property is a property that can have only one
|
|
(unique) value y for each instance x, i.e. there
|
|
cannot be two distinct range values y1 and y2 such that the pairs (x,y1) and
|
|
(x,y2) are both instances of this property.
|
|
Both object properties and datatype properties can be declared as
|
|
"functional". >For this purpose,
|
|
OWL defines the built-in class <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_FunctionalProperty_semantics">owl:FunctionalProperty</a></span>
|
|
as a special subclass of the RDF class
|
|
<code>rdf:Property</code>.
|
|
</p>
|
|
|
|
<p>The following axiom states that the <code>husband</code> property is
|
|
functional, <em>i.e.,</em> a person can have at most one husband (a good
|
|
example of culture dependence of ontologies):</p>
|
|
|
|
<pre>
|
|
<owl:ObjectProperty rdf:ID="husband">
|
|
<rdf:type rdf:resource="&owl;FunctionalProperty" />
|
|
<rdfs:domain rdf:resource="#Woman" />
|
|
<rdfs:range rdf:resource="#Man" />
|
|
</owl:ObjectProperty>
|
|
</pre>
|
|
|
|
<p>As always, there are other syntactic
|
|
variations. The example above
|
|
is semantically equivalent to the one below:</p>
|
|
|
|
<pre>
|
|
<owl:ObjectProperty rdf:ID="husband">
|
|
<rdfs:domain rdf:resource="#Woman" />
|
|
<rdfs:range rdf:resource="#Man" />
|
|
</owl:ObjectProperty>
|
|
|
|
<owl:FunctionalProperty rdf:about="#husband" />
|
|
</pre>
|
|
|
|
|
|
<h4><a name="InverseFunctionalProperty-def"
|
|
id="InverseFunctionalProperty-def">owl:InverseFunctionalProperty</a></h4>
|
|
|
|
<p>If a
|
|
property is declared to be inverse-functional, the a range value uniquely
|
|
determines the domain value (some individual). More formally, if we state that
|
|
P is an <code>owl:InverseFunctionalProperty</code>, then this asserts that a
|
|
range value 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 pairs (x1,y) and
|
|
(x2,y) are instances of P.</p>
|
|
|
|
<p>Syntactically, an inverse-functional property axiom is specified by
|
|
declaring the property to be an instance of the built-in class
|
|
<span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_InverseFunctionalProperty_semantics">owl:InverseFunctionalProperty</a></span>,
|
|
which is a subclass of the OWL class <code>owl:ObjectProperty</code>.</p>
|
|
|
|
<p class="note">NOTE: Because in
|
|
OWL Full datatype properties are a subclass of object
|
|
properties, an inverse-functional property can be defined for
|
|
datatype properties. In OWL DL object properties and datatype properties are
|
|
disjoint, so an inverse-functional property cannot be defined for datatype
|
|
properties. See also Sections <a href="#OWLFull">8.1</a> and <a
|
|
href="#OWLDL">8.2</a>.</p>
|
|
|
|
<p>A typical example of an inverse-functional property:</p>
|
|
|
|
<pre>
|
|
<owl:InverseFunctionalProperty rdf:ID="biologicalMotherOf">
|
|
<rdfs:domain rdf:resource="#Woman"/>
|
|
<rdfs:range rdf:resource="#Human"/>
|
|
</owl:InverseFunctionalProperty>
|
|
</pre>
|
|
|
|
<p>This example states that for each range value (a
|
|
human) of the property <code>biologicalMotherOf</code> one should be able
|
|
to uniquely identify domain value (a woman). Inverse-functional
|
|
properties resemble the notion of a key in databases. </p>
|
|
|
|
<p>One difference with functional properties is that for inverse-functional
|
|
properties no additional object-property or datatype-property axiom is
|
|
required: inverse-functional properties are by definition object properties.
|
|
</p>
|
|
|
|
<p>Notice that <code><a
|
|
href="#FunctionalProperty-def">owl:FunctionalProperty</a></code> and <code><a
|
|
href="#InverseFunctionalProperty-def">owl:InverseFunctionalProperty</a></code>
|
|
specify global cardinality constraints. That is, no matter which class the
|
|
property is applied to, the cardinality constraints must hold. This is
|
|
different from the cardinality constraints contained in <a
|
|
href="#Restriction">property restrictions</a>. The latter are class
|
|
descriptions and are only enforced on the property when applied to that
|
|
class.</p>
|
|
|
|
|
|
<h3><a name="PropertyLogic">4.4 Logical characteristics of properties</a></h3>
|
|
|
|
<h4><a name="TransitiveProperty-def"
|
|
id="TransitiveProperty-def">owl:TransitiveProperty</a></h4>
|
|
|
|
<p>When one defines a property P to be a transitive property, this means
|
|
that if a pair (x,y) is an instance
|
|
of P, and the pair (y,z) is also instance of P, then we can infer
|
|
the the pair (x,z) is also
|
|
an instance of P. </p>
|
|
|
|
<p>Syntactically, a property is defined as being transitive by making it an
|
|
instance of the the built-in OWL property class
|
|
<span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_TransitiveProperty_semantics">owl:TransitiveProperty</a></span>,
|
|
which is defined as a subclass of <code><a
|
|
href="#ObjectProperty-def">owl:ObjectProperty</a></code>.</p>
|
|
|
|
<p>Typical examples of transitive properties are properties
|
|
representing certain part-whole relations.
|
|
For example, we might want to say that the
|
|
<code>subRegionOf</code> property between regions is transitive:</p>
|
|
|
|
<pre>
|
|
<owl:TransitiveProperty rdf:ID="subRegionOf">
|
|
<rdfs:domain rdf:resource="#Region"/>
|
|
<rdfs:range rdf:resource="#Region"/>
|
|
</owl:TransitiveProperty>
|
|
</pre>
|
|
|
|
<p>From this an OWL reasoner should be able to derive that if
|
|
<code>ChiantiClassico</code>,
|
|
<code>Tuscany</code> and <code>Italy</code> are regions, and
|
|
<code>ChiantiClassico</code> is a subregion of <code>Tuscany</code>, and
|
|
<code>Tuscany</code> is a subregion of <code>Italy</code>, then
|
|
<code>ChiantiClassico</code> is also a subregion of <code>Italy</code>.</p>
|
|
|
|
<p>Note that because <code>owl:TransitiveProperty</code> is a subclass of
|
|
<code>owl:ObjectProperty</code>, the following syntactic variant is equivalent
|
|
to the example above:</p>
|
|
|
|
<pre>
|
|
<owl:ObjectProperty rdf:ID="subRegionOf">
|
|
<rdf:type rdf:resource="&owl;TransitiveProperty"/>
|
|
<rdfs:domain rdf:resource="#Region"/>
|
|
<rdfs:range rdf:resource="#Region"/>
|
|
</owl:ObjectProperty>
|
|
</pre>
|
|
|
|
<p class="note">
|
|
NOTE: OWL DL requires that for a transitive property no local or global
|
|
cardinality constraints should be declared on the property itself or its
|
|
subproperties, nor on the inverse of the property or its subproperties.
|
|
</p>
|
|
|
|
<h4><a name="SymmetricProperty-def"
|
|
id="SymmetricProperty-def">owl:SymmetricProperty</a></h4>
|
|
|
|
<p>
|
|
A symmetric property is a property for which holds that
|
|
if the pair (x,y) is an instance
|
|
of P, then the pair (y,x) is also
|
|
an instance of P.
|
|
Syntactically, a property is defined as symmetric by making it an
|
|
instance of the built-in OWL property class
|
|
<span class="def"><a href="http://www.w3.org/TR/owl-semantics/direct#owl_SymmetricProperty_semantics">owl:SymmetricProperty</a></span>
|
|
is also
|
|
a subclass of <code><a
|
|
href="#ObjectProperty-def">owl:ObjectProperty</a></code>.
|
|
</p>
|
|
|
|
<p>A popular example of a symmetric property is the <code>friendOf</code>
|
|
relation:
|
|
</p>
|
|
|
|
<pre>
|
|
<owl:SymmetricProperty rdf:ID="friendOf">
|
|
<rdfs:domain rdf:resource="#Human"/>
|
|
<rdfs:range rdf:resource="#Human"/>
|
|
</owl:SymmetricProperty>
|
|
</pre>
|
|
|
|
<p>Symmetric properties should have identical domains and ranges to make
|
|
sense. </p>
|
|
|
|
|
|
<h2><a name="Individual" id="Individual">5. Individuals</a></h2>
|
|
|
|
|
|
<h3><a name="IndividualAxiom">5.1 Individual axioms ("facts")</a></h3>
|
|
|
|
<p>Individual axioms (also called "facts") are statements about individuals,
|
|
indicating class membership and statements about relevant properties. As an
|
|
example, consider the following set of statements about an instance of the
|
|
class <code>Opera</code>:</p>
|
|
|
|
<pre>
|
|
<Opera rdf:ID="Tosca">
|
|
<hasComposer rdf:resource="#Giacomo_Puccini"/>
|
|
<hasLibrettist rdf:resource="#Victorien_Sardou"/>
|
|
<hasLibrettist rdf:resource="#Giuseppe_Giacosa"/>
|
|
<hasLibrettist rdf:resource="#Luigi_Illica"/>
|
|
<premiereDate rdf:datatype="&xsd;date">1900-01-14</premiereDate>
|
|
<premierePlace rdf:resource="#Roma"/>
|
|
<numberOfActs rdf:datatype="&xsd;positiveInteger">3</numberOfActs>
|
|
</Opera>
|
|
</pre>
|
|
|
|
<p>This example includes a number of facts
|
|
about the opera <code>Tosca</code>,
|
|
composed by Giacomo Puccini. The opera has three libretto writers. The property
|
|
<code>premiereDate</code> links an opera to a typed literal
|
|
with as datatype the XML Schema datatype
|
|
<code>date</code>. The XML schema document on datatypes
|
|
[<cite><a href="#ref-xml-schema2">XML Schema Datatypes</a></cite>]
|
|
contains the relevant information about syntax and semantics of
|
|
this datatype. </p>
|
|
|
|
<p>Individual axioms need not necessarily be about named individuals: they can
|
|
also refer to anonymous individuals. As an example, consider the piece of
|
|
RDF/XML below. The example defines some facts about an anonymous instance of
|
|
the class
|
|
<code>Measurement</code>, a quantitative observation for which facts such as
|
|
the subject under observation, the observed phenomenon, the observed value, and
|
|
the observation time are listed:</p>
|
|
|
|
<pre>
|
|
<Measurement>
|
|
<observedSubject rdf:resource="#JaneDoe"/>
|
|
<observedPhenomenon rdf:resource="#Weight"/>
|
|
<observedValue>
|
|
<Quantity>
|
|
<quantityValue rdf:datatype="&xsd;float">59.5</quantityValue>
|
|
<quantityUnit rdf:resource="#Kilogram"/>
|
|
</Quantity>
|
|
</observedValue>
|
|
<timeStamp rdf:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</timeStamp>
|
|
</Measurement>
|
|
</pre>
|
|
|
|
<p>This individual axiom contains two anonymous individuals, namely some
|
|
<code>Measurement</code> and some <code>Quantity</code>. In natural language,
|
|
for
|
|
the subject Jane Doe the measured value of the phenomenon
|
|
<code>Weight</code> is some
|
|
quantity, which has a value of 59.5 using the unit of kilogram. The time of
|
|
measurement is January 24, 2003, eight seconds past nine in the morning, in the
|
|
time zone UTC+1 (winter time in Amsterdam, Berlin, Paris). As before,
|
|
<code>float</code> and <code>dateTime</code> are XML Schema datatypes, the
|
|
syntactic and semantic details of which can be found in the relevant XML Schema
|
|
documentation
|
|
[<cite><a href="#ref-xml-schema2">XML Schema Datatypes</a></cite>].</p>
|
|
|
|
<h3><a name="IndividualIdentity">5.2 Individual identity</a></h3>
|
|
|
|
<p>Many languages have a so-called "unique names" assumption: different names
|
|
refer to different things in the world. On the web, such an assumption is not
|
|
possible. For example, the same person could be referred to in many different
|
|
ways (i.e. with different URI references). For this reason OWL does not make
|
|
this assumption. Unless an explicit statement is being made that two URI
|
|
references refer to the same or to different individuals, OWL tools should in
|
|
principle assume either situation is possible.</p>
|
|
|
|
<p>OWL provides three constructs for making statements about the identity of
|
|
individuals:</p>
|
|
|
|
<ul>
|
|
<li><code>owl:sameAs</code> is used to state that two URI references refer to
|
|
the same individual. The construct <code>owl:sameIndividualAs</code> is a synonym
|
|
of <code>owl:sameAs</code></li>
|
|
<li><code>owl:differentFrom</code> is used to state that two URI references
|
|
refer to different individuals</li>
|
|
<li><code>owl:AllDifferent</code> provides an idiom for stating that a list
|
|
of individuals are all different.</li>
|
|
</ul>
|
|
|
|
<h4><a name="sameAs-def">owl:sameAs</a> and <a name="sameIndividualAs-def">owl:sameIndividualAs</a></h4>
|
|
|
|
<p>The property <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_sameIndividualAs_semantics">owl:sameAs</a></span>
|
|
has as its domain and range an individual.
|
|
Such an <code>owl:sameAs</code> statement indicates that
|
|
two URI references actually refer to the same thing: the
|
|
individuals have the same "identity". For historical reasons, OWL also supports
|
|
<code>owl:sameIndividualAs</code> as a synonym with exactly the same
|
|
meaning. </p>
|
|
|
|
<p>For individuals such as "people" this
|
|
notion is relatively easy to understand. For example, we could state that
|
|
the following two URI references actually refer to the same person:</p>
|
|
|
|
<pre>
|
|
<owl:Human rdf:about="#William_Jefferson_Clinton">
|
|
<owl:sameAs rdf:resource="#BillClinton"/>
|
|
</owl:Human>
|
|
</pre>
|
|
|
|
<p>The <code>owl:sameAs</code> statements are often used in defining mappings
|
|
between ontologies. It is unrealistic to assume everybody will use the same
|
|
name to refer to individuals. That would require some grand design, which is
|
|
contrary to the spirit of the web. </p>
|
|
|
|
<p>In OWL Full, where class can be treated as instances of (meta)classes, we
|
|
can use the <code>owl:sameAs</code> construct to define class equality,
|
|
thus indicating that two concepts have the same intensional meaning.
|
|
An example: </p>
|
|
<pre>
|
|
<owl:Class rdf:ID="FootballTeam">
|
|
<owl:sameAs rdf:resource="http://sports.org/US#SoccerTeam"/>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>One could imagine this axiom to be part of a European sports ontology. The
|
|
two classes are treated here as individuals, in this case as instances of the
|
|
class <code>owl:Class</code>. This allows us to state that the class
|
|
<code>FootballTeam</code> in some European sports ontology denotes the same concept as the
|
|
class <code>SoccerTeam</code> in some American sports ontology. Note the difference with
|
|
the statement:</p>
|
|
|
|
<pre>
|
|
<footballTeam owl:equivalentClass us:soccerTeam />
|
|
</pre>
|
|
|
|
<p>which states that the two classes have the same class extension, but are not
|
|
(necessarily) the same concepts. </p>
|
|
|
|
|
|
<h4><a name="differentFrom-def">owl:differentFrom</a></h4>
|
|
|
|
<p>
|
|
An <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_differentFrom_semantics">owl:differentFrom</a></span>
|
|
property links an individual to another individual.
|
|
An <code>owl:differentFrom</code> statement indicates that two URI references
|
|
refer to different individuals. </p>
|
|
|
|
<p>An example:</p>
|
|
|
|
<pre>
|
|
<Opera rdf:ID="Don_Giovanni"/>
|
|
|
|
<Opera rdf:ID="Nozze_di_Figaro">
|
|
<owl:differentFrom rdf:resource="#Don_Giovanni"/>
|
|
</Opera>
|
|
|
|
<Opera rdf:ID="Cosi_fan_tutte">
|
|
<owl:differentFrom rdf:resource="#Don_Giovanni"/>
|
|
<owl:differentFrom rdf:resource="#Nozze_di_Figaro"/>
|
|
</Opera>
|
|
</pre>
|
|
|
|
This states that there are three operas, which are all different individuals.
|
|
|
|
|
|
<h4><a name="AllDifferent-def">owl:AllDifferent</a></h4>
|
|
|
|
<p>For ontologies in which the unique-names assumption holds, the use of
|
|
<code>owl:differentFrom</code> is likely to lead to a large number of
|
|
statements, as all individuals have to be declared pairwise disjoint. For such
|
|
situations OWL provides a special idiom in the form of the construct <a
|
|
href="http://www.w3.org/TR/owl-semantics/rdfs#owl_AllDifferent_rdf">owl:AllDifferent</a>.
|
|
The <code>owl:AllDifferent</code> construct is a special OWL class, for which
|
|
the property <a
|
|
href="http://www.w3.org/TR/owl-semantics/rdfs#owl_distinctMembers_rdf">owl:distinctMembers</a>
|
|
<a name="distinctMembers-def" id="distinctMembers-def"></a> is defined, which
|
|
links an instance of <code>owl:AllDifferent</code> to a list of individuals. The
|
|
intended meaning of such a statement is that all individuals in the list are
|
|
all different from each other.</p>
|
|
|
|
<p>An example:</p>
|
|
|
|
<pre>
|
|
<owl:AllDifferent>
|
|
<owl:distinctMembers rdf:parseType="Collection">
|
|
<Opera rdf:about="#Don_Giovanni"/>
|
|
<Opera rdf:about="#Nozze_di_Figaro"/>
|
|
<Opera rdf:about="#Cosi_fan_tutte"/>
|
|
<Opera rdf:about="#Tosca"/>
|
|
<Opera rdf:about="#Turandot"/>
|
|
<Opera rdf:about="#Salome"/>
|
|
</owl:distinctMembers>
|
|
</owl:AllDifferent>
|
|
</pre>
|
|
|
|
<p>This states that these six URI references all
|
|
point to different operas. </p>
|
|
|
|
<p class="note">
|
|
NOTE: <code>owl:distinctMembers</code> is a special syntactical construct added
|
|
for convenience and should always be used with an <code>owl:AllDifferent</code>
|
|
individual as its domain value.</p>
|
|
|
|
|
|
<h2><a name="Datatype" id="Datatype"></a>6. Datatypes</h2>
|
|
|
|
<p>
|
|
In a number of places in this document we have seen the notion of a
|
|
<a name="DataRange">data range</a>
|
|
for specifying a range of data values. OWL allows two types of data range
|
|
specifications:</p>
|
|
|
|
<ul>
|
|
<li>A <a href="#rdf-datatype">RDF datatype</a> specification.</li>
|
|
<li>An <a href="#EnumeratedDatatype">enumerated datatype</a>,
|
|
using the <code>owl:oneOf</code> construct.</li>
|
|
</ul>
|
|
|
|
<h3><a name="rdf-datatype" id="rdf-datatype"></a>6.1 RDF Datatypes</h3>
|
|
|
|
<p>OWL makes use of the RDF datatyping scheme, which provides a mechanism for
|
|
referring to XML Schema datatypes
|
|
[<cite><a href="#ref-xml-schema2">XML Schema Datatypes</a></cite>]. For a
|
|
detailed description the reader is referred to the RDF documents, <em>e.g.</em>,
|
|
[<cite><a href="#ref-rdf-concepts">RDF Concepts</a></cite>].
|
|
For the convenience of
|
|
the reader, we provide here a
|
|
synopsis of the use of RDF datatypes.</p>
|
|
|
|
<p>Data values are instances of the RDF Schema class
|
|
<code>rdfs:Literal</code>. Literals can be either
|
|
plain (no datatype) or typed. Datatypes are instances of the class
|
|
<code>rdfs:Datatype</code>. A
|
|
typed literal needs to have an XML attribute <code>rdf:datatype</code> of which
|
|
the value is recommended to be one of the following:</p>
|
|
|
|
<ul>
|
|
<li>A canonical URI reference to an XML Schema datatype of the form:
|
|
<pre>
|
|
http://www.w3.org/2001/XMLSchema#NAME
|
|
</pre>
|
|
where "NAME" should be the name of a <em>simple</em> XML Schema
|
|
<em>built-in</em> datatype, as defined in Section 3 of
|
|
[<cite><a href="#ref-xml-schema2">XML Schema Datatypes</a></cite>], with the
|
|
provisos specified below.</li>
|
|
<li>The RDF datatype
|
|
<a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/#section-XMLLiteral">
|
|
<code>rdf:XMLLiteral</code></a>.
|
|
This datatype is used to
|
|
include XML content into an RDF/OWL document. The URI reference of this
|
|
datatype is:
|
|
<pre>
|
|
http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral
|
|
</pre>
|
|
For details about this datatype, see the RDF Concepts document
|
|
[<cite><a href="#ref-rdf-concepts">RDF Concepts</a></cite>].
|
|
</li>
|
|
<li>The RDF datatype
|
|
<a href="http://www.w3.org/TR/rdf-schema/#ch_literal">rdfs:Literal</a>
|
|
which is the class of literals, typed and plain. The URI reference of this
|
|
datatype is:
|
|
<pre>
|
|
http://www.w3.org/2000/01/rdf-schema#Literal
|
|
</pre></li>
|
|
</ul>
|
|
|
|
<p>The following are the recommended simple built-in XML Schema datatypes
|
|
for use in OWL ontologies: </p>
|
|
<ul>
|
|
<li>The primitive datatype
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#string">
|
|
<code>xsd:string</code></a>,
|
|
plus the following datatypes derived from xsd:strong:
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#normalizedString">
|
|
<code>xsd:normalizedString</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#token">
|
|
<code>xsd:token</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#language">
|
|
<code>xsd:language</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#NMTOKEN">
|
|
<code>xsd:NMTOKEN</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#Name">
|
|
<code>xsd:Name</code></a>,and
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#NCName">
|
|
<code>xsd:NCName</code></a>.</li>
|
|
|
|
<li>The primitive datatype
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#boolean">
|
|
<code>xsd:boolean</code></a>.</li>
|
|
|
|
<li>The primitive numerical datatypes
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#decimal">
|
|
<code>xsd:decimal</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#float">
|
|
<code>xsd:float</code></a>, and
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#double">
|
|
<code>xsd:double</code></a>,
|
|
plus all derived types of xsd:decimal
|
|
(<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#integer">
|
|
<code>xsd:integer</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#positiveInteger">
|
|
<code>xsd:positiveInteger</code></a>.
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#nonPositiveInteger">
|
|
<code>xsd:nonPositiveInteger</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#negativeInteger">
|
|
<code>xsd:negativeInteger</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#nonNegativeInteger">
|
|
<code>xsd:nonNegativeInteger</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#long">
|
|
<code>xsd:long</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#int">
|
|
<code>xsd:int</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#short">
|
|
<code>xsd:short</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#byte">
|
|
<code>xsd:byte</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#unsignedLong">
|
|
<code>xsd:unsignedLong</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#unsignedInt">
|
|
<code>xsd:unsignedInt</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#unsignedShort">
|
|
<code>xsd:unsignedShort</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#unsignedByte">
|
|
<code>xsd:unsignedByte</code></a>)</li>
|
|
|
|
<li>The primitive time-related datatypes:
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#dateTime">
|
|
<code>xsd:dateTime</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#time">
|
|
<code>xsd:time</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#date">
|
|
<code>xsd:date</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#gYearMonth">
|
|
<code>xsd:gYearMonth</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#gYear">
|
|
<code>xsd:gYear</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#gMonthDay">
|
|
<code>xsd:gMonthDay</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#gDay">
|
|
<code>xsd:gDay</code></a>, and
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#gMonth">
|
|
<code>xsd:gMonth</code></a>.</li>
|
|
|
|
<li>The primitive datatypes
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#hexBinary">
|
|
<code>xsd:hexBinary</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#base64Binary">
|
|
<code>xsd:base64Binary</code></a>, and
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#anyURI">
|
|
<code>xsd:anyURI</code></a>.</li>
|
|
|
|
</ul>
|
|
|
|
<p>The following datatypes are NOT recommended for use in OWL
|
|
(see for details the OWL Semantics and Abstract Syntax document
|
|
[<cite><a href="#ref-abstract-syntax">OWL S&AS</a></cite>]):
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#duration">
|
|
<code>xsd:duration</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#QName">
|
|
<code>xsd:QName</code></a>.
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#ENTITY">
|
|
<code>xsd:ENTITY</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#NOTATION">
|
|
<code>xsd:NOTATION</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#ID">
|
|
<code>xsd:ID</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#IDREF">
|
|
<code>xsd:IDREF</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#IDREFS">
|
|
<code>xsd:IDREFS</code></a>,
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#ENTITIES">
|
|
<code>xsd:ENTITIES</code></a>, and
|
|
<a href="http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#NMTOKENS">
|
|
<code>xsd:NMTOKENS</code></a>.
|
|
</p>
|
|
|
|
<p class="note">
|
|
NOTE: It is not illegal, although not recommended, for applications to define
|
|
their own datatypes by defining an instance of <code>rdfs:Datatype</code>. Such
|
|
datatypes are "unrecognized", but are treated in a similar fashion as
|
|
"unsupported datatypes" (see Sect. <a href="#DatatypeSupport">6.3</a>
|
|
for details about how these should be treated by OWL tools). </p>
|
|
|
|
<p>When using datatypes, please note that even if
|
|
the range of a property is declared to be of a certain datatype, RDF still
|
|
requires a <code>rdf:datatype</code> attribute in a statement about this
|
|
property, otherwise it is treated as a plain literal.
|
|
An example could be the declaration of a property
|
|
that we used earlier in the <code>Measurement</code> example:</p>
|
|
|
|
<pre>
|
|
<owl:DatatypeProperty rdf:about="#timeStamp">
|
|
<rdfs:domain rdf:resource="#Measurement"/>
|
|
<rdf:range rdf:resource="&xsd;dateTime"/>
|
|
</owl:DatatypeProperty>
|
|
|
|
<Measurement>
|
|
<timeStamp rdf:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</timeStamp>
|
|
</Measurement>
|
|
</pre>
|
|
|
|
|
|
<h3><a name="EnumeratedDatatype"></a>6.2 Enumerated datatype</h3>
|
|
|
|
<p>In addition to the RDF datatypes, OWL provides one additional construct for
|
|
defining a range of data values, namely an enumerated datatype. This datatype
|
|
format makes use of the <code>owl:oneOf</code> construct, that is also used for
|
|
describing an <a href="#EnumeratedClass">enumerated class</a>. In the case of
|
|
an enumerated datatype, the domain value of <code>owl:oneOf</code> is a blank
|
|
node of class
|
|
<a name="DataRange-def"><code>owl:DataRange</code></a>
|
|
and the range value is a list of
|
|
literals. Unfortunately, we cannot use the
|
|
<code>rdf:parseType="Collection"</code> idiom for specifying the literal list,
|
|
because RDF requires the collection to be a list of RDF node
|
|
elements. Therefore we have to specify the list of data values with the basic
|
|
list constructs <code>rdf:first</code>, <code>rdf:rest</code> and
|
|
<code>rdf:nil</code>.</p>
|
|
|
|
<p>The example below specifies the range of the property
|
|
<code>tennisGameScore</code> to be the list of integer values {0, 15, 30, 40}:.
|
|
</p>
|
|
|
|
<pre>
|
|
<owl:DatatypeProperty rdf:ID="tennisGameScore">
|
|
<rdfs:range>
|
|
<owl:DataRange>
|
|
<owl:oneOf>
|
|
<rdf:List>
|
|
<rdf:first rdf:datatype="xsd:integer">0</rdf:first>
|
|
<rdf:rest>
|
|
<rdf:List>
|
|
<rdf:first rdf:datatype="xsd:integer">15</rdf:first>
|
|
<rdf:rest>
|
|
<rdf:List>
|
|
<rdf:first rdf:datatype="xsd:integer">30</rdf:first>
|
|
<rdf:rest>
|
|
<rdf:List>
|
|
<rdf:first rdf:datatype="xsd:integer">40</rdf:first>
|
|
<rdf:rest rdf:resource="&rdf;nil" />
|
|
</rdf:List>
|
|
</rdf:rest>
|
|
</rdf:List>
|
|
</rdf:rest>
|
|
</rdf:List>
|
|
</rdf:rest>
|
|
</rdf:List>
|
|
</owl:oneOf>
|
|
</owl:DataRange>
|
|
</rdfs:range>
|
|
</owl:DatatypeProperty>
|
|
</pre>
|
|
|
|
|
|
<p class="note">
|
|
NOTE: Enumerated datatypes are not part of OWL Lite.
|
|
</p>
|
|
|
|
<h3><a name="DatatypeSupport"></a>6.3 Support for datatype reasoning</h3>
|
|
|
|
<p>Tools may vary in terms of support for datatype reasoning. As a minimum,
|
|
tools should support datatype reasoning for the XML Schema datatypes
|
|
<code>xsd:string</code> and <code>xsd:integer</code>. For unsupported
|
|
datatypes, lexically identical
|
|
literals should be considered equal, whereas lexically different literals
|
|
would not be known to be either equal or unequal.
|
|
Unrecognized datatypes should be treated in the same way as
|
|
unsupported datatypes. </p>
|
|
|
|
|
|
|
|
|
|
|
|
<h2><a name="Header" id="Header">7. Annotations, ontology header, imports and
|
|
version information</a></h2>
|
|
|
|
<h3><a name="Annotations"></a>7.1 Annotations</h3>
|
|
|
|
<p>
|
|
OWL DL allows annotations on classes, properties, individuals
|
|
and ontology headers, but only under the following conditions:
|
|
</p>
|
|
<ul>
|
|
<li>Annotation properties should have an explicit typing triple of the form:
|
|
<pre>
|
|
AnnotationPropertyID rdf:type owl:AnnotationProperty
|
|
</pre></li>
|
|
<li>Annotation properties must not be used in property axioms (e.g., no
|
|
subproperties are allowed).</li>
|
|
</ul>
|
|
<p>Five annotation properties are predefined by OWL, namely:</p>
|
|
<ul>
|
|
<li><code>owl:versionInfo</code></li>
|
|
<li><code>rdfs:label</code></li>
|
|
<li><code>rdfs:comment</code></li>
|
|
<li><code>rdfs:seeAlso</code></li>
|
|
<li><code>rdfs:isDefinedBy</code></li>
|
|
</ul>
|
|
<p>Here is an example of legal use of an annotation property is OWL DL:</p>
|
|
|
|
<pre>
|
|
<owl:AnnotationProperty rdf:about="&dc;creator"/>
|
|
|
|
<owl:Class rdf:about="MusicalWork">
|
|
<rdfs:label>Musical work</rdf:label>
|
|
<dc:creator>N.N.</dc:creator>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>The example assumes <code>&dc;</code> and <code>dc:</code> point
|
|
respectively to the Dublin Core URI and namespace. Thus, using
|
|
Dublin Core annotations in OWL DL requires an explicit typing triple.
|
|
This ensures annotations are handled in a semantically correct fashion by OWL
|
|
DL reasoners
|
|
(see the OWL Semantics and Abstract Syntax document [<cite><a
|
|
href="#ref-abstract-syntax">OWL S&AS</a></cite>] for details).</p>
|
|
|
|
|
|
<h3><a name="Ontology-def" id="Ontology-def">7.2 Ontology header</a></h3>
|
|
|
|
<p>An ontology header component is represented with an instance of the class
|
|
<code>owl:Ontology</code>, which typically identifies the containing document
|
|
with a same-document reference <a
|
|
href="http://www.ietf.org/rfc/rfc2396.txt">[section 4.2 of RFC2396]</a>, and
|
|
which may optionally contain, in any order, any number of import and/or
|
|
versioning statements.</p>
|
|
|
|
<p>A sample ontology header could look like this:</p>
|
|
|
|
<pre>
|
|
<owl:Ontology rdf:about="">
|
|
<owl:versionInfo>v 1.17 2003/02/26 12:56:51 mdean</owl:versionInfo>
|
|
<rdfs:comment>An example ontology</rdfs:comment>
|
|
<owl:imports rdf:resource="http://www.example.org/foo"/>
|
|
</owl:Ontology>
|
|
</pre>
|
|
|
|
<p>The <code>rdf:about=""</code> refers to the current document.
|
|
The following sections describe the various types of statements that are
|
|
typically used within the header.</p>
|
|
|
|
<h3><a name="imports-def" id="imports-def">7.3 Importing an ontology</a></h3>
|
|
|
|
<p>An <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/direct#owl_imports_semantics"><code>owl:imports</code></a></span>
|
|
statement references another OWL ontology containing definitions, whose meaning
|
|
is considered to be part of the meaning of
|
|
the importing ontology. Each reference consists of a URI
|
|
specifying from where the ontology is to be imported.
|
|
Technically, <code>owl:imports</code> is a property with an instance of the
|
|
class <code>owl:Ontology</code> as its domain and range. </p>
|
|
|
|
<p>The <code>owl:imports</code> statements are transitive, that is, if
|
|
ontology A imports B, and B imports C, then A imports both B and C.</p>
|
|
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 the importing a document is different than creating a
|
|
namespace reference. owl:imports do not set up a shorthand notation
|
|
for names as does a namespace reference. On the other hand, the
|
|
namespace reference does not imply that all (or even any) ontological
|
|
terms from that namespace are being imported. Therefore, it is common
|
|
to have a corresponding namespace declaration for any ontology that is
|
|
imported.
|
|
</p>
|
|
|
|
|
|
<h3><a name="VersionInformation">7.4 Version information</a></h3>
|
|
|
|
<h4><a name="versionInfo-def" id="versionInfo-def">owl:versionInfo</a></h4>
|
|
|
|
<p>An
|
|
<span class="def"><a href="http://www.w3.org/TR/owl-semantics/mapping#owl_versionInfo_mapping"><code>owl:versionInfo</code></a></span>
|
|
statement generally contains a string giving information about this
|
|
version, for example RCS/CVS keywords. This statement does not
|
|
contribute to the logical meaning of the ontology other than that
|
|
given by the RDF(S) model theory.</p>
|
|
|
|
<p>Although this property is typically used to make statements about
|
|
ontologies, it may be applied to any OWL construct. For example, one could
|
|
attach a <code>owl:versionInfo</code> statement to an OWL class.
|
|
</p>
|
|
|
|
<h4> <a name="priorVersion-def" id="priorVersion-def">owl:priorVersion</a></h4>
|
|
|
|
<p> An <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/mapping#owl_priorVersion_mapping"><code>owl:priorVersion</code></a></span>
|
|
statement contains a reference to another ontology. This identifies
|
|
the specified ontology as a prior version of the containing ontology.
|
|
This has no meaning in the model-theoretic semantics other than that
|
|
given by the RDF(S) model theory. However, it may be used by software
|
|
to organize ontologies by versions.</p>
|
|
|
|
<p>The <code>owl:priorVersion</code> construct is a property with an instance
|
|
of the class <code>owl:Ontology</code> as its domain and range.
|
|
</p>
|
|
|
|
<h4><a name="backwardCompatibleWith-def"
|
|
id="backwardCompatibleWith-def">owl:backwardCompatibleWith</a></h4>
|
|
|
|
<p>An <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/mapping#owl_backwardCompatibleWith_mapping"><code>owl:backwardCompatibleWith</code></a></span>
|
|
statement contains a reference to another ontology. This identifies
|
|
the specified ontology as a prior version of the containing ontology,
|
|
and further indicates that it is backward compatible with it. In
|
|
particular, this indicates that all identifiers from the previous
|
|
version have the same intended interpretations in the new version.
|
|
Thus, it is a hint to document authors that they can safely change
|
|
their documents to commit to the new version (by simply updating
|
|
namespace declarations and <a href="#imports-def"><code>owl:imports</code></a> statements to refer to the URL of
|
|
the new version). If <code>owl:backwardCompatibleWith</code> is not
|
|
declared for two versions, then compatibility should not be assumed.</p>
|
|
|
|
<p><code>owl:backwardCompatibleWith</code>
|
|
has no meaning in the model theoretic semantics other than that given by the
|
|
RDF(S) model theory.</p>
|
|
|
|
<p>The <code>owl:backwardCompatibleWith</code> construct is a property with an instance
|
|
of the class <code>owl:Ontology</code> as its domain and range.
|
|
</p>
|
|
|
|
<h4><a name="incompatibleWith-def"
|
|
id="incompatibleWith-def">owl:incompatibleWith</a></h4>
|
|
|
|
<p>An <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/mapping#owl_incompatibleWith_mapping"><code>owl:incompatibleWith</code></a></span>
|
|
statement contains a reference to another ontology. This indicates that the
|
|
containing ontology is a later version of the referenced ontology, but is not
|
|
backward compatible with it. Essentially, this is for use by ontology authors
|
|
who want to be explicit that documents cannot upgrade to use the new version
|
|
without checking whether changes are required.</p>
|
|
|
|
<p><code>owl:incompatibleWith</code> has
|
|
no meaning in the model theoretic semantics other than that given by the
|
|
RDF(S) model theory.</p>
|
|
|
|
<p>The <code>owl:incompatiblewith</code> construct is a property with an
|
|
instance of the class <code>owl:Ontology</code> as its domain and range.
|
|
</p>
|
|
|
|
<h4><a name="Deprecation" id="Deprecation">owl:DeprecatedClass and owl:DeprecatedProperty</a></h4>
|
|
|
|
<p>
|
|
<a name="DeprecatedClass-def" id="DeprecatedClass-def"></a> <a
|
|
name="DeprecatedProperty-def" id="DeprecatedProperty-def"></a> Deprecation is a
|
|
feature commonly used in versioning software (for example, see the Java
|
|
programming language) to indicate that a particular feature is preserved for
|
|
backward-compatibility purposes, but may be phased out in the future. Here, a
|
|
specific identifier is said to be of type <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/#owl_DeprecatedClass">owl:DeprecatedClass</a></span>
|
|
or <span class="def"><a
|
|
href="http://www.w3.org/TR/owl-semantics/#owl_DeprecatedProperty">owl:DeprecatedProperty</a></span>,
|
|
where <code>owl:DeprecatedClass</code> is a subclass of <code>rdfs:Class</code>
|
|
and <code>owl:DeprecatedProperty</code> is a subclass of
|
|
<code>rdf:Property</code>. By deprecating a term, it means that the term
|
|
should not be used in new documents that commit to the ontology. This allows
|
|
an ontology to maintain backward-compatibility while phasing out an old
|
|
vocabulary (thus, it only makes sense to use deprecation in combination with
|
|
backward compatibility). As a result, it it easier for old data and
|
|
applications to migrate to a new version, and thus can increase the level of
|
|
adoption of the new version. This has no meaning in the model theoretic
|
|
semantics other than that given by the RDF(S) model theory. However, authoring
|
|
tools may use it to warn users when checking OWL markup.</p>
|
|
|
|
<p>An example of deprecation is:</p>
|
|
|
|
<pre>
|
|
<owl:Ontology rdf:about="">
|
|
<rdfs:comment>Vehicle Ontology, v. 1.1</rdfs:comment>
|
|
<owl:backwardCompatibleWith rdf:resource="http://www.example.org/vehicle-1.0"/>
|
|
<owl:priorVersion rdf:resource="http://www.example.org/vehicle-1.0"/>
|
|
</owl:Ontology>
|
|
|
|
<owl:DeprecatedClass rdf:ID="Car">
|
|
<rdfs:comment>Automobile is now preferred</rdfs:comment>
|
|
</owl:DeprecatedClass>
|
|
|
|
<owl:Class rdf:ID="Automobile">
|
|
<owl:equivalentClass rdf:resource="#Car"/>
|
|
<!-- note that equivalentClass only means that the classes have the same
|
|
extension, so this DOES NOT lead to the entailment that
|
|
Automobile is of type DeprecatedClass too -->
|
|
</owl:Class>
|
|
|
|
<owl:DeprecatedProperty rdf:ID="hasDriver">
|
|
<rdfs:comment>inverse property drives is now preferred</rdfs:comment>
|
|
</owl:DeprecatedProperty>
|
|
|
|
<owl:ObjectProperty rdf:ID="drives">
|
|
<owl:inverseOf rdf:resource="#hasDriver"/>
|
|
</owl:ObjectProperty>
|
|
</pre>
|
|
|
|
|
|
<h2><a name="Sublanguage-def">8. OWL Full, OWL DL and OWL Lite</a></h2>
|
|
|
|
<p>In the introduction we briefly discussed the three sublanguages of OWL. In
|
|
this section an informative
|
|
specification is given of the differences between the
|
|
three "species" of OWL. A formal account of the differences is given in the
|
|
Semantics and Abstract Syntax document [<cite><a
|
|
href="#ref-abstract-syntax">OWL S&AS</a></cite>].</p>
|
|
|
|
|
|
<h3><a name="OWLFull">8.1 OWL Full</a></h3>
|
|
|
|
<p>OWL Full is not actually a sublanguage. OWL Full contains all the OWL
|
|
language constructs and provides free, unconstrained use of RDF constructs.
|
|
In OWL Full The resource <code>owl:Class</code> is equivalent to
|
|
<code>rdfs:Class</code>. This is different from OWL DL
|
|
and OWL Lite, where <code>owl:Class</code> is a proper subclass of
|
|
<code>rdfs:Class</code> (meaning that not all RDF classes are OWL
|
|
classes in OWL DL and OWL Lite).
|
|
OWL Full also allows classes to be treated as individuals. For
|
|
example, it is perfectly legal in OWL Full to have a "Fokker-100" identifier
|
|
which acts both as a class name (denoting the set of Fokker-100 airplanes
|
|
flying around the world) and as an individual name (<em>e.g.</em>,
|
|
an instance of the
|
|
class <code>AirplaneType</code>). </p>
|
|
|
|
<p>In OWL Full all data values are considered to also be part of the individual
|
|
domain. In fact, in OWL Full the universe of individuals consists of
|
|
all resources.
|
|
This means that object properties and datatype properties are not
|
|
disjoint. In OWL Full <code>owl:ObjectProperty</code> is equivalent to
|
|
<code>rdf:Property</code>. The consequence is
|
|
that datatype properties are effectively
|
|
a subclass of object properties. (Note: the fact that
|
|
<code>owl:ObjectProperty</code> and <code>owl:DatatypeProperty</code> are both
|
|
subclasses of <code>rdf:Property</code> is not inconsistent with this).
|
|
Although from the semantics point of view it is not forbidden in OWL Full to declare
|
|
datatype properties to be inverse, transitive, or symmetric, in practice this
|
|
does not make much sense. (RDF does not allow data values as the subject of a
|
|
statement). However, for inverse-functional properties this does
|
|
make sense and such a definition is thus explicitly allowed in OWL Full.</p>
|
|
|
|
<p>OWL Full will typically be useful for people who want to combine the
|
|
expressivity of OWL with the flexibility and metamodelling features of RDF.
|
|
However, use of the OWL Full features means that one loses some
|
|
guarantees (see <a href="#OWLDL">below</a>) that OWL DL and OWL Lite can provide
|
|
for reasoning systems.</p>
|
|
|
|
<p class="note">
|
|
NOTE: RDF documents will generally be in OWL Full, unless they are
|
|
specifically constructed to be in OWL DL or Lite.
|
|
</p>
|
|
|
|
<p class="note">
|
|
NOTE: Thus, in OWL Full
|
|
<code>owl:Thing</code> is equivalent to
|
|
<code>rdf:Resource</code>,
|
|
<code>owl:Class</code> is equivalent to
|
|
<code>rdfs:Class</code>, and
|
|
<code>owl:ObjectProperty</code> is equivalent to
|
|
<code>rdf:Property</code>,
|
|
</p>
|
|
|
|
<h3><a name="OWLDL">8.2 OWL DL</a></h3>
|
|
|
|
<p>OWL DL is a sublanguage of OWL which places a number of constraints on
|
|
the use of the OWL language constructs. Briefly, these constraints are the
|
|
following:</p>
|
|
<ul>
|
|
<li>OWL DL requires a pairwise separation between classes, datatypes,
|
|
datatype properties, object properties, annotation properties, ontology
|
|
properties (<em>i.e.,</em> the import and versioning stuff),
|
|
individuals, data values and the built-in vocabulary. This means that, for
|
|
example, a class cannot be at the same time an individual.</li>
|
|
<li>In OWL DL the set of object properties and datatype properties are
|
|
disjoint. This implies that the following four property characteristics:
|
|
<ul>
|
|
<li><a href="#inverseOf-def">inverse of</a>,</li>
|
|
<li><a href="#InverseFunctionalProperty-def">inverse functional</a>, </li>
|
|
<li><a href="#SymmetricProperty-def">symmetric</a>, and </li>
|
|
<li><a href="#TransitiveProperty-def">transitive</a></li>
|
|
</ul>
|
|
can never be specified for <a href="#DatatypeProperty-def">datatype
|
|
properties</a></li>
|
|
<li>OWL DL requires that no cardinality constraints (local nor global)
|
|
can be placed on transitive properties or their inverses or any of their
|
|
superproperties.</li>
|
|
<li>Annotations are allowed only under certain conditions. See Section <a
|
|
href="#Annotations">7.1</a> for details. </li>
|
|
<li>Most RDF(S) vocabulary cannot be used within OWL DL. See the OWL
|
|
Semantics and Abstract Syntax document [<cite><a
|
|
href="#ref-abstract-syntax">OWL S&AS</a></cite>] for details. </li>
|
|
<li>All axioms must be well-formed, with no missing or extra components, and
|
|
must form a tree-like structure.
|
|
|
|
<p>The last constraint implies that all classes and properties that one
|
|
refers to are explicitly typed as OWL classes or properties, respectively.
|
|
For example, if the ontology contains the following component:</p>
|
|
<pre>
|
|
<owl:Class rdf:ID="C1">
|
|
<rdfs:subClassOf rdf:about="#C2" />
|
|
</owl:Class>
|
|
</pre>
|
|
<p>then the ontology (or an ontology imported into this ontology)
|
|
should contain a <code>owl:Class</code> triple for
|
|
<code>C2</code>.</p></li>
|
|
<li>Axioms (facts) about individual equality and difference must be about
|
|
named individuals. </li>
|
|
</ul>
|
|
|
|
<p>These constraints of OWL DL may seem like an arbitrary set, but in fact
|
|
they are not. The constraints are based on work in the
|
|
area of reasoners for Description Logic, which require these restrictions to
|
|
provide the ontology builder or user with reasoning support.
|
|
In particular, the OWL DL restrictions allow the maximal subset of OWL
|
|
Full against which current research can assure that a decidable
|
|
reasoning procedure can exist for an OWL reasoner.
|
|
</p>
|
|
|
|
<h3><a name="OWLLite">8.3 OWL Lite</a></h3>
|
|
|
|
<p>
|
|
OWL Lite abides by all the restrictions OWL DL puts on the use of the OWL
|
|
language constructs.
|
|
In addition, OWL Lite forbids the use of:</p>
|
|
<ul>
|
|
<li><a href="#oneOf-def">owl:oneOf</a></li>
|
|
<li><a href="#unionOf-def">owl:unionOf</a></li>
|
|
<li><a href="#complementOf-def">owl:complementOf</a></li>
|
|
<li><a href="#hasValue-def">owl:hasValue</a></li>
|
|
<li><a href="#disjointWith-def">owl:disjointWith</a></li>
|
|
<li><a href="#DataRange-def">owl:DataRange</a></li>
|
|
<li><a href="#Nothing-def">owl:Nothing</a></li>
|
|
</ul>
|
|
|
|
<p>In addition, OWL Lite requires that:</p>
|
|
<ul>
|
|
<li>the subject of <code>owl:equivalentClass</code> triples be named classes
|
|
and the object of <code>owl:equivalentClass</code> triples be named classes,
|
|
restrictions, or subjects of <code>owl:intersectionOf</code> triples;</li>
|
|
<li>the subject of <code>rdfs:subClassOf</code> triples be named classes
|
|
and the object of <code>rdfs:subClassOf</code> triples be named classes or
|
|
restrictions;</li>
|
|
<li><code>owl:intersectionOf</code> be used only on lists of length greater
|
|
than one that contain only named classes and restrictions;
|
|
<p class="note">
|
|
NOTE: This is a prototypical example of legal use of
|
|
<code>owl:intersectionOf</code> in OWL Lite:</p>
|
|
<pre>
|
|
<owl:Class rdf:ID="Woman">
|
|
<owl:intersectionOf rdf:parseType="Collection">
|
|
<owl:Class rdf:about="#Female"/>
|
|
<owl:Class rdf:about="#Human"/>
|
|
</owl:intersectionOf>
|
|
</owl:Class/>
|
|
</pre>
|
|
</li>
|
|
<li>the object of <code>owl:allValuesFrom</code> and
|
|
<code>owl:someValuesFrom</code> triples be named
|
|
classes or named datatypes;</li>
|
|
<li>the object of <code>rdf:type</code> triples be named classes or
|
|
restrictions;</li>
|
|
<li>the object of <code>rdfs:domain</code> triples be named classes;
|
|
and</li>
|
|
<li>the object of <code>rdfs:range</code> triples be named classes or
|
|
datatypes.
|
|
</li>
|
|
</ul>
|
|
|
|
<p>The idea behind the OWL Lite expressivity limitations is that they provide a
|
|
minimal useful subset of language features, that are relatively straightforward
|
|
for tool developers to support. The language constructs of OWL Lite provide the
|
|
basics for subclass hierarchy construction: subclasses, value and cardinality
|
|
restrictions. In addition, OWL Lite allows properties to be made optional or
|
|
required (using the cardinality features).
|
|
The limitations on OWL Lite place it in a lower complexity class than OWL
|
|
DL. This can have a positive impact on the efficiency of complete reasoners
|
|
for OWL Lite. </p>
|
|
|
|
<p>Implementations that support only the OWL Lite vocabulary,
|
|
but otherwise relax the restrictions of OWL DL, cannot make certain
|
|
computational claims with respect to consistency and complexity.
|
|
However, such implementations may be useful in providing
|
|
interoperability of OWL systems with RDFS models, databases, markup tools, or
|
|
other non-reasoning tools.
|
|
The Web Ontology Working Group has not provided a name for this
|
|
potentially useful subset.
|
|
</p>
|
|
|
|
|
|
<h2><a name="appA" id="appA">Appendix A. Index of all language
|
|
elements</a></h2>
|
|
|
|
<p class="note">
|
|
NOTE: This appendix only contains the OWL-specific constructs. For the RDF/RDFS
|
|
constructs see the relevant RDF documentation, in particular the RDF Schema document
|
|
[<cite><a href="#ref-rdf-schema">RDF Schema</a></cite>].</p>
|
|
|
|
<table border="1">
|
|
<tr>
|
|
<th>[OWL Reference]<br />(this document)</th>
|
|
<th>[<cite><a href="#ref-abstract-syntax">OWL Semantics</a></cite>]<br />(normative)</th>
|
|
<th>[<cite><a href="#ref-guide">OWL Guide</a></cite>]<br />(examples)</th>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#AllDifferent-def">owl:AllDifferent</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/rdfs#owl_AllDifferent_rdf">owl:AllDifferent</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_AllDifferent">owl:AllDifferent</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#allValuesFrom-def">owl:allValuesFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_allValuesFrom_semantics">owl:allValuesFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_allValuesFrom">owl:allValuesFrom</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#backwardCompatibleWith-def">owl:backwardCompatibleWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/mapping#owl_backwardCompatibleWith_mapping">owl:backwardCompatibleWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_backwardCompatibleWith">owl:backwardCompatibleWith</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#cardinality-def">owl:cardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_cardinality_semantics">owl:cardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_cardinality">owl:cardinality</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_Class_semantics">owl:Class</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_Class">owl:Class</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#complementOf-def">owl:complementOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_complementOf_semantics">owl:complementOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_complementOf">owl:complementOf</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#EnumeratedDatatype">owl:DataRange</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#DatatypeProperty-def">owl:DatatypeProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_DatatypeProperty_semantics">owl:DatatypeProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_DatatypeProperty">owl:DatatypeProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#DeprecatedClass-def">owl:DeprecatedClass</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/#owl_DeprecatedClass">owl:DeprecatedClass</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_DeprecatedClass">owl:DeprecatedClass</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#DeprecatedProperty-def">owl:DeprecatedProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/#owl_DeprecatedProperty">owl:DeprecatedProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_DeprecatedProperty">owl:DeprecatedProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#differentFrom-def">owl:differentFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_differentFrom_semantics">owl:differentFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_differentFrom">owl:differentFrom</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#disjointWith-def">owl:disjointWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_disjointWith_semantics">owl:disjointWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_disjointWith">owl:disjointWith</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#distinctMembers-def">owl:distinctMembers</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/rdfs#owl_distinctMembers_rdf">owl:distinctMembers</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_distinctMembers">owl:distinctMembers</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#domain-def">rdfs:domain</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#FunctionalProperty-def">owl:FunctionalProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_FunctionalProperty_semantics">owl:FunctionalProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_FunctionalProperty">owl:FunctionalProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#hasValue-def">owl:hasValue</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_hasValue_semantics">owl:hasValue</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_hasValue">owl:hasValue</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#imports-def">owl:imports</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_imports_semantics">owl:imports</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_imports">owl:imports</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#incompatibleWith-def">owl:incompatibleWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/mapping#owl_incompatibleWith_mapping">owl:incompatibleWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_incompatibleWith">owl:incompatibleWith</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#intersectionOf-def">owl:intersectionOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_intersectionOf_semantics">owl:intersectionOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_intersectionOf">owl:intersectionOf</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#InverseFunctionalProperty-def">owl:InverseFunctionalProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_InverseFunctionalProperty_semantics">owl:InverseFunctionalProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_InverseFunctionalProperty">owl:InverseFunctionalProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#inverseOf-def">owl:inverseOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_inverseOf_semantics">owl:inverseOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_inverseOf">owl:inverseOf</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#maxCardinality-def">owl:maxCardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_maxCardinality_semantics">owl:maxCardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_maxCardinality">owl:maxCardinality</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#minCardinality-def">owl:minCardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_minCardinality_semantics">owl:minCardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_minCardinality">owl:minCardinality</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Nothing-def">owl:Nothing</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_Nothing_semantics">owl:Nothing</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_Nothing">owl:Nothing</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#ObjectProperty-def">owl:ObjectProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_ObjectProperty_semantics">owl:ObjectProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_ObjectProperty">owl:ObjectProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#oneOf-def">owl:oneOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_oneOf_semantics">owl:oneOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_oneOf">owl:oneOf</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#onProperty-def">owl:onProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_onProperty_semantics">owl:onProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_onProperty">owl:onProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_Ontology_semantics">owl:Ontology</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_Ontology">owl:Ontology</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#priorVersion-def">owl:priorVersion</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/mapping#owl_priorVersion_mapping">owl:priorVersion</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_priorVersion">owl:priorVersion</a></td>
|
|
</tr>
|
|
<tr>
|
|
<!-- <td><a href="#Property-def">rdf:Property</a></td> -->
|
|
<td>rdf:Property</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#range-def">rdfs:range</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_Restriction_semantics">owl:Restriction</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_Restriction">owl:Restriction</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#sameAs-def">owl:sameAs</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/rdfs#owl_sameAs_rdf">owl:sameAs</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_sameAs">owl:sameAs</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#equivalentClass-def">owl:equivalentClass</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_sameClassAs_semantics">owl:equivalentClass</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_equivalentClass">owl:equivalentClass</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#sameIndividualAs-def">owl:sameIndividualAs</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_sameIndividualAs_semantics">owl:sameIndividualAs</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_sameIndividualAs">owl:sameIndividualAs</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#equivalentProperty-def">owl:equivalentProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_samePropertyAs_semantics">owl:equivalentProperty</a>@</td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_equivalentProperty">owl:equivalentProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#someValuesFrom-def">owl:someValuesFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_someValuesFrom_semantics">owl:someValuesFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_someValuesFrom">owl:someValuesFrom</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#subClassOf-def">rdfs:subClassOf</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#subPropertyOf-def">rdfs:subPropertyOf</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#SymmetricProperty-def">owl:SymmetricProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_SymmetricProperty_semantics">owl:SymmetricProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_SymmetricProperty">owl:SymmetricProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Thing-def">owl:Thing</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_Thing_semantics">owl:Thing</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_Thing">owl:Thing</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#TransitiveProperty-def">owl:TransitiveProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_TransitiveProperty_semantics">owl:TransitiveProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_TransitiveProperty">owl:TransitiveProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#unionOf-def">owl:unionOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-semantics/direct#owl_unionOf_semantics">owl:unionOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/owl-guide/#owl_unionOf">owl:unionOf</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#versionInfo-def">owl:versionInfo</a></td>
|
|
<!-- <td><a href="http://www.w3.org/TR/owl-semantics/#owl_versionInfo">owl:versionInfo</a></td> -->
|
|
<td>owl:versionInfo </td>
|
|
<!-- <td><a href="http://www.w3.org/TR/owl-guide/#owl_versionInfo">owl:versionInfo</a></td> -->
|
|
<td>owl:versionInfo </td>
|
|
</tr>
|
|
</table>
|
|
|
|
<h2><a name="appB" id="appB"></a>Appendix B. RDF Schema of OWL (Normative)</h2>
|
|
|
|
<pre>
|
|
<?xml version="1.0"?>
|
|
<!DOCTYPE owl [
|
|
<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
|
|
<!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
|
|
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
|
|
<!ENTITY owl "http://www.w3.org/2002/07/owl#" >
|
|
]>
|
|
|
|
<rdf:RDF
|
|
xmlns ="&owl;"
|
|
xmlns:owl ="&owl;"
|
|
xml:base ="http://www.w3.org/2002/07/owl"
|
|
xmlns:rdf ="&rdf;"
|
|
xmlns:rdfs="&rdfs;"
|
|
xmlns:dc ="http://purl.org/dc/elements/1.1/"
|
|
>
|
|
|
|
<Ontology rdf:about="">
|
|
<versionInfo>March 18. 2003, GS</versionInfo>
|
|
<imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>
|
|
<dc:title>Classes and properties for the Web Ontology Language OWL</dc:title>
|
|
<dc:creator>W3C Web Ontology (WebOnt) Working Group</dc:creator>
|
|
<dc:subject>OWL; Web Ontology Language; Semantic Web</dc:subject>
|
|
<dc:description>This file specifies in RDF Schema format the
|
|
built-in classes and properties that together form the basis of
|
|
the RDF/XML syntax of OWL Full, OWL DL and OWL Lite with the help
|
|
of RDF Schema. We do not expect people to import this file
|
|
explicitly into their ontology. People that do import this file
|
|
should expect their ontology to be an OWL Full ontology.
|
|
</dc:description>
|
|
<dc:publisher>W3C</dc:publisher>
|
|
<dc:date>2003-02-10</dc:date>
|
|
<dc:format>text/xml</dc:format>
|
|
<dc:language>en</dc:language>
|
|
<dc:identifier>http://www.w3.org/2002/07/owl</dc:identifier>
|
|
</Ontology>
|
|
|
|
<rdfs:Class rdf:ID="Class">
|
|
<rdfs:label>Class</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="&rdfs;Class"/>
|
|
</rdfs:Class>
|
|
|
|
<Class rdf:ID="Thing">
|
|
<rdfs:label>Thing</rdfs:label>
|
|
<unionOf rdf:parseType="Collection">
|
|
<Class rdf:about="#Nothing"/>
|
|
<Class>
|
|
<complementOf rdf:resource="#Nothing"/>
|
|
</Class>
|
|
</unionOf>
|
|
</Class>
|
|
|
|
<Class rdf:ID="Nothing">
|
|
<rdfs:label>Nothing</rdfs:label>
|
|
<complementOf rdf:resource="#Thing"/>
|
|
</Class>
|
|
|
|
<rdf:Property rdf:ID="equivalentClass">
|
|
<rdfs:label>equivalentClass</rdfs:label>
|
|
<rdfs:subPropertyOf rdf:resource="&rdfs;subClassOf"/>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="disjointWith">
|
|
<rdfs:label>disjointWith</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="equivalentProperty">
|
|
<rdfs:label>equivalentProperty</rdfs:label>
|
|
<rdfs:subPropertyOf rdf:resource="&rdfs;subPropertyOf"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="sameIndividualAs">
|
|
<rdfs:label>sameIndividualAs</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Thing"/>
|
|
<rdfs:range rdf:resource="#Thing"/>
|
|
<rdfs:subPropertyOf rdf:resource="#sameAs"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="sameAs">
|
|
<rdfs:label>sameAs</rdfs:label>
|
|
<rdfs:subPropertyOf rdf:resource="#sameIndividualAs"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="differentFrom">
|
|
<rdfs:label>differentFrom</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Thing"/>
|
|
<rdfs:range rdf:resource="#Thing"/>
|
|
</rdf:Property>
|
|
|
|
<rdfs:Class rdf:ID="AllDifferent">
|
|
<rdfs:label>AllDifferent</rdfs:label>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="distinctMembers">
|
|
<rdfs:label>distinctMembers</rdfs:label>
|
|
<rdfs:domain rdf:resource="#AllDifferent"/>
|
|
<rdfs:range rdf:resource="&rdf;List"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="unionOf">
|
|
<rdfs:label>unionOf</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="&rdf;List"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="intersectionOf">
|
|
<rdfs:label>intersectionOf</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="&rdf;List"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="complementOf">
|
|
<rdfs:label>complementOf</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="#Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="oneOf">
|
|
<rdfs:label>oneOf</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Class"/>
|
|
<rdfs:range rdf:resource="&rdf;List"/>
|
|
</rdf:Property>
|
|
|
|
<rdfs:Class rdf:ID="Restriction">
|
|
<rdfs:label>Restriction</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="#Class"/>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="onProperty">
|
|
<rdfs:label>onProperty</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="&rdf;Property"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="allValuesFrom">
|
|
<rdfs:label>allValuesFrom</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="&rdfs;Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="hasValue">
|
|
<rdfs:label>hasValue</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="someValuesFrom">
|
|
<rdfs:label>someValuesFrom</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="&rdfs;Class"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="minCardinality">
|
|
<rdfs:label>minCardinality</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="maxCardinality">
|
|
<rdfs:label>maxCardinality</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="cardinality">
|
|
<rdfs:label>cardinality</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Restriction"/>
|
|
<rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
|
|
</rdf:Property>
|
|
|
|
<rdfs:Class rdf:ID="ObjectProperty">
|
|
<rdfs:label>ObjectProperty</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="DatatypeProperty">
|
|
<rdfs:label>DatatypeProperty</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="inverseOf">
|
|
<rdfs:label>inverseOf</rdfs:label>
|
|
<rdfs:domain rdf:resource="#ObjectProperty"/>
|
|
<rdfs:range rdf:resource="#ObjectProperty"/>
|
|
</rdf:Property>
|
|
|
|
<rdfs:Class rdf:ID="TransitiveProperty">
|
|
<rdfs:label>TransitiveProperty</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="#ObjectProperty"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="SymmetricProperty">
|
|
<rdfs:label>SymmetricProperty</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="#ObjectProperty"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="FunctionalProperty">
|
|
<rdfs:label>FunctionalProperty</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="InverseFunctionalProperty">
|
|
<rdfs:label>InverseFunctionalProperty</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="AnnotationProperty">
|
|
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Description rdf:about="&rdfs;label">
|
|
<rdf:type rdf:resource="#AnnotationProperty"/>
|
|
</rdf:Description>
|
|
|
|
<rdf:Description rdf:about="&rdfs;comment">
|
|
<rdf:type rdf:resource="#AnnotationProperty"/>
|
|
</rdf:Description>
|
|
|
|
<rdf:Description rdf:about="&rdfs;seeAlso">
|
|
<rdf:type rdf:resource="#AnnotationProperty"/>
|
|
</rdf:Description>
|
|
|
|
<rdf:Description rdf:about="&rdfs;isDefinedBy">
|
|
<rdf:type rdf:resource="#AnnotationProperty"/>
|
|
</rdf:Description>
|
|
|
|
<rdfs:Class rdf:ID="Ontology">
|
|
<rdfs:label>Ontology</rdfs:label>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="imports">
|
|
<rdfs:label>imports</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Ontology"/>
|
|
<rdfs:range rdf:resource="#Ontology"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="versionInfo">
|
|
<rdfs:label>versionInfo</rdfs:label>
|
|
<rdf:type rdf:resource="#AnnotationProperty"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="priorVersion">
|
|
<rdfs:label>priorVersion</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Ontology"/>
|
|
<rdfs:range rdf:resource="#Ontology"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="backwardCompatibleWith">
|
|
<rdfs:label>backwardCompatibleWith</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Ontology"/>
|
|
<rdfs:range rdf:resource="#Ontology"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="incompatibleWith">
|
|
<rdfs:label>incompatibleWith</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Ontology"/>
|
|
<rdfs:range rdf:resource="#Ontology"/>
|
|
</rdf:Property>
|
|
|
|
<rdfs:Class rdf:ID="DeprecatedClass">
|
|
<rdfs:label>DeprecatedClass</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="&rdfs;Class"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="DeprecatedProperty">
|
|
<rdfs:label>DeprecatedProperty</rdfs:label>
|
|
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="DataRange">
|
|
<rdfs:label>DataRange</rdfs:label>
|
|
</rdfs:Class>
|
|
|
|
|
|
</rdf:RDF>
|
|
</pre>
|
|
|
|
|
|
|
|
<h2><a name="appC" id="appC"></a>Appendix C.
|
|
OWL Quick Reference</h2>
|
|
|
|
Classes defined by OWL:
|
|
|
|
<table border="1">
|
|
<tr>
|
|
<th>rdfs:Class</th>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#AllDifferent-def">owl:AllDifferent</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#DatatypeProperty-def">owl:DatatypeProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#DeprecatedClass-def">owl:DeprecatedClass</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#DeprecatedProperty-def">owl:DeprecatedProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#FunctionalProperty-def">owl:FunctionalProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#InverseFunctionalProperty-def">owl:InverseFunctionalProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Nothing-def">owl:Nothing</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#ObjectProperty-def">owl:ObjectProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#SymmetricProperty-def">owl:SymmetricProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Thing-def">owl:Thing</a></td>
|
|
</tr>
|
|
</table>
|
|
|
|
<p />
|
|
Properties defined by OWL:
|
|
|
|
<table border="1">
|
|
<tr>
|
|
<th>rdf:Property</th>
|
|
<th>rdfs:domain</th>
|
|
<th>rdfs:range</th>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#allValuesFrom-def">owl:allValuesFrom</a></td>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td>rdfs:Class</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#backwardCompatibleWith-def">owl:backwardCompatibleWith</a></td>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#cardinality-def">owl:cardinality</a></td>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td>xsd:nonNegativeInteger</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#complementOf-def">owl:complementOf</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#differentFrom-def">owl:differentFrom</a></td>
|
|
<td><a href="#Thing-def">owl:Thing</a></td>
|
|
<td><a href="#Thing-def">owl:Thing</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#disjointWith-def">owl:disjointWith</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#distinctMembers-def">owl:distinctMembers</a></td>
|
|
<td><a href="#AllDifferent-def">owl:AllDifferent</a></td>
|
|
<td>rdf:List</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#equivalentClass-def">owl:equivalentClass</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#equivalentProperty-def">owl:equivalentProperty</a></td>
|
|
<td>rdf:Property</td>
|
|
<td>rdf:Property</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#hasValue-def">owl:hasValue</a></td>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#imports-def">owl:imports</a></td>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
<td></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#incompatibleWith-def">owl:incompatibleWith</a></td>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#intersectionOf-def">owl:intersectionOf</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
<td>rdf:List</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#inverseOf-def">owl:inverseOf</a></td>
|
|
<td><a href="#ObjectProperty-def">owl:ObjectProperty</a></td>
|
|
<td><a href="#ObjectProperty-def">owl:ObjectProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#maxCardinality-def">owl:maxCardinality</a></td>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td>xsd:nonNegativeInteger</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#minCardinality-def">owl:minCardinality</a></td>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td>xsd:nonNegativeInteger</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#oneOf-def">owl:oneOf</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
<td>rdf:List</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#onProperty-def">owl:onProperty</a></td>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td>rdf:Property</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#priorVersion-def">owl:priorVersion</a></td>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
<td><a href="#Ontology-def">owl:Ontology</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#sameAs-def">owl:sameAs</a></td>
|
|
<td><a href="#Thing-def">owl:Thing</a></td>
|
|
<td><a href="#Thing-def">owl:Thing</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#sameIndividualAs-def">owl:sameIndividualAs</a></td>
|
|
<td><a href="#Thing-def">owl:Thing</a></td>
|
|
<td><a href="#Thing-def">owl:Thing</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#someValuesFrom-def">owl:someValuesFrom</a></td>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td>rdfs:Class</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#unionOf-def">owl:unionOf</a></td>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
<td>rdf:List</td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#versionInfo-def">owl:versionInfo</a></td>
|
|
<td></td>
|
|
<td></td>
|
|
</tr>
|
|
</table>
|
|
|
|
<h2><a name="appD" id="appD"></a>Appendix D.
|
|
Changes from DAML+OIL</h2>
|
|
|
|
<p>This section summarizes the changes from
|
|
DAML+OIL
|
|
[<cite><a href="#ref-daml">DAML+OIL</a></cite>]
|
|
to OWL.
|
|
</p>
|
|
|
|
<ol>
|
|
<li>The semantics have changed significantly. With respect to the three
|
|
sublanguages, the DAML+OWL semantics is closests to the OWL DL semantics. </li>
|
|
<li>The namespace was changed to
|
|
<a href="http://www.w3.org/2002/07/owl">http://www.w3.org/2002/07/owl</a>.
|
|
</li>
|
|
<li>Various updates to RDF and RDF Schema from the
|
|
<a href="http://www.w3.org/2001/sw/RDFCore/">RDF Core Working Group</a>
|
|
were incorporated,
|
|
including
|
|
<ul>
|
|
<li>cyclic subclasses are now allowed</li>
|
|
<li>multiple
|
|
<code>rdfs:domain</code>
|
|
and
|
|
<code>rdfs:range</code>
|
|
properties are handled as intersection</li>
|
|
<li><a href="http://www.w3.org/TR/rdf-syntax-grammar/#section-Syntax-parsetype-Collection">rdf:parseType="Collection"</a>
|
|
replaces
|
|
<code>rdf:parseType="daml:collection"</code></li>
|
|
<li>RDF Semantics [<cite><a href="#ref-rdf-mt">RDF Semantics</a></cite>]</li>
|
|
<li><a href="http://www.w3.org/TR/rdf-concepts/#section-Datatypes">datatypes</a>
|
|
<ul>
|
|
<li>RDF and OWL use the XML Schema namespace
|
|
<a href="http://www.w3.org/2001/XMLSchema">http://www.w3.org/2001/XMLSchema</a>
|
|
rather than
|
|
<a href="http://www.w3.org/2000/10/XMLSchema">http://www.w3.org/2000/10/XMLSchema</a>.</li>
|
|
<li>OWL does not support using datatypes as types, e.g.
|
|
<pre>
|
|
<size>
|
|
<xsd:integer rdf:value="10"/>
|
|
</size>
|
|
</pre>
|
|
Instead use
|
|
<pre>
|
|
<size
|
|
rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">10</size>
|
|
</pre>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
|
|
<li>Qualified restrictions were removed from the language,
|
|
resulting in the removal of the following properties:
|
|
<ul>
|
|
<li><code>daml:cardinalityQ</code></li>
|
|
<li><code>daml:hasClassQ</code></li>
|
|
<li><code>daml:maxCardinalityQ</code></li>
|
|
<li><code>daml:minCardinalityQ</code></li>
|
|
</ul>
|
|
</li>
|
|
|
|
<li>Various properties and classes were renamed,
|
|
as shown in the following table:
|
|
<table border="1">
|
|
<tr>
|
|
<th>DAML+OIL</th>
|
|
<th>OWL</th>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:differentIndividualFrom</code></td>
|
|
<td><code><a href="#differentFrom-def">owl:differentFrom</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:equivalentTo</code></td>
|
|
<td><code><a href="#sameAs-def">owl:sameAs</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:sameClassAs</code></td>
|
|
<td><code><a href="#equivalentClass-def">owl:equivalentClass</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:samePropertyAs</code></td>
|
|
<td><code><a href="#equivalentProperty-def">owl:equivalentProperty</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:hasClass</code></td>
|
|
<td><code><a href="#someValuesFrom-def">owl:someValuesFrom</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:sameClassAs</code></td>
|
|
<td><code><a href="#equivalentClass-def">owl:equivalentClass</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:samePropertyAs</code></td>
|
|
<td><code><a href="#equivalentProperty-def">owl:equivalentProperty</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:toClass</code></td>
|
|
<td><code><a href="#allValuesFrom-def">owl:allValuesFrom</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:UnambiguousProperty</code></td>
|
|
<td><code><a href="#InverseFunctionalProperty-def">owl:InverseFunctionalProperty</a></code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>daml:UniqueProperty</code></td>
|
|
<td><code><a href="#FunctionalProperty-def">owl:FunctionalProperty</a></code></td>
|
|
</tr>
|
|
</table>
|
|
</li>
|
|
|
|
<li>
|
|
<code><a href="#SymmetricProperty-def">owl:SymmetricProperty</a></code>
|
|
was added.
|
|
</li>
|
|
|
|
<li>An
|
|
<code><a href="#DatatypeProperty-def">owl:DatatypeProperty</a></code>
|
|
may be an
|
|
<code><a href="#InverseFunctionalProperty-def">owl:InverseFunctionalProperty</a></code>
|
|
in OWL Full.
|
|
</li>
|
|
|
|
<li>
|
|
Synonyms for RDF and RDF Schema classes and properties were removed from the language,
|
|
resulting in the removal of:
|
|
<ul>
|
|
<li><code>daml:comment</code></li>
|
|
<li><code>daml:domain</code></li>
|
|
<li><code>daml:label</code></li>
|
|
<li><code>daml:isDefinedBy</code></li>
|
|
<li><code>daml:Literal</code></li>
|
|
<li><code>daml:Property</code></li>
|
|
<li><code>daml:range</code></li>
|
|
<li><code>daml:seeAlso</code></li>
|
|
<li><code>daml:subClassOf</code></li>
|
|
<li><code>daml:subPropertyOf</code></li>
|
|
<li><code>daml:type</code></li>
|
|
<li><code>daml:value</code></li>
|
|
</ul>
|
|
</li>
|
|
|
|
<li>
|
|
<code>daml:disjointUnionOf</code>
|
|
was removed from the language,
|
|
since it can be effected using
|
|
<code><a href="#unionOf-def">owl:unionOf</a></code>
|
|
or
|
|
<code><a href="#subClassOf-def">rdfs:subClassOf</a></code>
|
|
and
|
|
<code><a href="#disjointWith-def">owl:disjointWith</a></code>.
|
|
</li>
|
|
|
|
<li>
|
|
<code>daml:equivalentTo</code>
|
|
was renamed to
|
|
<code><a href="#sameAs-def">owl:sameAs</a></code>,
|
|
and is no longer a superproperty of
|
|
<code><a href="#equivalentClass-def">owl:equivalentClass</a></code>,
|
|
<code><a href="#equivalentProperty-def">owl:equivalentProperty</a></code>,
|
|
and
|
|
<code><a href="#sameIndividualAs-def">owl:sameIndividualAs</a></code>
|
|
</li>
|
|
<li>
|
|
The following properties and classes were added to support versioning:
|
|
<ul>
|
|
<li><a href="#backwardCompatibleWith-def">owl:backwardCompatibleWith</a></li>
|
|
<li><a href="#DeprecatedClass-def">owl:DeprecatedClass</a></li>
|
|
<li><a href="#DeprecatedProperty-def">owl:DeprecatedProperty</a></li>
|
|
<li><a href="#incompatibleWith-def">owl:incompatibleWith</a></li>
|
|
<li><a href="#priorVersion-def">owl:priorVersion</a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#AllDifferent-def">owl:AllDifferent</a>
|
|
and
|
|
<a href="#distinctMembers-def">owl:distinctMembers</a>
|
|
were added to address the
|
|
Unique Names Assumption.
|
|
</li>
|
|
</ol>
|
|
|
|
<hr />
|
|
|
|
<h2><a id="References" name="References">References</a></h2>
|
|
|
|
<dl>
|
|
|
|
<dt><a id="ref-daml">[DAML+OIL]</a></dt>
|
|
<dd>
|
|
<cite>
|
|
<a href="http://www.w3.org/TR/2001/NOTE-daml+oil-reference-20011218">
|
|
DAML+OIL (March 2001) Reference Description</a></cite>.
|
|
Dan Connolly, Frank van Harmelen, Ian Horrocks,
|
|
Deborah L. McGuinness, Peter F. Patel-Schneider, and Lynn Andrea Stein.
|
|
W3C Note 18 December 2001.
|
|
<a href="http://www.w3.org/TR/daml+oil-reference">Latest version</a>
|
|
is available at
|
|
<code>http://www.w3.org/TR/daml+oil-reference</code>.
|
|
</dd>
|
|
|
|
<dt><a id="Hendler02">[Hendler <em>et al,</em>, 2002]</a></dt>
|
|
<dd>
|
|
Hendler, James, Berners-Lee, Tim and Miller, Eric "Integrating
|
|
Applications on the Semantic Web," Journal of the Institute of
|
|
Electrical Engineers of Japan, Vol 122(10), October, 2002, p.
|
|
676-680. available in English at
|
|
<a href="http://www.w3.org/2002/07/swint">http://www.w3.org/2002/07/swint</a>
|
|
</dd>
|
|
|
|
<dt><a id="ref-abstract-syntax">[OWL S&AS]</a></dt>
|
|
<dd>
|
|
<span class="draftedit"><cite><a
|
|
href="http://www.w3.org/TR/2003/WD-owl-semantics-20030203/">Web Ontology
|
|
Language (OWL) Semantics and Abstract Syntax</a></cite></span>.
|
|
Peter F. Patel-Schneider, Patrick Hayes, and Ian Horrocks, eds.
|
|
W3C Working Draft <span class="draftedit">3 February 2003</span>.
|
|
<a href="http://www.w3.org/TR/owl-semantics/">Latest version</a> is available at
|
|
<code>http://www.w3.org/TR/owl-semantics/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-overview">[OWL Overview]</a></dt>
|
|
<dd>
|
|
<span class="draftedit"><cite><a href="http://www.w3.org/TR/2002/WD-owl-features-20020729/">Web Ontology Language (OWL Lite and OWL) Feature Synopsis Version 1.0</a></cite></span>.
|
|
Deborah L. McGuinness and Frank van Harmelen, eds.
|
|
W3C Working Draft <span class="draftedit">29 Jul 2002</span>.
|
|
<a href="http://www.w3.org/TR/owl-features/">Latest version</a> is available at
|
|
<code>http://www.w3.org/TR/owl-features/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-guide">[OWL Guide]</a></dt>
|
|
<dd>
|
|
<span class="draftedit"><cite><a href="http://www.w3.org/TR/2002/WD-owl-guide-20021104/">Web Ontology Language (OWL) Guide Version 1.0</a></cite></span>.
|
|
Michael K. Smith, Christopher Welty, Raphael Volz, and Deborah McGuinness.
|
|
W3C Working Draft <span class="draftedit">4 November 2002</span>.
|
|
<a href="http://www.w3.org/TR/owl-guide/">Latest version</a> is available at
|
|
<code>http://www.w3.org/TR/owl-guide/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-requirements">[OWL Use Cases and Requirements]</a></dt>
|
|
<dd>
|
|
<span class="draftedit"><cite><a href="http://www.w3.org/TR/2003/WD-webont-req-20030203/">Web Ontology Language (OWL) Use Cases and Requirements</a></cite></span>.
|
|
Jeff Heflin, ed.
|
|
W3C Working Draft <span class="draftedit">3 February 2003</span>.
|
|
<a href="http://www.w3.org/TR/webont-req/">Latest version</a> is available at
|
|
<code>http://www.w3.org/TR/webont-req/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-test-cases">[OWL Test Cases]</a></dt>
|
|
<dd>
|
|
<span class="draftedit"><cite><a href="http://www.w3.org/TR/2002/WD-owl-test-20021024/">Web Ontology Language (OWL) Test Cases</a></cite></span>.
|
|
Jeremy J. Carroll and Jos De Roo, eds.
|
|
W3C Working Draft <span class="draftedit">24 October 2002</span>.
|
|
<a href="http://www.w3.org/TR/owl-test/">Latest version</a> is available at
|
|
<code>http://www.w3.org/TR/owl-test/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-rdf-concepts">[RDF Concepts]</a></dt>
|
|
<dd>
|
|
<cite><a href="http://www.w3.org/TR/2003/WD-rdf-concepts-20030123/">
|
|
Resource Description Framework (RDF): Concepts and Abstract Syntax</a></cite>.
|
|
Graham Klyne and Jeremy J. Carroll, eds.
|
|
W3C Working Draft 23 January 2003.
|
|
<a href="http://www.w3.org/TR/rdf-concepts/">Latest version</a>
|
|
is available at
|
|
<code>http://www.w3.org/TR/rdf-concepts/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-rdf-schema">[RDF Schema]</a></dt>
|
|
<dd>
|
|
<cite><a href="http://www.w3.org/TR/2003/WD-rdf-schema-20030123/">
|
|
RDF Vocabulary Description Language 1.0: RDF Schema</a></cite>.
|
|
Dan Brickley and R.V. Guha, eds.
|
|
W3C Working Draft 23 January 2003.
|
|
<a href="http://www.w3.org/TR/rdf-schema/">Latest version</a>
|
|
is available at
|
|
<code>http://www.w3.org/TR/rdf-schema/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-rdf-mt">[RDF Semantics]</a></dt>
|
|
<dd>
|
|
<cite><a href="http://www.w3.org/TR/2003/WD-rdf-mt-20030123/">
|
|
RDF Semantics</a></cite>.
|
|
Patrick Hayes, ed.
|
|
W3C Working Draft 23 January 2003.
|
|
<a href="http://www.w3.org/TR/rdf-mt/">Latest version</a>
|
|
is available at
|
|
<code>http://www.w3.org/TR/rdf-mt/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-rdf-xml-syntax">[RDF/XML Syntax]</a></dt>
|
|
<dd>
|
|
<cite><a href="http://www.w3.org/TR/2003/WD-rdf-syntax-grammar-20030123/">
|
|
RDF/XML Syntax Specification (Revised)</a></cite>.
|
|
Dave Beckett, ed.
|
|
W3C Working Draft 23 January 2003.
|
|
<a href="http://www.w3.org/TR/rdf-syntax-grammar/">Latest version</a>
|
|
is available at
|
|
<code>http://www.w3.org/TR/rdf-syntax-grammar/</code>.
|
|
</dd>
|
|
|
|
<dt><a id="ref-xml-schema2" name="ref-xml-schema2"></a>[XML-SCHEMA2]
|
|
</dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/xmlschema-2/">XML Schema
|
|
Part 2: Datatypes - W3C Recommendation</a></cite>, World Wide Web
|
|
Consortium, 2 May 2001.
|
|
</dd>
|
|
|
|
</dl>
|
|
|
|
</body>
|
|
</html>
|