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.
4831 lines
190 KiB
4831 lines
190 KiB
<?xml version="1.0" encoding="utf-8" ?>
|
|
<!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.10 2009/11/13 14:31:49 bertails Exp $"/>
|
|
<style type="text/css">
|
|
.issue {background-color: yellow}
|
|
.postponedissue {background-color: yellow}
|
|
.def code
|
|
.code {
|
|
background: #dde;
|
|
margin-left: 20px;
|
|
padding-left: 10px;
|
|
width: auto;
|
|
border: 1px solid #aaa;
|
|
}
|
|
.draftedit {background-color: white}
|
|
.draftdelete {background-color: white}
|
|
.note { margin-left: 4em }
|
|
</style>
|
|
<style type="text/css">
|
|
.PrePublicationWarning {
|
|
font-weight: bold;
|
|
margin: 1em 0em;
|
|
border: medium double black;
|
|
background: yellow;
|
|
padding: 1em;
|
|
}
|
|
</style>
|
|
|
|
<link href="http://www.w3.org/StyleSheets/TR/W3C-REC.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><a id="w3c-doctype" name="w3c-doctype"></a>
|
|
W3C Recommendation 10 February 2004</h2>
|
|
|
|
<div id="owl_2_notice" style="border: solid black 1px; padding: 0.5em; background: #FFB;">
|
|
|
|
<p style="margin-top: 0; font-weight: bold;">New Version
|
|
Available: OWL 2 <span style="padding-left: 2em;"></span>
|
|
(Document Status Update, 12 November 2009)</p>
|
|
|
|
<p style="margin-bottom: 0;">The OWL Working Group has produced
|
|
a W3C Recommendation for a new version of OWL which adds
|
|
features to this 2004 version, while remaining compatible.
|
|
Please see <a href="http://www.w3.org/TR/owl2-overview">OWL 2
|
|
Document Overview</a> for an introduction to OWL 2 and a guide
|
|
to the OWL 2 document set.</p>
|
|
|
|
</div>
|
|
|
|
|
|
|
|
<dl>
|
|
<dt>This version: </dt>
|
|
<dd><a href="http://www.w3.org/TR/2004/REC-owl-ref-20040210/">
|
|
http://www.w3.org/TR/2004/REC-owl-ref-20040210/</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/PR-owl-ref-20031215/">
|
|
http://www.w3.org/TR/2003/PR-owl-ref-20031215/</a></dd>
|
|
|
|
<dt>Editors:</dt>
|
|
|
|
<dd>
|
|
<a href="http://www.daml.org/people/mdean/">Mike Dean</a>,
|
|
BBN Technologies<br/>
|
|
<a href="http://www.cs.vu.nl/~guus/">Guus Schreiber</a>,
|
|
Free University Amsterdam<br/>
|
|
</dd>
|
|
|
|
<dt>Authors:</dt>
|
|
|
|
<dd>
|
|
<a href="http://www.cs.man.ac.uk/~seanb/">Sean Bechhofer</a>,
|
|
University of Manchester<br/>
|
|
<a href="http://www.cs.vu.nl/~frankh/"> Frank van Harmelen</a>,
|
|
Free University Amsterdam<br/>
|
|
<a href="http://www.cs.umd.edu/users/hendler/">Jim Hendler</a>,
|
|
University of Maryland<br/>
|
|
<a href="http://www.cs.man.ac.uk/~horrocks/">Ian Horrocks</a>,
|
|
University of Manchester<br/>
|
|
<a href="http://www.ksl.stanford.edu/people/dlm/">Deborah L.
|
|
McGuinness</a>, Stanford University<br/>
|
|
<a href="http://www.bell-labs.com/user/pfps/">Peter F.
|
|
Patel-Schneider</a>, Bell Labs Research, Lucent Technologies<br/>
|
|
<a href="http://faculty.olin.edu/~las/">Lynn Andrea Stein</a>,
|
|
Franklin W. Olin College of Engineering<br/>
|
|
</dd>
|
|
</dl>
|
|
|
|
|
|
<p>Please refer to the <a
|
|
href="http://www.w3.org/2001/sw/WebOnt/errata#owl-ref"><strong>errata</strong></a>
|
|
for this document, which may include some normative corrections.</p>
|
|
|
|
<p>See also <a href="http://www.w3.org/2001/sw/RDFCore/translation/owl-ref">translations</a>.</p>
|
|
|
|
<p class="copyright"><a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright"> Copyright</a> © 2004 <a href="http://www.w3.org/"><acronym title="World Wide Web Consortium">W3C</acronym></a><sup>®</sup> (<a href="http://www.csail.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>
|
|
|
|
<h2><a id="status" name="status">Status of this document</a></h2>
|
|
|
|
<!-- Start Status-Of-This-Document Text -->
|
|
|
|
<p>This document has been reviewed by W3C Members and other interested
|
|
parties, and it has been endorsed by the Director as a <a
|
|
href="http://www.w3.org/2003/06/Process-20030618/tr.html#RecsW3C">W3C
|
|
Recommendation</a>. W3C's role in making the Recommendation is to
|
|
draw attention to the specification and to promote its widespread
|
|
deployment. This enhances the functionality and interoperability of
|
|
the Web.</p>
|
|
|
|
<p>This is one of <a
|
|
href="http://www.w3.org/TR/2004/REC-owl-features-20040210/#s1.1">six
|
|
parts</a> of the W3C Recommendation for OWL, the Web Ontology
|
|
Language. It has been developed by the <a
|
|
href="http://www.w3.org/2001/sw/WebOnt/">Web Ontology Working
|
|
Group</a> 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
|
|
href="http://www.w3.org/2001/sw/WebOnt/charter">Group Charter</a>) for
|
|
publication on 10 February 2004. </p>
|
|
|
|
<p>The design of OWL expressed in earlier versions of these documents
|
|
has been widely reviewed and satisfies the Working Group's <a
|
|
href="http://www.w3.org/TR/webont-req/"> technical requirements</a>.
|
|
The Working Group has addressed <a
|
|
href="http://lists.w3.org/Archives/Public/public-webont-comments/">
|
|
all comments received</a>, making changes as necessary. Changes to
|
|
this document since <a
|
|
href="http://www.w3.org/TR/2003/PR-owl-ref-20031215/">the Proposed
|
|
Recommendation version</a> are detailed in the <a
|
|
href="./#changes-since-PR">change log</a>.</p>
|
|
|
|
<p>Comments are welcome at <a
|
|
href="mailto:public-webont-comments@w3.org">public-webont-comments@w3.org</a>
|
|
(<a
|
|
href="http://lists.w3.org/Archives/Public/public-webont-comments/">archive</a>)
|
|
and general discussion of related technology is welcome at <a
|
|
href="mailto:www-rdf-logic@w3.org">www-rdf-logic@w3.org</a> (<a
|
|
href="http://lists.w3.org/Archives/Public/www-rdf-logic/"
|
|
shape="rect">archive</a>).
|
|
</p>
|
|
|
|
<p>A list of <a href="http://www.w3.org/2001/sw/WebOnt/impls">
|
|
implementations</a> is available.</p>
|
|
|
|
<p>The W3C maintains a list of <a
|
|
href="http://www.w3.org/2001/sw/WebOnt/discl" rel="disclosure">any
|
|
patent disclosures related to this work</a>.
|
|
</p>
|
|
|
|
<p><em>This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the <a href="http://www.w3.org/TR/">W3C technical reports index</a> at http://www.w3.org/TR/.</em></p>
|
|
|
|
<!-- End Status-Of-This-Document Text -->
|
|
|
|
|
|
<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 participants in this Working Group included:
|
|
Yasser alSafadi,
|
|
Jean-François Baget,
|
|
James Barnette,
|
|
Sean Bechhofer,
|
|
Jonathan Borden,
|
|
Frederik Brysse,
|
|
Stephen Buswell,
|
|
Jeremy Carroll,
|
|
Dan Connolly,
|
|
Peter Crowther,
|
|
Jonathan Dale,
|
|
Jos De Roo,
|
|
David De Roure,
|
|
Mike Dean,
|
|
Larry Eshelman,
|
|
Jérôme Euzenat,
|
|
Tim Finin,
|
|
Nicholas Gibbins,
|
|
Sandro Hawke,
|
|
Patrick Hayes,
|
|
Jeff Heflin,
|
|
Ziv Hellman,
|
|
James Hendler,
|
|
Bernard Horan,
|
|
Masahiro Hori,
|
|
Ian Horrocks,
|
|
Jane Hunter,
|
|
Francesco Iannuzzelli,
|
|
Rüdiger Klein,
|
|
Natasha Kravtsova,
|
|
Ora Lassila,
|
|
Massimo Marchiori,
|
|
Deborah McGuinness,
|
|
Enrico Motta,
|
|
Leo Obrst,
|
|
Mehrdad Omidvari,
|
|
Martin Pike,
|
|
Marwan Sabbouh,
|
|
Guus Schreiber,
|
|
Noboru Shimizu,
|
|
Michael Sintek,
|
|
Michael K. Smith,
|
|
John Stanton,
|
|
Lynn Andrea Stein,
|
|
Herman ter Horst,
|
|
David Trastour,
|
|
Frank van Harmelen,
|
|
Bernard Vatant,
|
|
Raphael Volz,
|
|
Evan Wallace,
|
|
Christopher Welty,
|
|
Charles White,
|
|
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. Introduction</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">3.1.2.1.1
|
|
owl:allValuesFrom</a></li>
|
|
<li><a href="#someValuesFrom-def">3.1.2.1.2
|
|
owl:someValuesFrom</a></li>
|
|
<li><a href="#hasValue-def">3.1.2.1.3
|
|
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">3.1.2.2.1
|
|
owl:maxCardinality</a></li>
|
|
<li><a href="#minCardinality-def">3.1.2.2.2
|
|
owl:minCardinality</a></li>
|
|
<li><a href="#cardinality-def">3.1.2.2.3
|
|
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">3.1.3.1
|
|
owl:intersectionOf</a></li>
|
|
<li><a href="#unionOf-def">3.1.3.2 owl:unionOf</a></li>
|
|
<li><a href="#complementOf-def">3.1.3.3
|
|
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">4.1.1 rdfs:subPropertyOf</a></li>
|
|
<li><a href="#domain-def">4.1.2 rdfs:domain</a></li>
|
|
<li><a href="#range-def">4.1.3 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">4.2.1
|
|
owl:equivalentProperty</a></li>
|
|
<li><a href="#inverseOf-def">4.2.2 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">4.3.1
|
|
owl:FunctionalProperty</a></li>
|
|
<li><a href="#InverseFunctionalProperty-def">4.3.2
|
|
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">4.4.1
|
|
owl:TransitiveProperty</a></li>
|
|
<li><a href="#SymmetricProperty-def">4.4.2
|
|
owl:SymmetricProperty</a></li>
|
|
</ul></li>
|
|
</ul></li>
|
|
<li><a href="#Individual">5. Individuals</a>
|
|
<ul class="toc">
|
|
<li><a href="#IndividualAxiom">5.1 Class membership and property values</a></li>
|
|
<li><a href="#IndividualIdentity">5.2 Individual identity</a>
|
|
<ul class="toc">
|
|
<li><a href="#sameAs-def">5.2.1 owl:sameAs</a></li>
|
|
<li><a href="#differentFrom-def">5.2.2 owl:differentFrom</a></li>
|
|
<li><a href="#AllDifferent-def">5.2.3 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">7.4.1 owl:versionInfo</a></li>
|
|
<li><a href="#priorVersion-def">7.4.2 owl:priorVersion</a></li>
|
|
<li><a href="#backwardCompatibleWith-def">7.4.3
|
|
owl:backwardCompatibleWith</a></li>
|
|
<li><a href="#incompatibleWith-def">7.4.4
|
|
owl:incompatibleWith</a></li>
|
|
<li><a href="#Deprecation">7.4.5 owl:DeprecatedClass and
|
|
owl:DeprecatedProperty</a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#Sublanguage-def">8. OWL Full, OWL DL and OWL Lite</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>Appendix E: <a href="#app-DLinRDF">Rules of Thumb for OWL DL ontologies
|
|
</a></li>
|
|
<li>Appendix F: <a href="#changes-since-PR">Change Log since PR</a></li>
|
|
<li><a href="#References">References</a></li>
|
|
</ul>
|
|
|
|
|
|
<hr/>
|
|
|
|
<h2><a name="Intro"></a>1. Introduction</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. </p>
|
|
|
|
<p>
|
|
This document is one component of the description of OWL, the Web Ontology
|
|
Language, being produced by the W3C Web Ontology Working Group.
|
|
The <a href="http://www.w3.org/TR/2004/REC-owl-features-20040210/#s1.1">Document Roadmap</a> section
|
|
of the OWL Overview document describes each of the different parts
|
|
and how they fit together.
|
|
Readers
|
|
unfamiliar with OWL may wish to first consult the OWL Overview
|
|
document
|
|
[<cite><a href="#ref-OWL-Overview">OWL Overview</a></cite>],
|
|
and subsequently the OWL Guide
|
|
[<cite><a href="#ref-owl-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-syntax">RDF/XML Syntax</a></cite>] and of RDF
|
|
Schema [<cite><a href="#ref-rdf-vocabulary">RDF Vocabulary</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-owl-abstract-syntax">OWL S&AS</a></cite>].
|
|
That
|
|
document also contains a precise definition of the meaning of the
|
|
language constructs in the form of a model-theoretic
|
|
semantics.
|
|
Notions such as consistency of OWL ontologies
|
|
are discussed in that document. </p>
|
|
|
|
<p>Use cases and requirements for the OWL language are described in the OWL
|
|
requirements document
|
|
[<cite><a href="#ref-owl-requirements">OWL Requirements</a></cite>].
|
|
Test cases for OWL tools (<em>e.g.</em>, entailment tests, consistency tests)
|
|
are specified in the Test document
|
|
[<cite><a href="#ref-owl-test">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-OWL-Overview">OWL Overview</a></cite>],
|
|
and subsequently the OWL Guide
|
|
[<cite><a href="#ref-owl-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 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>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-owl-abstract-syntax">OWL S&AS</a></cite>].
|
|
<a href="#OWLDL">Sec. 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
|
|
<a href="#OWLLite">Sec. 8.3</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-owl-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 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>
|
|
|
|
<p class="note">
|
|
NOTE: OWL Lite is defined in this document as a number of additional
|
|
restrictions on OWL DL. This
|
|
mean that, OWL DL constructs are also part of OWL Lite, unless
|
|
explicitly stated otherwise.
|
|
<a href="#OWLLite">Sec. 8.3</a>.provides a summary of these additional
|
|
OWL Lite restrictions.</p>
|
|
|
|
|
|
<h3><a name="Syntax"></a>1.3 OWL syntax </h3>
|
|
|
|
<p>
|
|
An OWL ontology is 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-syntax">RDF/XML Syntax</a></cite>]).
|
|
The current document
|
|
uses some specific syntactic forms of RDF/XML for representing triples
|
|
(as does the Guide document) .
|
|
However, the meaning of an OWL ontology is solely determined by the
|
|
RDF graph. Thus, it is allowable to use other syntactic RDF/XML
|
|
forms, as long as these
|
|
result in the same underlying set of RDF triples.
|
|
Such other syntactic forms would then carry exactly the same
|
|
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 triples, 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
|
|
[<cite><a
|
|
href="#ref-RDF-Semantics">RDF Semantics</a></cite>].
|
|
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-owl-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.
|
|
Therefore, RDF documents will generally be in OWL Full, unless they
|
|
are specifically constructed to be in OWL DL or Lite. </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-owl-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="#sameAs-def">owl:sameAs</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>
|
|
|
|
<p>
|
|
The ability of the Semantic Web to link information from multiple
|
|
sources is a desirable and powerful feature that can be used in many
|
|
applications.
|
|
However, the capability to merge data from multiple sources, combined with the
|
|
inferential power of OWL, does have potential for abuse. It may even be illegal
|
|
to create or to process such linked information in countries with data
|
|
protection laws, especially in the EU, without having a valid legal reason for
|
|
such processing. Therefore, great care should be taken when using OWL with any
|
|
kind of personal data that might be linked with other data sources or
|
|
ontologies. Detailed security solutions were considered out of scope for the
|
|
Working Group. Work currently underway elsewhere is expected to address these
|
|
issues with a variety of security and preference solutions --
|
|
see for example
|
|
<a href="http://www.oasis-open.org/committees/security/charter.php">
|
|
SAML</a> and
|
|
<a href="http://www.w3.org/P3P/">P3P</a>
|
|
</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-owl-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 a RDF schema for the OWL language constructs.
|
|
This schema provides information about the OWL vocabulary that could
|
|
be a useful reference point for ontology builders and tool
|
|
developers. The restrictions provided by the schema on the OWL classes
|
|
and properties are informative and not complete. Also, this schema
|
|
does not make distinctions between OWL Full, OWL DL and OWL Lite.
|
|
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.</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.
|
|
People that do import this schema should expect the resulting ontology
|
|
to be an OWL Full ontology.</p>
|
|
|
|
<p>
|
|
<a href="#appC">Appendix C</a> gives a tabular overview of the
|
|
OWL vocabulary in
|
|
terms of the built-in OWL classes and properties (the latter
|
|
with their domain and range).</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>
|
|
|
|
<p>Finally, <a href="#app-DLinRDF">Appendix E</a> provides a set of
|
|
practical guidelines for specifying OWL DL ontologies in RDF.</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 most RDF documents, the OWL code should be subelements of
|
|
a <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
|
|
example wine and food ontologies
|
|
discussed in the Guide document
|
|
[<cite><a href="#ref-owl-guide">OWL Guide</a></cite>].</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 "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.</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).
|
|
A class description describes an OWL class, either by a class name or
|
|
by specifying the class extension of an unnamed anonymous class.</p>
|
|
|
|
<p>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 is special in the sense that it describes a class
|
|
through a <em>class name</em> (syntactically represented as a URI
|
|
reference).
|
|
The other five types of class descriptions describe an anonymous
|
|
class by <em>placing
|
|
constraints on the class extension</em>. </p>
|
|
|
|
<p>Class descriptions of type 2-6
|
|
describe, 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>"ex:Human rdf:type owl:Class
|
|
."</code>, where <code>ex:</code> is the namespace of the relevant
|
|
ontology .</p>
|
|
|
|
<p class="note">NOTE: In OWL Lite and OWL DL, <code>owl:Class</code>
|
|
(or <code>owl:Restriction</code>, see further)
|
|
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 equivalent in
|
|
OWL Full. </p>
|
|
|
|
<p>The other five forms of class descriptions consist of a set of RDF triples
|
|
in which a blank node represents the class being described. That blank
|
|
node has an <code>rdf:type</code> property whose value is
|
|
<code>owl:Class</code>.</p>
|
|
|
|
<p class="note">
|
|
NOTE: If one provides an RDF identifier for class descriptions of
|
|
the enumeration, intersection, union or complement type,
|
|
this is not considered to be a class description, but a
|
|
special kind of class axiom for complete classes.
|
|
See <a href="#DescriptionAxiom">Sec. 3.2.3</a> for details.
|
|
</p>
|
|
|
|
<p class="note">
|
|
NOTE: In this document we sometimes use for readability purposes
|
|
the shorthand "class description" to
|
|
refer to "the class being described by the class
|
|
description". Strictly speaking, these are different in the case of
|
|
class descriptions of type 2-6: the class is represented by the
|
|
corresponding blank node; the class description is represented by the
|
|
triples that have this blank node as their subject.
|
|
</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/2004/REC-owl-semantics-20040210/#owl_Thing">owl:Thing</a></span>
|
|
and <a name="Nothing-def" id="Nothing-def"></a> <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_Nothing">owl:Nothing</a></span>.
|
|
The class extension of <code>owl:Thing</code> is the set of all
|
|
individuals.
|
|
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>
|
|
|
|
|
|
<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/2004/REC-owl-semantics-20040210/#owl_oneOf">owl:oneOf</a></span>
|
|
property. The value of this built-in OWL property must be a
|
|
list of individuals
|
|
that are the <a href="#Individual">instances</a> of the class.
|
|
This enables a class to be described by
|
|
exhaustively enumerating its instances.
|
|
The class extension of a class described 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 describes an anonymous class, namely a class of
|
|
all individuals that satisfy the restriction.
|
|
OWL distinguishes two kinds of property restrictions: value
|
|
constraints and cardinality constraints.</p>
|
|
|
|
<p>A <a href="#ValueRestriction">value constraint</a> puts constraints on the
|
|
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 some <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 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 <a href="#FunctionalProperty-def">owl:FunctionalProperty</a> and
|
|
<a href="#InverseFunctionalProperty-def"> owl:InverseFunctionalProperty</a>
|
|
(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/2004/REC-owl-semantics-20040210/#owl_Restriction">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/2004/REC-owl-semantics-20040210/#owl_onProperty"> 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 value is a data literal) and <a href="#ObjectProperty-def">object
|
|
properties</a> (properties for which the 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">3.1.2.1.1
|
|
owl:allValuesFrom</a></h6>
|
|
|
|
<p>The value constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_allValuesFrom">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
|
|
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 values of class
|
|
<code>Human</code>. Note that this class description does not state
|
|
that the property
|
|
always has values of this class; just that this is true for individuals
|
|
that belong to the class extension of the anonymous restriction class. </p>
|
|
|
|
<p class="note">
|
|
NOTE: In OWL Lite the only type of class description allowed as object of
|
|
<code>owl:allValuesFrom</code> is a class name.
|
|
</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 that is
|
|
being described, every 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 should be of type T, and if no
|
|
such values exist, the constraint is trivially true.</p>
|
|
|
|
<h6><a name="someValuesFrom-def" id="someValuesFrom-def">3.1.2.1.2
|
|
owl:someValuesFrom</a></h6>
|
|
|
|
<p>The value constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_someValuesFrom">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 only type of class description allowed as object of
|
|
<code>owl:someValuesFrom</code> is a class name.
|
|
</p>
|
|
|
|
|
|
<h6><a name="hasValue-def" id="hasValue-def">3.1.2.1.3 owl:hasValue</a></h6>
|
|
|
|
<p>The value constraint <span class="def"><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_hasValue">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="#sameAs-def">owl:sameAs</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 values "0" or "1".</p>
|
|
|
|
<h6><a name="maxCardinality-def" id="maxCardinality-def">3.1.2.2.1
|
|
owl:maxCardinality</a></h6>
|
|
|
|
<p>The cardinality constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_maxCardinality">
|
|
owl:maxCardinality</a></span>
|
|
is a built-in OWL property that
|
|
links a restriction class to a data value belonging to the value space 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 semantically distinct values
|
|
(individuals or data
|
|
values) for the property concerned, where N is the 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
|
|
<a href="#Datatype">Sec. 6</a>.</p>
|
|
|
|
|
|
<h6><a name="minCardinality-def" id="minCardinality-def">3.1.2.2.2
|
|
owl:minCardinality</a></h6>
|
|
|
|
<p>The cardinality constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_minCardinality">
|
|
owl:minCardinality</a></span>
|
|
is a built-in OWL property that
|
|
links a restriction class to a data value belonging to the value space 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 semantically distinct values
|
|
(individuals or data
|
|
values) for the property concerned, where N is the 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 <code>owl:minCardinality</code> of one or more means that
|
|
all instances of the class must have a value for the property.</p>
|
|
|
|
|
|
<h6><a name="cardinality-def" id="cardinality-def">3.1.2.2.3
|
|
owl:cardinality</a></h6>
|
|
|
|
|
|
<p>The cardinality constraint <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_cardinality">
|
|
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 semantically distinct values
|
|
(individuals or data
|
|
values) for the property concerned, where N is the 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 types 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">3.1.3.1 owl:intersectionOf</a></h5>
|
|
|
|
<p>The <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_intersectionOf">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 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 value of <code>owl:intersectionOf</code>
|
|
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
|
|
<a href="#Individual">Sec. 5</a>
|
|
one can find OWL language constructs for making
|
|
constraints about equality and difference of individuals.</p>
|
|
|
|
<p class="note"> NOTE: In this example we use enumerations to make
|
|
clear what the meaning is of this language construct. See the OWL
|
|
Guide [<cite><a href="#ref-owl-guide">OWL Guide</a></cite>] for more
|
|
typical examples. </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 <a
|
|
href="#DescriptionAxiom">Sec. 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">3.1.3.2 owl:unionOf</a></h5>
|
|
|
|
|
|
<p>The <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_unionOf">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 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">3.1.3.3
|
|
owl:complementOf</a></h5>
|
|
|
|
<p>An
|
|
<span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_complementOf">owl:complementOf</a></span>
|
|
property links a class to precisely one <a href="#ClassDescription">class
|
|
description</a>.
|
|
An <code>owl:complementOf</code> statement describes a class for which the class
|
|
extension contains exactly those individuals
|
|
that do <em>not</em> belong to the class extension of the
|
|
class description that is the object of the statement.
|
|
<code>owl:complementOf</code> is
|
|
analogous to logical negation: the class extension consists of those
|
|
individuals that are NOT members of the class extension of the
|
|
complement class. </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>The extension of this class description contains all individuals
|
|
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 the
|
|
name of 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 <a
|
|
href="#DescriptionAxiom">Sec. 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>rdfs:subClassOf</code> <em>class
|
|
description</em> </p>
|
|
|
|
<p>The <code>rdfs:subClassOf</code> construct is
|
|
defined as part of RDF Schema
|
|
[<cite><a href="#ref-rdf-vocabulary">RDF Vocabulary</a></cite>]. Its meaning in OWL
|
|
is exactly the same: if the class description C1 is defined as a subclass of
|
|
class description C2, then 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 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 subject of an
|
|
<code>rdfs:subClassOf</code> statement must be a class identifier. The
|
|
object must be either a class identifier or a property restriction.</p>
|
|
|
|
<p>
|
|
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
|
|
[<cite><a href="#ref-owl-guide">OWL Guide</a></cite>].
|
|
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
|
|
at least one
|
|
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/2004/REC-owl-semantics-20040210/#owl_equivalentClass">owl:equivalentClass</a></span>
|
|
statements. <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 descriptions 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="#sameAs-def">owl:sameAs</a></code> construct.
|
|
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 subject and object
|
|
of an <code>owl:equivalentClass</code> statement. In OWL Lite
|
|
the subject must be a class name and the object must be either a class
|
|
name or a property restriction. </p>
|
|
|
|
<p class="note">
|
|
NOTE: Although in principle different types of class descriptions are allowed
|
|
as the subject of an equivalentClass statement,
|
|
in practice it usually is some class
|
|
identifier. This 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 axiom indeed defines a class with exactly the same instances 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 opera 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:complementOf</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 values of the
|
|
intersectionOf list must 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/2004/REC-owl-semantics-20040210/#owl_disjointWith">owl:disjointWith</a></span>
|
|
statements.
|
|
<code>owl:disjointWith</code> is a
|
|
built-in OWL property with a class
|
|
description as domain and range.
|
|
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 main categories of properties that an
|
|
ontology builder may want to define:</p>
|
|
<ul>
|
|
<li><em>Object properties</em> link individuals to individuals.</li>
|
|
<li><em>Datatype properties</em> link individuals to data values.</li>
|
|
</ul>
|
|
|
|
<p class="note">
|
|
NOTE: OWL also has the notion of annotation properties
|
|
(<code>owl:AnnotationProperty</code>) and ontology properties
|
|
(<code>owl:OntologyProperty</code>). These are needed in OWL DL for semantic
|
|
reasons. See <a href="#Header">Sec. 7</a>
|
|
and the OWL Semantics and Abstract Syntax document
|
|
[<cite><a href="#ref-owl-abstract-syntax">OWL S&AS</a></cite>].
|
|
</p>
|
|
|
|
<p>An object property is defined as an instance of the built-in OWL class
|
|
<a name="ObjectProperty-def" id="ObjectProperty-def"></a> <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_ObjectProperty">owl:ObjectProperty</a></span>.
|
|
A datatype property is defined as an instance of the built-in
|
|
OWL class <a
|
|
name="DatatypeProperty-def" id="DatatypeProperty-def"></a> <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_DatatypeProperty">owl:DatatypeProperty</a></span>.
|
|
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 <a
|
|
href="#OWLFull">Sec. 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 its 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-vocabulary">RDF Vocabulary</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">4.1.1 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 subject and object of a subproperty statement
|
|
must be either both datatype properties or both object properties.</p>
|
|
|
|
<h4><a name="domain-def" id="domain-def">4.1.2 rdfs:domain</a></h4>
|
|
|
|
<p>For a property one can define (multiple)
|
|
<code>rdfs:domain</code> axioms.
|
|
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 subjects of such
|
|
property statements must belong to the class extension of
|
|
the indicated 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 class="note">
|
|
NOTE: In OWL Lite the value of <code>rdfs:domain</code>
|
|
must be a class identifier.
|
|
</p>
|
|
|
|
|
|
<h4><a name="range-def" id="range-def">4.1.3 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 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 only type of class descriptions allowed as objects of
|
|
<code>rdfs:range</code> are class names.
|
|
</p>
|
|
|
|
<h3><a name="PropertyRelation">4.2 Relations to other properties</a></h3>
|
|
|
|
<h4><a name="equivalentProperty-def" id="equivalentProperty-def">4.2.1
|
|
owl:equivalentProperty</a></h4>
|
|
|
|
|
|
<p>The <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_equivalentProperty">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
|
|
built-in OWL property
|
|
with <code>rdf:Property</code> as both its domain and range.</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="#sameAs-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">4.2.2
|
|
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/2004/REC-owl-semantics-20040210/#owl_inverseOf">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 built-in OWL
|
|
property with <code>owl:ObjectProperty</code> as its domain and
|
|
range.
|
|
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 property
|
|
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">4.3.1 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 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/2004/REC-owl-semantics-20040210/#owl_FunctionalProperty">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 woman 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 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">4.3.2
|
|
owl:InverseFunctionalProperty</a></h4>
|
|
|
|
<p>If a
|
|
property is declared to be inverse-functional, then the object of a
|
|
property statement uniquely
|
|
determines the subject (some individual). More formally, if we state that
|
|
P is an <code>owl:InverseFunctionalProperty</code>, then this asserts that a
|
|
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 OWL class
|
|
<span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_InverseFunctionalProperty">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 <a href="#OWLFull">Sec. 8.1</a> and <a
|
|
href="#OWLDL">Sec. 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 object
|
|
of <code>biologicalMotherOf</code> statements (some human) one should be able
|
|
to uniquely identify a subject (some 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">4.4.1 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 class
|
|
<span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_TransitiveProperty">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
|
|
superproperties, nor on the inverse of the property or its superproperties.
|
|
</p>
|
|
|
|
<h4><a name="SymmetricProperty-def"
|
|
id="SymmetricProperty-def">4.4.2 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 class
|
|
<span class="def"><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_SymmetricProperty">owl:SymmetricProperty</a></span>,
|
|
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>
|
|
The domain and range of a symmetric property are the same.
|
|
</p>
|
|
|
|
|
|
<h2><a name="Individual" id="Individual">5. Individuals</a></h2>
|
|
|
|
<p>Individuals are defined with individual axioms (also called "facts").
|
|
We discuss two types of facts:</p>
|
|
<ol>
|
|
<li>Facts about class membership and property values of individuals</li>
|
|
<li>Facts about individual identity</li>
|
|
</ol>
|
|
|
|
<h3><a name="IndividualAxiom">5.1 Class membership and property values</a></h3>
|
|
|
|
<p>Many facts typically are statements indicating class membership
|
|
of individuals and property values of individuals.
|
|
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 individual
|
|
<code>Tosca</code>, an instance of the class <code>Opera</code>.
|
|
<code>Tosca</code> is
|
|
composed by Giacomo Puccini.
|
|
The opera has three libretto writers. The property
|
|
<code>premiereDate</code> links an opera to a typed literal
|
|
with 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 stating facts 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. </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">5.2.1 owl:sameAs</a></h4>
|
|
|
|
<p>The built-in OWL property <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_sameAs">owl:sameAs</a></span>
|
|
links an individual to 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". </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>
|
|
<rdf:Description rdf:about="#William_Jefferson_Clinton">
|
|
<owl:sameAs rdf:resource="#BillClinton"/>
|
|
</rdf:Description>
|
|
</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 a 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>
|
|
|
|
<p class="note">
|
|
NOTE: For details of comparison of URI references, see the section on
|
|
RDF URI references in the RDF Concepts document
|
|
[<cite><a href="#ref-rdf-concepts">RDF Concepts</a></cite>].
|
|
</p>
|
|
|
|
<h4><a name="differentFrom-def">5.2.2 owl:differentFrom</a></h4>
|
|
|
|
<p>
|
|
The built-in OWL <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_differentFrom">owl:differentFrom</a></span>
|
|
property links an individual to an 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 different operas.
|
|
|
|
|
|
<h4><a name="AllDifferent-def">5.2.3 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/2004/REC-owl-semantics-20040210/#owl_AllDifferent">owl:AllDifferent</a>.
|
|
<code>owl:AllDifferent</code> is a special built-in OWL class, for
|
|
which the property <a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_distinctMembers">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 subject.</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 three types of data range
|
|
specifications:</p>
|
|
|
|
<ul>
|
|
<li>A <a href="#rdf-datatype">RDF datatype</a> specification.</li>
|
|
<li>The RDFS class
|
|
<a href="http://www.w3.org/TR/rdf-schema/#ch_literal">rdfs:Literal</a>.</li>
|
|
<li>An <a href="#EnumeratedDatatype">enumerated datatype</a>,
|
|
using the <code>owl:oneOf</code> construct.</li>
|
|
</ul>
|
|
|
|
<p>The minimal level of tool support for datatypes is discussed in
|
|
<a href="#DatatypeSupport">Sec. 6.3</a>.</p>
|
|
|
|
<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>.
|
|
In RDF/XML, the type of a literal is specified by an <code>rdf:datatype</code>
|
|
attribute 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 URI reference of the datatype <code>rdf:XMLLiteral</code>.
|
|
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>
|
|
</ul>
|
|
|
|
<p>The RDF Semantics document
|
|
[<cite><a href="#ref-RDF-Semantics">RDF Semantics</a></cite>, Section 5].
|
|
recommends use of the following
|
|
simple built-in XML Schema datatypes.</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:string:
|
|
<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 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 <a href="#DatatypeSupport">Sec. 6.3</a>
|
|
for details about how these should be treated by OWL tools). </p>
|
|
|
|
|
|
<p>
|
|
When using datatypes, please note that even if a property is defined
|
|
to have a range of a certain datatype, RDF/XML still requires that
|
|
the datatype be specified each time the property is used.
|
|
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 subject of <code>owl:oneOf</code> is a blank
|
|
node of class
|
|
<a name="DataRange-def"><code>owl:DataRange</code></a>
|
|
and the object 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 class="note">
|
|
NOTE: Enumerated datatypes are not part of OWL Lite.
|
|
</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>
|
|
|
|
|
|
<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 must support datatype reasoning for the XML Schema datatypes
|
|
<code>xsd:string</code> and <code>xsd:integer</code>.
|
|
OWL Full tools must also support <code>rdf:XMLLiteral</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 Full does not put any constraints on annotations in an ontology.
|
|
OWL DL allows annotations on classes, properties, individuals
|
|
and ontology headers, but only under the following conditions:
|
|
</p>
|
|
<ul>
|
|
<li>The sets of object properties, datatype properties, annotation properties
|
|
and ontology properties must be mutually disjoint. Thus, in OWL DL
|
|
<code>dc:creator</code> cannot be at the same time a datatype property and
|
|
an annotation property.</li>
|
|
<li>Annotation properties must have an explicit <a
|
|
name="AnnotationProperty-def">typing triple</a> of the form:
|
|
<pre>
|
|
AnnotationPropertyID rdf:type owl:AnnotationProperty .
|
|
</pre></li>
|
|
<li>Annotation properties must not be used in property axioms. Thus, in OWL
|
|
DL one cannot define subproperties or domain/range constraints for
|
|
annotation properties.</li>
|
|
<li>The object of an annotation property must be either a data literal, a URI
|
|
reference, or an individual.</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 in OWL DL:</p>
|
|
|
|
<pre>
|
|
<owl:AnnotationProperty rdf:about="&dc;creator"/>
|
|
|
|
<owl:Class rdf:about="#MusicalWork">
|
|
<rdfs:label>Musical work</rdfs: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 properties as annotation properties
|
|
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-owl-abstract-syntax">OWL S&AS</a></cite>] for details).</p>
|
|
|
|
<p>Once we define <code>dc:creator</code>
|
|
as an annotation property, OWL DL does
|
|
NOT allow property axioms such as the range constraint below:</p>
|
|
|
|
<pre>
|
|
<-- This is illegal in OWL DL -->
|
|
|
|
<owl:AnnotationProperty rdf:about="&dc;creator">
|
|
<rdfs:range rdf:resource="&xsd;string"/>
|
|
</owl:AnnotationProperty>
|
|
</pre>
|
|
|
|
<p>Note that one can still specify the value type of a literal in an
|
|
annotation-property statement:</p>
|
|
|
|
<pre>
|
|
<Opera rdf:about="#Tosca">
|
|
<dc:creator rdf:datatype="&xsd;string">Giacomo Puccini</dc:creator>
|
|
</Opera>
|
|
</pre>
|
|
|
|
|
|
<h3><a name="Ontology-def" id="Ontology-def">7.2 Ontology header</a></h3>
|
|
|
|
<p>A document describing an ontology typically contains information
|
|
about the ontology itself. An ontology is a resource, so it may be
|
|
described using properties from the OWL and other namespaces, e.g.:</p>
|
|
|
|
<pre>
|
|
<owl:Ontology rdf:about="">
|
|
<owl:versionInfo> ... </owl:versionInfo>
|
|
<rdfs:comment>...</rdfs:comment>
|
|
<owl:imports rdf:resource="..."/>
|
|
</owl:Ontology>
|
|
</pre>
|
|
|
|
<p>This is commonly called the ontology header and is typically found
|
|
near the beginning of the RDF/XML document. The line</p>
|
|
|
|
<pre>
|
|
<owl:Ontology rdf:about="">
|
|
</pre>
|
|
|
|
<p>states that this block describes the current ontology. More
|
|
precisely, it states the current base URI identifies an instance of
|
|
the class <code>owl:Ontology</code>.
|
|
It is recommended that the
|
|
base URI be defined using an <code>xml:base</code> attribute in the
|
|
<code><rdf:RDF></code> element at the beginning of the document.
|
|
</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 following sections describe the various types of statements that are
|
|
typically used within the header.</p>
|
|
|
|
<p class="note">
|
|
NOTE: The ontology-import construct <a href="#imports-def">owl:imports</a>
|
|
and the ontology-versioning constructs
|
|
<a href="#priorVersion-def">owl:priorVersion</a>,
|
|
<a href="#backwardCompatibleWith-def">owl:backwardCompatibleWith</a>
|
|
and
|
|
<a href="#incompatibleWith-def">owl:incompatibleWith</a>
|
|
are defined in the OWL vocabulary as instances of the OWL built-in
|
|
class <a name="OntologyProperty-def"><code>owl:OntologyProperty</code></a>.
|
|
Instances of <code>owl:OntologyProperty</code> must have the class
|
|
<code>owl:Ontology</code> as their domain and range.
|
|
It is permitted to define other instances of
|
|
<code>owl:OntologyProperty</code>. In OWL DL for
|
|
ontology properties the same constraints hold as those specified for
|
|
annotation properties in <a href="#Annotations">Sec. 7.1</a>.
|
|
</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/2004/REC-owl-semantics-20040210/#owl_imports"><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.
|
|
Syntactically, <code>owl:imports</code> is a property with 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 whether or not an OWL tool must load an imported ontology
|
|
depends on the purpose of the tool. If the tool is a complete reasoner
|
|
(including complete consistency checkers) then it must load all of the
|
|
imported ontologies. Other tools, such as simple editors and incomplete
|
|
reasoners, may choose to load only some or even none of the imported
|
|
ontologies.</p>
|
|
|
|
<p>
|
|
Although owl:imports and namespace declarations may appear
|
|
redundant, they actually serve different purposes. Namespace
|
|
declarations simply set up a shorthand for referring to identifiers.
|
|
They do not implicitly include the meaning of documents located at the
|
|
URI. On the other hand, owl:imports does not provide any shorthand
|
|
notation for referring to the identifiers from the imported document.
|
|
Therefore, it is common to have a corresponding namespace declaration
|
|
for any ontology that is imported.
|
|
</p>
|
|
|
|
<p class="note">NOTE: <code>owl:imports</code>
|
|
is an instance of <code>owl:OntologyProperty</code>.
|
|
</p>
|
|
|
|
|
|
<h3><a name="VersionInformation">7.4 Version information</a></h3>
|
|
|
|
<h4><a name="versionInfo-def" id="versionInfo-def">7.4.1
|
|
owl:versionInfo</a></h4>
|
|
|
|
<p>An
|
|
<span class="def"><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_versionInfo"><code>owl:versionInfo</code></a></span>
|
|
statement generally has as its object 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>
|
|
|
|
<p class="note">NOTE: <code>owl:versionInfo</code>
|
|
is an instance of <code>owl:AnnotationProperty</code>.
|
|
</p>
|
|
|
|
<h4> <a name="priorVersion-def" id="priorVersion-def">7.4.2
|
|
owl:priorVersion</a></h4>
|
|
|
|
<p> An <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_priorVersion"><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><code>owl:priorVersion</code> is a built-in OWL property with the class
|
|
<code>owl:Ontology</code> as its domain and range.
|
|
</p>
|
|
|
|
<p class="note">NOTE: <code>owl:priorVersion</code>
|
|
is an instance of <code>owl:OntologyProperty</code>.
|
|
</p>
|
|
|
|
|
|
<h4><a name="backwardCompatibleWith-def"
|
|
id="backwardCompatibleWith-def">7.4.3
|
|
owl:backwardCompatibleWith</a></h4>
|
|
|
|
<p>An <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_backwardCompatibleWith"><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><code>owl:backwardCompatibleWith</code> is a built-in OWL
|
|
property with the class <code>owl:Ontology</code> as its domain and range.
|
|
</p>
|
|
|
|
<p class="note">NOTE:
|
|
<code>owl:backwardCompatibleWith</code>
|
|
is an instance of <code>owl:OntologyProperty</code>.
|
|
</p>
|
|
|
|
|
|
<h4><a name="incompatibleWith-def"
|
|
id="incompatibleWith-def">7.4.4 owl:incompatibleWith</a></h4>
|
|
|
|
<p>An <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_incompatibleWith"><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><code>owl:incompatibleWith</code> is a built-in OWL property with
|
|
the class <code>owl:Ontology</code> as its domain and range.
|
|
</p>
|
|
|
|
|
|
<p class="note">NOTE:
|
|
<code>owl:backwardCompatibleWith</code>
|
|
is an instance of <code>owl:OntologyProperty</code>.
|
|
</p>
|
|
|
|
<h4><a name="Deprecation" id="Deprecation">7.4.5 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/2004/REC-owl-semantics-20040210/#owl_DeprecatedClass">owl:DeprecatedClass</a></span>
|
|
or <span class="def"><a
|
|
href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#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:equivalentClass rdf:resource="#Automobile"/>
|
|
<!-- 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:DeprecatedClass>
|
|
|
|
<owl:Class rdf:ID="Automobile" />
|
|
|
|
<owl:DeprecatedProperty rdf:ID="hasDriver">
|
|
<rdfs:comment>inverse property drives is now preferred</rdfs:comment>
|
|
<owl:inverseOf rdf:resource="#drives" />
|
|
</owl:DeprecatedProperty>
|
|
|
|
<owl:ObjectProperty rdf:ID="drives" />
|
|
</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-owl-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 also to be part of the individual
|
|
domain. In fact, in OWL Full the universe of individuals consists of
|
|
all resources (<code>owl:Thing</code>
|
|
is equivalent to <code>rdfs:Resource</code>).
|
|
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). </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>rdfs: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 <a
|
|
href="#Annotations">Sec. 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-owl-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:resource="#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>
|
|
|
|
<p class="note">
|
|
NOTE: <a href="#app-DLinRDF">Appendix E</a> provides a set of
|
|
practical guidelines for specifying OWL DL ontologies in RDF.</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>
|
|
</ul>
|
|
|
|
<p>OWL Lite also requires that:</p>
|
|
<ul>
|
|
<li>the subject of <code>owl:equivalentClass</code> triples be class names
|
|
and the object of <code>owl:equivalentClass</code> triples be class names
|
|
or restrictions.</li>
|
|
<li>the subject of <code>rdfs:subClassOf</code> triples be class names
|
|
and the object of <code>rdfs:subClassOf</code> triples be class names or
|
|
restrictions;</li>
|
|
<li><code>owl:intersectionOf</code> be used only on lists of length greater
|
|
than one that contain only class names 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 class
|
|
names or datatype names;</li>
|
|
<li>the object of <code>rdf:type</code> triples be class names or
|
|
restrictions;</li>
|
|
<li>the object of <code>rdfs:domain</code> triples be class names;
|
|
and</li>
|
|
<li>the object of <code>rdfs:range</code> triples be class names or
|
|
datatype names.
|
|
</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 and property
|
|
restrictions. In addition, OWL Lite allows properties to be made
|
|
optional or required. 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-vocabulary">RDF Vocabulary</a></cite>].</p>
|
|
|
|
<table border="1">
|
|
<tr>
|
|
<th>[OWL Reference]<br />(this document)</th>
|
|
<th>[<cite><a href="#ref-owl-abstract-syntax">OWL Semantics</a></cite>]<br />(normative)</th>
|
|
<th>[<cite><a href="#ref-owl-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/2004/REC-owl-semantics-20040210/#owl_AllDifferent">owl:AllDifferent</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_allValuesFrom">owl:allValuesFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_allValuesFrom">owl:allValuesFrom</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#AnnotationProperty-def">owl:AnnotationProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_AnnotationProperty">owl:AnnotationProperty</a></td>
|
|
<td> </td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#backwardCompatibleWith-def">owl:backwardCompatibleWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_backwardCompatibleWith">owl:backwardCompatibleWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_cardinality">owl:cardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_Class">owl:Class</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_complementOf">owl:complementOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_complementOf">owl:complementOf</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#EnumeratedDatatype">owl:DataRange</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_DataRange">owl:DataRange</a></td>
|
|
<td> </td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#DatatypeProperty-def">owl:DatatypeProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_DatatypeProperty">owl:DatatypeProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_DeprecatedClass">owl:DeprecatedClass</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_DeprecatedProperty">owl:DeprecatedProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_differentFrom">owl:differentFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_disjointWith">owl:disjointWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_distinctMembers">owl:distinctMembers</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_distinctMembers">owl:distinctMembers</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#equivalentClass-def">owl:equivalentClass</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_equivalentClass">owl:equivalentClass</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_equivalentClass">owl:equivalentClass</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#equivalentProperty-def">owl:equivalentProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_equivalentProperty">owl:equivalentProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_equivalentProperty">owl:equivalentProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#FunctionalProperty-def">owl:FunctionalProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_FunctionalProperty">owl:FunctionalProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_hasValue">owl:hasValue</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_imports">owl:imports</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_incompatibleWith">owl:incompatibleWith</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_intersectionOf">owl:intersectionOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_InverseFunctionalProperty">owl:InverseFunctionalProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_inverseOf">owl:inverseOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_maxCardinality">owl:maxCardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_minCardinality">owl:minCardinality</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_Nothing">owl:Nothing</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_ObjectProperty">owl:ObjectProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_oneOf">owl:oneOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_onProperty">owl:onProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_Ontology">owl:Ontology</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_Ontology">owl:Ontology</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#OntologyProperty-def">owl:OntologyProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_OntologyProperty">
|
|
owl:OntologyProperty</a></td>
|
|
<td> </td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#priorVersion-def">owl:priorVersion</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_priorVersion">owl:priorVersion</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_priorVersion">owl:priorVersion</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Restriction-def">owl:Restriction</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_Restriction">owl:Restriction</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_sameAs">owl:sameAs</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_sameAs">owl:sameAs</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#someValuesFrom-def">owl:someValuesFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_someValuesFrom">owl:someValuesFrom</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_someValuesFrom">owl:someValuesFrom</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#SymmetricProperty-def">owl:SymmetricProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_SymmetricProperty">owl:SymmetricProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_Thing">owl:Thing</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_TransitiveProperty">owl:TransitiveProperty</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_unionOf">owl:unionOf</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#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/2004/REC-owl-semantics-20040210/#owl_versionInfo">owl:versionInfo</a></td>
|
|
<td><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/#owl_versionInfo">owl:versionInfo</a></td>
|
|
</tr>
|
|
</table>
|
|
|
|
<h2><a name="appB" id="appB"></a>Appendix B. RDF Schema of OWL</h2>
|
|
|
|
<p>See <a href="#AppendixList">Sec. 1.7</a> for a description of the
|
|
purpose of this appendix. The RDF/XML version of this appendix can
|
|
be found at <a href="http://www.w3.org/2002/07/owl">
|
|
http://www.w3.org/2002/07/owl</a>
|
|
</p>
|
|
|
|
<pre>
|
|
<?xml version="1.0"?>
|
|
<!DOCTYPE rdf:RDF [
|
|
<!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;"
|
|
>
|
|
|
|
<Ontology rdf:about="">
|
|
<imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>
|
|
<rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/" />
|
|
<rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-test-20040210/" />
|
|
<rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-features-20040210/" />
|
|
<rdfs:comment>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.
|
|
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.
|
|
</rdfs:comment>
|
|
<versionInfo>10 February 2004</versionInfo>
|
|
</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="sameAs">
|
|
<rdfs:label>sameAs</rdfs:label>
|
|
<rdfs:domain rdf:resource="#Thing"/>
|
|
<rdfs:range rdf:resource="#Thing"/>
|
|
</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="&rdfs;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="&owl;ObjectProperty"/>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="AnnotationProperty">
|
|
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
|
|
</rdfs:Class>
|
|
|
|
<AnnotationProperty rdf:about="&rdfs;label"/>
|
|
<AnnotationProperty rdf:about="&rdfs;comment"/>
|
|
<AnnotationProperty rdf:about="&rdfs;seeAlso"/>
|
|
<AnnotationProperty rdf:about="&rdfs;isDefinedBy"/>
|
|
|
|
<rdfs:Class rdf:ID="Ontology">
|
|
<rdfs:label>Ontology</rdfs:label>
|
|
</rdfs:Class>
|
|
|
|
<rdfs:Class rdf:ID="OntologyProperty">
|
|
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
|
|
</rdfs:Class>
|
|
|
|
<rdf:Property rdf:ID="imports">
|
|
<rdfs:label>imports</rdfs:label>
|
|
<rdf:type rdf:resource="#OntologyProperty"/>
|
|
<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>
|
|
<rdf:type rdf:resource="#OntologyProperty"/>
|
|
<rdfs:domain rdf:resource="#Ontology"/>
|
|
<rdfs:range rdf:resource="#Ontology"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="backwardCompatibleWith">
|
|
<rdfs:label>backwardCompatibleWitesh</rdfs:label>
|
|
<rdf:type rdf:resource="#OntologyProperty"/>
|
|
<rdfs:domain rdf:resource="#Ontology"/>
|
|
<rdfs:range rdf:resource="#Ontology"/>
|
|
</rdf:Property>
|
|
|
|
<rdf:Property rdf:ID="incompatibleWith">
|
|
<rdfs:label>incompatibleWith</rdfs:label>
|
|
<rdf:type rdf:resource="#OntologyProperty"/>
|
|
<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>
|
|
|
|
<p>Classes in the OWL vocabulary:</p>
|
|
|
|
<table border="1">
|
|
<tr>
|
|
<th>rdfs:Class</th>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#AllDifferent-def">owl:AllDifferent</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#AnnotationProperty-def">owl:AnnotationProperty</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#Class-def">owl:Class</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="#DataRange-def">owl:DataRange</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="#OntologyProperty-def">owl:OntologyProperty</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>
|
|
<tr>
|
|
<td><a href="#TransitiveProperty-def">owl:TransitiveProperty</a></td>
|
|
</tr>
|
|
</table>
|
|
|
|
<p />
|
|
|
|
<p>Properties in the OWL vocabulary:</p>
|
|
|
|
<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><a href="#Ontology-def">owl:Ontology</a></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="#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+OIL semantics are closest 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>RDF Semantics [<cite><a href="#ref-RDF-Semantics">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>
|
|
<li>the <code>daml:List</code> construct used to represent closed collections
|
|
was largely incorporated into RDF
|
|
<ul>
|
|
<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><code>rdf:List</code>, <code>rdf:first</code>, <code>rdf:rest</code>
|
|
and <code>rdf:nil</code>
|
|
replace
|
|
<code>daml:List</code>, <code>daml:first</code>, <code>daml:rest</code>,
|
|
and <code>daml:nil</code></li>
|
|
<li><code>daml:item</code>
|
|
is not supported.
|
|
As this feature was typically used to create
|
|
typed lists, we include here an example of creating such a list
|
|
without using <code>daml:item</code>:
|
|
|
|
<pre>
|
|
<rdfs:Class rdf:ID="OperaList">
|
|
<rdfs:subClassOf rdf:resource="&rdf;List"/>
|
|
<rdfs:subClassOf>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="&rdf;first"/>
|
|
<owl:allValuesFrom rdf:resource="#Opera"/>
|
|
</owl:Restriction>
|
|
</rdfs:subClassOf>
|
|
<rdfs:subClassOf>
|
|
<owl:Restriction>
|
|
<owl:onProperty rdf:resource="&rdf;rest"/>
|
|
<owl:allValuesFrom rdf:resource="#OperaList"/>
|
|
</owl:Restriction>
|
|
</rdfs:subClassOf>
|
|
</rdfs:Class>
|
|
</pre>
|
|
This example defines a list of which the elements most be operas. This
|
|
is achieved by two restrictions, one on the <code>rdf:first</code>
|
|
value (representing the type of the list element) and a second
|
|
restriction on the <code>rdf:rest</code> value (which should the name
|
|
of the list being defined).
|
|
</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: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>Also added were
|
|
<code><a href="#AnnotationProperty-def">owl:AnnotationProperty</a></code>,
|
|
<code><a href="#OntologyProperty-def">owl:OntologyProperty</a></code> and
|
|
<code><a href="#DataRange-def">owl:DataRange</a></code>.
|
|
</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> and
|
|
<code><a href="#equivalentProperty-def">owl:equivalentProperty</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>
|
|
|
|
<h2><a name="app-DLinRDF" id="app-DLinRDF"></a>Appendix E.
|
|
Rules of Thumb for OWL DL ontologies</h2>
|
|
|
|
<p>The OWL Abstract Syntax and Semantics document
|
|
[<cite><a href="#ref-owl-abstract-syntax">OWL S&AS</a></cite>]
|
|
provides a characterization of OWL ontologies in terms of an abstract
|
|
syntax, along with a mapping to RDF triples.</p>
|
|
|
|
<p>The following rules give an informal characterization of the
|
|
conditions for an RDF graph to be a DL ontology. This is not intended
|
|
to replace the characterization given in S&AS, but instead gives
|
|
some general pointers — the idea is that if you stick to these
|
|
guidelines, you're more likely to produce OWL DL ontologies. Nor is
|
|
this intended to tell you how to turn the triple representation into
|
|
something closer to the abstract syntax.</p>
|
|
|
|
<h3><a name="nomess" id="nomess"></a>Don't mess with the vocabulary</h3>
|
|
|
|
<p>The built-in properties and classes should <strong>not</strong> be
|
|
redefined. In general this means that things in the OWL, RDF or RDFS
|
|
namespaces should not appear as subjects of triples.
|
|
</p>
|
|
|
|
<h3><a name="typeEverything"></a>Provide Explicit Typing</h3>
|
|
|
|
<p>Everything should have a type<a href="#1"><sup>1</sup></a>. If any
|
|
URI reference <code>x</code> is used where a class is expected, the
|
|
graph should contain a triple stating that </p>
|
|
|
|
<pre class="code">
|
|
x rdf:type owl:Class
|
|
</pre>
|
|
<p>
|
|
Similarly, if a property <code>p</code> is used where an object
|
|
property is expected then there should be a triple<a
|
|
href="#2"><sup>2</sup></a>
|
|
</p>
|
|
<pre class="code">
|
|
p rdf:type owl:ObjectProperty
|
|
</pre>
|
|
<p>If a property <code>q</code> is used where a data property is
|
|
expected then there should be a triple</p>
|
|
<pre class="code">
|
|
q rdf:type owl:DatatypeProperty
|
|
</pre>
|
|
|
|
<p>If a property <code>o</code> is used where an ontology property is
|
|
expected then it should either be one of the built in ontology properties
|
|
(<code>owl:imports</code>, <code>owl:priorVersion</code>,
|
|
<code>owl:backwardCompatibleWith</code>, and
|
|
<code>owl:incompatibleWith</code>) or there should be a triple:</p>
|
|
<pre class="code">
|
|
o rdf:type owl:OntologyProperty
|
|
</pre>
|
|
|
|
<p>If a property <code>a</code> is used where an annotation property
|
|
is expected then it should either be one of the built in annotation
|
|
properties (<code>owl:versionInfo</code>, <code>rdfs:label</code>,
|
|
<code>rdfs:comment</code>, <code>rdfs:seeAlso</code>, and
|
|
<code>rdfs:isDefinedBy</code>) or there should be a triple:</p>
|
|
<pre class="code">
|
|
a rdf:type owl:AnnotationProperty
|
|
</pre>
|
|
|
|
<p>
|
|
Any individuals that occur in the ontology should have at least one
|
|
type specified, i.e. for an individual <code>i</code>, there must be
|
|
a triple:</p>
|
|
<pre class="code">
|
|
i rdf:type c
|
|
</pre>
|
|
<p>where <code>c</code> is an <code>owl:Class</code> or
|
|
<code>owl:Restriction</code>.
|
|
</p>
|
|
|
|
<h3><a name="separatenames" id="separatenames"></a>Keep names separate</h3>
|
|
|
|
<p>URI references for classes, properties (object, datatype, ontology
|
|
and annotation) and individuals should be disjoint. Thus we cannot
|
|
have things like:
|
|
</p>
|
|
<pre class="code">
|
|
x rdf:type owl:Class
|
|
x rdf:type owl:ObjectProperty
|
|
</pre>
|
|
|
|
<p>
|
|
In particular, this means that we cannot use <em>classes as
|
|
instances</em>, i.e.
|
|
</p>
|
|
|
|
<pre class="code">
|
|
x rdf:type owl:Class
|
|
y rdf:type owl:Class
|
|
x rdf:type y
|
|
</pre>
|
|
|
|
<p>
|
|
is not valid OWL DL. A general rule here is that if there is a node
|
|
<code>x</code> in the graph with a triple:
|
|
</p>
|
|
|
|
<pre class="code">
|
|
x rdf:type owl:Class
|
|
</pre>
|
|
|
|
<p>
|
|
then <code>x</code> should not appear as the subject of any other
|
|
triple with predicate <code>rdf:type</code>.<a href="#3"><sup>3</sup></a>
|
|
</p>
|
|
|
|
<h3><a name="Restrictions" id="Restrictions"></a>Restrictions</h3>
|
|
|
|
<p>If a node <code>x</code> has <code>rdf:type</code>
|
|
<code>owl:Restriction</code> then the following should be the case:
|
|
</p>
|
|
<ul>
|
|
<li>It is a blank node (i.e. unnamed).</li>
|
|
<li>It is not the subject of any other triple with predicate <code>rdf:type</code><a href="#3"><sup>3</sup></a>.</li>
|
|
<li>It is the subject of exactly <strong>one</strong> triple with predicate
|
|
<code>owl:onProperty</code>, with the object of that triple being an
|
|
<code>owl:ObjectProperty</code> or
|
|
<code>owl:DatatypeProperty</code>.</li>
|
|
<li>It is the subject of exactly <strong>one</strong> of:
|
|
<ul>
|
|
<li>A triple with predicate <code>owl:someValuesFrom</code>. In this
|
|
case, the type of the property which is the object of the
|
|
<code>owl:onProperty</code> triple should be appropriate. By this we
|
|
mean that if the object of this triple is a datatype, the property
|
|
should be an
|
|
<code>owl:DatatypeProperty</code>. If the object is a class
|
|
description, the property should be an
|
|
<code>owl:ObjectProperty</code>. This typing information should be
|
|
present (due to the restrictions outlined <a
|
|
href="#typeEverything">above</a>).</li>
|
|
<li>A triple with predicate <code>owl:allValuesFrom</code>. Similar
|
|
restrictions hold as for <code>owl:someValuesFrom</code></li>
|
|
<li>A triple with predicate <code>owl:hasValue</code>. If the type of the
|
|
property involved in the <code>owl:onProperty</code> triple is
|
|
<code>owl:ObjectProperty</code> then the object of this triple should
|
|
be an individual. If the type of the
|
|
property involved in the <code>owl:onProperty</code> triple is
|
|
<code>owl:DatatypeProperty</code> the the object of this triple
|
|
should be a data literal. </li>
|
|
<li>A triple with predicate <code>owl:minCardinality</code>. The object
|
|
of this triple should be a data literal representing a non negative
|
|
integer.</li>
|
|
<li>A triple with predicate <code>owl:maxCardinality</code>. Restriction
|
|
as for <code>owl:minCardinality</code>. </li>
|
|
<li>A triple with predicate <code>owl:cardinality</code>. Restriction as
|
|
for <code>owl:minCardinality</code>. </li>
|
|
</ul>
|
|
</li>
|
|
<li>Any other triples in which <code>x</code> is the subject should
|
|
have predicate <code>owl:equivalentClass</code> or
|
|
<code>owl:disjointWith</code>.</li>
|
|
</ul>
|
|
|
|
<h3><a name="ClassAxioms2" id="ClassAxioms2"></a>Class axioms</h3>
|
|
|
|
<p>For any triples with predicate <code>rdfs:subClassOf</code> or
|
|
<code>owl:equivalentClass</code> or <code>owl:disjointWith</code>,
|
|
both the subject and object of the triples should be an
|
|
<code>owl:Class</code> or <code>owl:Restriction</code>, i.e. if we
|
|
have:</p>
|
|
|
|
<pre class="code">
|
|
x rdfs:subClassOf y
|
|
</pre>
|
|
|
|
<p>then the graph must contain one of:</p>
|
|
|
|
<pre class="code">
|
|
x rdf:type owl:Class
|
|
</pre>
|
|
|
|
<p>or</p>
|
|
|
|
<pre class="code">
|
|
x rdf:type owl:Restriction.
|
|
</pre>
|
|
|
|
<p>and one of</p>
|
|
|
|
<pre class="code">
|
|
y rdf:type owl:Class
|
|
</pre>
|
|
|
|
<p>or</p>
|
|
|
|
<pre class="code">
|
|
y rdf:type owl:Restriction.
|
|
</pre>
|
|
|
|
<h3><a name="PropertyAxioms" id="PropertyAxioms"></a>Property axioms</h3>
|
|
|
|
<p>For any triples with predicate <code>rdfs:subPropertyOf</code> or
|
|
<code>owl:equivalentProperty</code>, both the subject and object of the
|
|
triples should have the same type which should be one of
|
|
<code>owl:ObjectProperty</code> or <code>owl:DatatypeProperty</code>,
|
|
i.e. if we have:</p>
|
|
|
|
<pre class="code">
|
|
p owl:equivalentProperty q
|
|
</pre>
|
|
|
|
<p>
|
|
then the graph must contain either:
|
|
</p>
|
|
|
|
<pre class="code">
|
|
p rdf:type owl:ObjectProperty
|
|
q rdf:type owl:ObjectProperty.
|
|
</pre>
|
|
|
|
<p>
|
|
or
|
|
</p>
|
|
|
|
<pre class="code">
|
|
p rdf:type owl:DatatypeProperty
|
|
q rdf:type owl:DatatypeProperty.
|
|
</pre>
|
|
|
|
<p>
|
|
Triples with predicate <code>rdfs:domain</code> should have as their
|
|
subject an <code>owl:ObjectProperty</code> or
|
|
<code>owl:DatatypeProperty</code> and as their object an
|
|
<code>owl:Class</code> or <code>owl:Restriction</code>.
|
|
</p>
|
|
|
|
<p>
|
|
Triples with predicate <code>rdfs:range</code> should have as their subject
|
|
either an <code>owl:ObjectProperty</code> or an
|
|
<code>owl:DatatypeProperty</code>. In the case of the former, the
|
|
object of the triple should then be an <code>owl:Class</code> or
|
|
<code>owl:Restriction</code>, in the case of the latter, the object
|
|
should be either an XML Schema datatype, <code>rdfs:Literal</code>,
|
|
or an <code>owl:oneOf</code>
|
|
specifying a data range with type <code>owl:DataRange</code>.
|
|
</p>
|
|
|
|
<p>Both the subject and object of an <code>owl:inverseOf</code> triple
|
|
must have type <code>owl:ObjectProperty</code>.</p>
|
|
|
|
<h3><a name="individualaxioms" id="individualaxioms"></a>Individual axioms</h3>
|
|
|
|
<p>For any triples with predicate
|
|
<code>owl:sameAs</code> or
|
|
<code>owl:differentFrom</code>, the subject and object must be individuals.</p>
|
|
|
|
<p>
|
|
Note that relating two classes via
|
|
<code>owl:sameAs</code> is a very different thing to
|
|
relating them via <code>owl:equivalentClass</code>. The former says
|
|
that the two objects are in fact the same, is actually an example of
|
|
<em>class as instance</em>, and thus pushes the ontology out of OWL
|
|
DL. The latter is an assertion that the extension (e.g. the collection
|
|
of members) of the classes is equivalent.
|
|
</p>
|
|
|
|
<p>
|
|
Similarly, relating classes via <code>owl:differentFrom</code> is not
|
|
the same as relating them via <code>owl:disjointWith</code> (and is
|
|
again an example of an OWL Full construct). Two classes may be
|
|
different objects but still share the same extension.
|
|
</p>
|
|
|
|
<p>If
|
|
a node <code>x</code> has <code>rdf:type</code>
|
|
<code>owl:AllDifferent</code>, then the following should be the
|
|
case:</p>
|
|
<ul>
|
|
<li>It is a blank node (i.e. unnamed).</li>
|
|
<li>It is the subject of a triple with predicate
|
|
<code>owl:distinctMembers</code>, the object of which should be a
|
|
(well-formed) <code>rdf:List</code>, all of whose elements are
|
|
individuals.</li>
|
|
<li>It is not the subject (or object) of any other triples.</li>
|
|
</ul>
|
|
|
|
<h3><a name="booleanclassexpressions" id="booleanclassexpressions"></a>Boolean class expressions</h3>
|
|
|
|
<p>Boolean Operators (and, or, not) are represented in OWL using
|
|
<code>owl:intersectionOf</code>, <code>owl:unionOf</code> and
|
|
<code>owl:complementOf</code>.
|
|
</p>
|
|
|
|
<p>The subject of an <code>owl:complementOf</code> triple must be an
|
|
<code>owl:Class</code>, the object must be either an
|
|
<code>owl:Class</code> or <code>owl:Restriction</code>.</p>
|
|
|
|
<p>The subject of an <code>owl:unionOf</code>or
|
|
<code>owl:intersectionOf</code> triple must be an
|
|
<code>owl:Class</code>, the object must be a (well-formed)
|
|
<code>rdf:List</code>, all of whose elements are either
|
|
<code>owl:Class</code> or
|
|
<code>owl:Restriction</code>. These could either be represented
|
|
explicitly using expanded <code>rdf:Lists</code>, or if RDF-XML is
|
|
being used, an <code>rdf:parseType="Collection"</code> attribute.</p>
|
|
|
|
<pre class="code">
|
|
<owl:Class>
|
|
<owl:intersectionOf rdf:parseType="Collection">
|
|
<owl:Class rdf:about="x"/>
|
|
<owl:Class rdf:about="y"/>
|
|
</owl:intersectionOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>If the <code>owl:Class</code> is a blank node (i.e. the class is
|
|
unnamed), then it can only be the subject of at most one triple with
|
|
predicate
|
|
<code>owl:intersectionOf</code>,
|
|
<code>owl:unionOf</code> or <code>owl:complementOf</code>. If the
|
|
class is named, any number of such triples are allowed.</p>
|
|
|
|
<h3><a name="Enumerations" id="Enumerations"></a>Enumerations</h3>
|
|
|
|
<p>The subject of any triple with predicate <code>owl:oneOf</code> must be
|
|
either an <code>owl:Class</code> or an <code>owl:DataRange</code>. In
|
|
the case of the former, the object must be a (well-formed)
|
|
<code>rdf:List</code>, all of whose elements are individuals. In the case of the latter, the object must be a
|
|
(well-formed) <code>rdf:List</code>, all of whose elements are data
|
|
literals. Again, as with the boolean operators,
|
|
<code>rdf:parseType="Collection"</code> can be used.
|
|
</p>
|
|
|
|
<h3><a name="oaproperties" id="oaproperties"></a>Ontology and Annotation Properties</h3>
|
|
|
|
<p>The subject and object of any triple with an ontology predicate
|
|
should be an ontology, e.g. a node <code>x</code> such that there is a
|
|
triple:</p>
|
|
<pre class="code">
|
|
x rdf:type owl:Ontology
|
|
</pre>
|
|
|
|
<p>The subject of any triple with an annotation predicate should be a
|
|
named (i.e. non-bnode) class, a property, an individual or an
|
|
ontology. The object of a triple with an annotation predicate should
|
|
be an individual, a data literal or an arbitrary URI reference.</p>
|
|
|
|
<p>With the exception of predicates within the OWL, RDF and RDFS
|
|
vocabularies, annotation properties are the <strong>only</strong>
|
|
predicates that should appear in triples with a class or property as the
|
|
subject.</p>
|
|
|
|
<p>Annotation and ontology properties themselves should be
|
|
<a href="#typeEverything">typed</a>, and should not appear as the
|
|
subject or object of triples other than as the subject of a triple
|
|
with predicate <code>rdf:type</code> or an annotation property.</p>
|
|
|
|
<h3><a name="nosharing" id="nosharing"></a>Avoid structure sharing</h3>
|
|
|
|
<p>In general, the S&AS description of OWL does not permit
|
|
<em>structure sharing</em> in the RDF representation. This effectively
|
|
means that an anonymous node in the RDF graph representing a
|
|
particular description should only occur once (as the object of a
|
|
triple). Thus things like:</p>
|
|
<pre class="code">
|
|
x1 rdf:type owl:Class
|
|
x1 rdfs:subClassOf _:y
|
|
x2 rdf:type owl:Class
|
|
x2 rdfs:subClassOf _:y
|
|
_:y rdf:type owl:Class
|
|
_:y owl:complementOf z
|
|
</pre>
|
|
|
|
<p>
|
|
should be avoided. There are some tricky corner cases where this
|
|
<em>is</em> permitted. In general, however, graphs should use distinct
|
|
blank nodes whenever a class description is used in more than one place.
|
|
</p>
|
|
|
|
<h3><a name="noorphan" id="noorphan"></a>Avoid orphan blank nodes</h3>
|
|
|
|
<p>In general, blank nodes occurring in the graph either represent unnamed
|
|
individuals, or should be exactly
|
|
<strong>one</strong> of the following:</p>
|
|
<ul>
|
|
<li>The object of an <code>rdfs:subClassOf</code>,
|
|
<code>owl:equivalentClass</code>, <code>owl:disjointWith</code>,
|
|
<code>owl:someValuesFrom</code>, <code>owl:allValuesFrom</code> or
|
|
<code>rdf:type</code> triple.</li>
|
|
<li>The subject of an <code>rdf:type</code> triple with object
|
|
<code>owl:AllDifferent</code>.</li>
|
|
<li>An element in an <code>rdf:List</code>.</li>
|
|
</ul>
|
|
|
|
<p>Orphan blank nodes, i.e. those which are not the object of a triple are,
|
|
in general, not allowed (other than the <code>owl:AllDifferent</code>
|
|
case described above).</p>
|
|
|
|
<h3><a name="GroundFacts" id="GroundFacts"></a>Ground facts</h3>
|
|
|
|
<p>Ontologies may contain assertions of ground facts (e.g. triples
|
|
that assert the properties of individuals). The properties used in
|
|
these assertions must be an
|
|
<code>owl:ObjectProperty</code> or
|
|
<code>owl:DatatypeProperty</code>. The subject of any such triple must
|
|
be an individual (which should be <a
|
|
href="#typeEverything">typed</a>). The object can either be a reference
|
|
to an individual (if the property is an
|
|
<code>owl:ObjectProperty</code>) or a data literal (if the property is
|
|
an <code>owl:DatatypeProperty</code>).
|
|
</p>
|
|
|
|
|
|
<h3><a name="OWLLite2" id="OWLLite2"></a>OWL Lite</h3>
|
|
|
|
<p>OWL Lite documents should follow the same rules as OWL DL
|
|
documents, with a number of extra restrictions, primarily concerning
|
|
the vocabulary allowed. An OWL Lite document should
|
|
not use any of the following vocabulary:</p>
|
|
|
|
<ul>
|
|
<li><code>owl:unionOf</code></li>
|
|
<li><code>owl:complementOf</code></li>
|
|
<li><code>owl:oneOf</code></li>
|
|
<li><code>owl:hasValue</code></li>
|
|
<li><code>owl:disjointWith</code></li>
|
|
</ul>
|
|
|
|
<p>Any objects which are the object or subject of a triple with
|
|
predicate <code>owl:equivalentClass</code> should not be b-nodes.</p>
|
|
|
|
<p>The object of any triples with predicate
|
|
<code>owl:minCardinality</code>, <code>owl:maxCardinality</code> or
|
|
<code>owl:cardinality</code> should be a data literal representing the
|
|
integer 0 or 1.</p>
|
|
|
|
<p>The situation regarding the use of <code>owl:intersectionOf</code>
|
|
in OWL Lite is a little more complex. The predicate should
|
|
<strong>not</strong> be used to form arbitrary expressions, but <strong>is</strong>
|
|
needed in order to represent complete class definitions. The
|
|
restrictions above tell us that the subject of any triple with predicate
|
|
<code>owl:intersectionOf</code> should be a <code>owl:Class</code>. In
|
|
OWL Lite, we have the further restriction that this class should be
|
|
named, i.e. the subject should not be a bnode.</p>
|
|
|
|
<h3><a name="Miscellaneous" id="Miscellaneous"></a>Miscellaneous</h3>
|
|
|
|
<p>Be careful of the use of <code>owl:Thing</code>. For example, the
|
|
following OWL-RDF fragment:</p>
|
|
|
|
<pre class="code">
|
|
<owl:Class rdf:about="#A">
|
|
<rdfs:subClassOf>
|
|
<owl:Thing/>
|
|
</rdfs:subClassOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>does <strong>not</strong> describe a class <code>A</code> that is a
|
|
subclass of <code>owl:Thing</code>, but in fact describes a class
|
|
<code>A</code> that is a subclass of some anonymous instance of
|
|
<code>owl:Thing</code>. This is thus a use of class as instance and is
|
|
outside OWL DL. The desired effect of a subclass of
|
|
<code>owl:Thing</code> is obtained through:</p>
|
|
|
|
<pre class="code">
|
|
<owl:Class rdf:about="#A">
|
|
<rdfs:subClassOf>
|
|
<owl:Class rdf:about="http://www.w3.org/2002/07/owl#Thing"/>
|
|
</rdfs:subClassOf>
|
|
</owl:Class>
|
|
</pre>
|
|
|
|
<p>Be careful not to confuse <code>owl:Class</code> and
|
|
<code>rdfs:Class</code>. The following is <strong>not</strong> in DL
|
|
due to the fact that <code>c</code> is not given an appropriate
|
|
type.</p>
|
|
|
|
<pre class="code">
|
|
c rdf:type rdfs:Class
|
|
</pre>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<h3><a name="Notes" id="Notes"></a>Notes</h3>
|
|
|
|
<p>
|
|
<a name="1">[1]</a> Of course the necessity to type everything does
|
|
not apply to things from the OWL, RDF or RDFS namespaces.
|
|
</p>
|
|
|
|
<p>
|
|
<a name="2">[2]</a> Strictly speaking, if the property is defined as
|
|
being an <code>owl:TransitiveProperty</code>,
|
|
<code>owl:SymmetricProperty</code> or
|
|
<code>owl:InverseFunctionalProperty</code> then this is not
|
|
necessary.
|
|
</p>
|
|
|
|
<p>
|
|
<a name="3">[3]</a> An exception here is that we can have:
|
|
</p>
|
|
<pre class="code">
|
|
x rdf:type rdfs:Class
|
|
x rdf:type owl:Class
|
|
</pre>
|
|
<pre class="code">
|
|
p rdf:type rdf:Property
|
|
p rdf:type owl:ObjectProperty
|
|
</pre>
|
|
<p>or</p>
|
|
<pre class="code">
|
|
q rdf:type rdf:Property
|
|
q rdf:type owl:DatatypeProperty
|
|
</pre>
|
|
<p>In addition, for restrictions, we can have:</p>
|
|
<pre class="code">
|
|
x rdf:type owl:Restriction
|
|
x rdf:type rdfs:Class
|
|
x rdf:type owl:Class
|
|
</pre>
|
|
|
|
<h2><a name="changes-since-PR" id="changes-since-PR"></a>Appendix F.
|
|
Change Log since PR</h2>
|
|
|
|
<ol>
|
|
<li>
|
|
Removed spurious endnote [4] in Appendix E.
|
|
</li>
|
|
<li>
|
|
Added rdfs:label element to AnnotationProperty and OntologyProperty in Appendix
|
|
B (RDF Schema of OWL) after comment from
|
|
<a
|
|
href="http://lists.w3.org/Archives/Public/public-webont-comments/2003Dec/0024.html">Jacco van Ossenbruggen</a>.
|
|
</li>
|
|
<li>
|
|
Fixed broken section reference plus corrected section reference style.
|
|
</li>
|
|
<li>
|
|
Standardized reference section.
|
|
</li>
|
|
<li>
|
|
Editorial revision of requirement description for rdf:RDF element
|
|
after comment from
|
|
<a href="http://lists.w3.org/Archives/Public/public-webont-comments/2004Jan/0017.html">Minsu Jang</a>.
|
|
</li>
|
|
<li>
|
|
Several editorial changes in response to a review by
|
|
<a href="http://lists.w3.org/Archives/Public/public-webont-comments/2004Jan/0012.html">Lacy</a>.
|
|
</li>
|
|
<li>
|
|
Added explanatory text to Sec. 7.1 about OWL DL constraints on the use of
|
|
annotation properties, after
|
|
some public comments (for example, see the comments by
|
|
<a
|
|
href="http://lists.w3.org/Archives/Public/public-webont-comments/2004Jan/0006.html">Benjamin Nowack</a>.
|
|
Added also a sentence to Sec. 7.2
|
|
to indicate that the same constraints hold for ontology properties.
|
|
</li>
|
|
<li>
|
|
Several small editorial corrections after final read-though by editor.
|
|
</li>
|
|
</ol>
|
|
|
|
<hr />
|
|
|
|
<h2><a id="References" name="References">References</a></h2>
|
|
|
|
<dl>
|
|
|
|
<dt><a name="ref-OWL-Overview" id="ref-OWL-Overview">[OWL Overview]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-owl-features-20040210/">OWL Web Ontology Language Overview</a></cite>, Deborah L. McGuinness and Frank van Harmelen, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-features-20040210/ . <a href="http://www.w3.org/TR/owl-features/">Latest version</a> available at http://www.w3.org/TR/owl-features/ .</dd>
|
|
|
|
<dt><a name="ref-owl-guide" id="ref-owl-guide">[OWL Guide]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-owl-guide-20040210/">OWL Web Ontology Language Guide</a></cite>, Michael K. Smith, Chris Welty, and Deborah L. McGuinness, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-guide-20040210/ . <a href="http://www.w3.org/TR/owl-guide/">Latest version</a> available at http://www.w3.org/TR/owl-guide/ .</dd>
|
|
|
|
<dt><a name="ref-owl-abstract-syntax" id="ref-owl-abstract-syntax">[OWL Semantics and Abstract Syntax]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/">OWL Web Ontology Language Semantics and Abstract Syntax</a></cite>, Peter F. Patel-Schneider, Patrick Hayes, and Ian Horrocks, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-semantics-20040210/ . <a href="http://www.w3.org/TR/owl-semantics/">Latest version</a> available at http://www.w3.org/TR/owl-semantics/ .</dd>
|
|
|
|
<dt><a name="ref-owl-test" id="ref-owl-test">[OWL Test]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-owl-test-20040210/">OWL Web Ontology Language Test Cases</a></cite>, Jeremy J. Carroll and Jos De Roo, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-test-20040210/ . <a href="http://www.w3.org/TR/owl-test/">Latest version</a> available at http://www.w3.org/TR/owl-test/ .</dd>
|
|
|
|
<dt><a name="ref-owl-requirements" id="ref-owl-requirements">[OWL Requirements]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-webont-req-20040210/">OWL Web Ontology Language Use Cases and Requirements</a></cite>, Jeff Heflin, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-webont-req-20040210/ . <a href="http://www.w3.org/TR/webont-req/">Latest version</a> available at http://www.w3.org/TR/webont-req/ .</dd>
|
|
|
|
<dt><a name="ref-rdf-concepts" id="ref-rdf-concepts">[RDF Concepts]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/">Resource Description Framework (RDF): Concepts and Abstract Syntax</a></cite>, Graham Klyne and Jeremy J. Carroll, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/ . <a href="http://www.w3.org/TR/rdf-concepts/">Latest version</a> available at http://www.w3.org/TR/rdf-concepts/ .</dd>
|
|
|
|
<dt><a name="ref-rdf-syntax" id="ref-rdf-syntax">[RDF Syntax]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/">RDF/XML Syntax Specification (Revised)</a></cite>, Dave Beckett, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/ . <a href="http://www.w3.org/TR/rdf-syntax-grammar/">Latest version</a> available at http://www.w3.org/TR/rdf-syntax-grammar/ .</dd>
|
|
|
|
<dt><a name="ref-RDF-Semantics" id="ref-RDF-Semantics">[RDF Semantics]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-rdf-mt-20040210/">RDF Semantics</a></cite>, Pat Hayes, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/ . <a href="http://www.w3.org/TR/rdf-mt/">Latest version</a> available at http://www.w3.org/TR/rdf-mt/ .</dd>
|
|
|
|
<dt><a name="ref-rdf-vocabulary" id="ref-rdf-vocabulary">[RDF Vocabulary]</a></dt>
|
|
<dd><cite><a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210/">RDF Vocabulary Description Language 1.0: RDF Schema</a></cite>, Dan Brickley and R. V. Guha, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-schema-20040210/ . <a href="http://www.w3.org/TR/rdf-schema/">Latest version</a> available at http://www.w3.org/TR/rdf-schema/ .</dd>
|
|
|
|
<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="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>
|