CyberLibrarian

【注意】 このドキュメントは、W3CのOWL 2 Web Ontology Language Primer W3C Recommendation 27 October 2009の和訳です。
このドキュメントの正式版はW3Cのサイト上にある英語版であり、このドキュメントには翻訳に起因する誤りがありえます。誤訳、誤植などのご指摘は、訳者までお願い致します。

First Update: 2011年3月5日 | セマンティック・ウェブ関連用語集


W3C

OWL 2ウェブ・オントロジー言語
入門

W3C勧告 2009年10月27日

本バージョン:
http://www.w3.org/TR/2009/REC-owl2-primer-20091027/
最新バージョン(シリーズ2):
http://www.w3.org/TR/owl2-primer/
最新勧告:
http://www.w3.org/TR/owl-primer
旧バージョン:
http://www.w3.org/TR/2009/PR-owl2-primer-20090922/ (色分けした差分)
編集者:
Pascal Hitzler, Wright State University
Markus Krötzsch, FZI Research Center for Information Technology
Bijan Parsia, University of Manchester
Peter F. Patel-Schneider, Bell Labs Research, Alcatel-Lucent
Sebastian Rudolph, FZI Research Center for Information Technology

このドキュメントに対する正誤表を参照してください。いくつかの規範的な修正が含まれているかもしれません。

このドキュメントは、規範以外の形式でも入手できます: PDFバージョン

翻訳版も参照してください。


要約

OWL 2ウェブ・オントロジー言語(非公式にはOWL 2)は、形式的に定義された意味を有するセマンティック・ウェブのためのオントロジー言語です。OWL 2オントロジーは、クラス、プロパティー、個体、データ値を提供し、セマンティック・ウェブ・ドキュメントとして蓄積されます。OWL 2オントロジーは、RDFで記述された情報と共に使用でき、OWL 2オントロジー自身は、主にRDFドキュメントの形式で交換が行われます。OWL 2ドキュメント概要は、OWL 2の全般的な状況を説明しており、他のOWL 2ドキュメントの前に読むべきです。

この入門では、他の分野からやって来る人々に対するオリエンテーション、OWL 2を用いて最初にシンプルな情報を表し、その後により複雑な情報を表わす方法を示した実例、OWL 2でオントロジーを管理する方法、最後に、OWL 2の様々なサブ言語の違いなどを解説することにより、OWL 2を分かりやすく紹介しています。

このドキュメントのステイタス

置き換えられる可能性

この項は、このドキュメントの公開時のステイタスについて記述しています。他のドキュメントがこのドキュメントに取って代わることがありえます。現行のW3Cの刊行物およびこの技術報告の最新の改訂版のリストは、http://www.w3.org/TR/のW3C技術報告インデックスにあります。

XMLスキーマ・データ型の依存性

OWL 2は、XMLスキーマ定義言語(XML Schema Definition Language)(XSD)で定義されたデータ型を用いるように定義されています。この文書の執筆時点では、XSDの最新のW3C勧告はバージョン1.0であり、バージョン1.1の勧告に向けて進行中です。OWL 2は、XSD 1.1の新しいデータ型や、より明確な説明を用いるように作られていますが、現在は、これらの利用は部分的に保留されています。具体的には、2.3項の適合性で詳細に述べるように、XSD 1.1がW3C勧告になるまでは、それに基づくOWL 2の要素は任意であると考えるべきです。XSD 1.1がW3C勧告として公表されたときに、これらの要素は任意ではなくなり、規定に従い、必須であると見なすべきです。

開発者やユーザは、当面、XSD 1.1勧告候補に従うことをお勧めします。スキーマ・ワーキンググループとOWLワーキンググループの議論を踏まえると、XSD 1.1が勧告になった際にも、実装上の変更は必要なさそうです。

変更の概要

前バージョン以後は、実質的な変更はありません。軽微な変更に関する詳細は、変更履歴および色分けした差分を参照してください。

コメントの送信

public-owl-comments@w3.org公開アーカイブ)にコメントをお送りください。このドキュメントに対するOWLワーキンググループの作業は完了していますが、コメントは正誤表や今後の改定で扱われることがあります。開発者間の公開討論は、public-owl-dev@w3.org公開アーカイブ)で歓迎します。

W3Cによる承認

このドキュメントは、W3Cメンバー、ソフトウェア開発者、他のW3Cグループ、および他の利害関係者によりレビューされ、W3C勧告として管理者の協賛を得ました。これは確定済みドキュメントであり、参考資料として用いたり、別のドキュメントで引用することができます。勧告の作成におけるW3C の役割は、仕様に注意を引き付け、広範囲な開発を促進することです。これによってウェブの機能性および相互運用性が増強されます。

特許

このドキュメントは、2004年2月5日のW3C特許方針の下で活動しているグループによって作成されました。このドキュメントには、参考情報のみが含まれています。W3Cは、このグループの成果物に関連するあらゆる特許の開示の公開リストを維持し、このページには特許の開示に関する指示も含まれています。


目次



1 はじめに

W3C OWL 2ウェブ・オントロジー言語(OWL)は、事物、事物の集合、事物間の関係に関する豊かで複合的な知識を表現するように設計されたセマンティック・ウェブ言語です。OWLは、知識の一貫性を検証したり、暗黙知を明確化するために、OWLで表現した知識をコンピュータ・プログラムで推論可能とするコンピュータ論理言語です。オントロジーとして知られるOWLドキュメントは、WWWで公表され、他のOWLオントロジーを参照したり、他のOWLオントロジーから参照することができます。OWLは、RDF[RDF Concepts]と[SPARQL]を含むW3Cの一連のセマンティック・ウェブ技術の一部です。

この入門の主な目標は、OWLの長所や短所に関する見識を深められるようにすることです。入門は、OWLのほとんどの言語機能を実際の例を用いて紹介することを中心としています。入門の例の大部分は、オントロジーの例(全例は付録にある)から抽出したものです。このオントロジーの例は、OWLの主要な言語機能に分かりやすく触れられるように作成したものであり、本質的に、オントロジーの模範例を目指したものではありません。

1.1 このドキュメントに関して

このドキュメントは、OWL 2に関する初歩的な理解を得ることを目標としています。特に、このテーマになじみのない人々にとって分かりやすいものとなることを目指しています。したがって、2項において、OWL 2の性質に関し、何らかのハイレベルな紹介を行うことから始め、その後に3項において、非常に基本的な知識表現の概念をいくつか示し、それらがOWL 2で用いる用語とどの様に関連しているかを説明します。知識表現および推理について良く知っている読者は、OWL 2の用語について知るために、この項にざっと目を通すだけでよいかもしれません。

4~8項では、OWLが備えているほとんどの言語機能に関する非常に基本的な説明から始め、より洗練された説明へと進む形で、説明します。4項においてOWL 2の基本モデル化機能を示して論じた後に、5項において複合的なクラスについて紹介します。6項では、プロパティーの高度なモデル化機能を扱います。7項では、データ型に関連する高度なモデル化に焦点をあてます。8項の、主にオントロジーの管理目的で用いる付加的な論理機能で締めくくります。

9項では、OWL 2 DLとOWL 2 Fullの相違点とOWLの2つのセマンティック表示について扱い、10項では、プロファイルと呼ばれる、OWL 2の扱いやすい3つのサブ言語について説明します。OWL 2に対するツールのサポートについては、11項12項で扱い、このOWL 2に関する非公式な説明の後に読むべき文書について助言します。

最後に、13項では、このドキュメントで用いている全てのオントロジーの例をリストアップしています。

OWL 2言語機能の包括的なリストに関しては、構文と例に関する適切なドキュメントの該当箇所にリンクしているOWL 2クィック・リファレンス・ガイド[OWL 2 Quick Guide]を参照してください。

OWL 1について既に知っている読者は、OWL 2の新機能と原理[OWL 2 New Features and Rationale]にある、OWL 2の変更点に関する包括的な概要説明をご覧ください。

1.2 OWL構文

OWLはセマンティック・ウェブ用の言語であるため、OWLでは、名前は、国際化資源識別子(IRI)[RFC 3987]を用います。IRIは長いため、OWLでの記述においては、しばしば省略形を用います。そのような省略がどのように機能するかは、OWLオントロジーのコード化に使用できる構文の形式によって異なりますが、それに関する詳細を知らなくても、このドキュメントの例は、概ね理解できます。8.2項では、適切な名前空間の宣言と関連するメカニズムについてさらに詳細に示しています。

OWLでは、様々な目的に役立つ様々な構文が利用できます。関数型構文[OWL 2 Specification]は、仕様が簡単になり、APIや推論システムなどのOWL 2におけるツール実装の基礎となるように設計されています。OWLのRDF/XML構文は、OWL構成子用に特定の翻訳を行っただけのRDF/XMLです[OWL 2 RDF Mapping]。これは、すべてのOWL 2ツールにサポートが義務付けられている唯一の構文です。マンチェスター構文[OWL 2 Manchester Syntax]は、論理学者ではない人がより簡単に読めるように作られたOWL構文です。OWL XML構文は、XMLスキーマで定義されたOWL用XML構文です[OWL 2 XML]。OWLの異る構文間の翻訳が可能なツールもあります。多くの構文形式では、OWL言語構成子はIRIでも表され、省略形を用いるためには、例示の通り、いくつかの宣言が必要となりえます。先と同様に、必要な詳細は8.2項にあります。

付録の例とオントロジーの例は、4つの異なる構文のいずれかであると見なすことができ、ここでは、RDF/XML[RDF Syntax]と、RDFベースの構文のTurtle[RDF Turtle Syntax]シリアル化の両方を提供しています。下のボタンで、ドキュメント中に表示される構文を制御できます。

下のボタンで、利用可能な構文を表示または隠すことができます。

2 OWL 2とは

OWL 2は、オントロジーを表現するための言語です。オントロジーという用語には、コンピュータ・サイエンスの内外において複雑な歴史がありますが、ここでは、ある種のコンピュータ上の生成物、すなわち、プログラム、XMLスキーマやウェブ・ページのような、一般にドキュメントとして表示されるものを指すために使用します。オントロジーは、世界のある部分(通常、オントロジーの関心領域主題と呼ばれる)に関する正確な記述表現です。正確な記述は、いくつかの目的を満たします。最も注目すべきは、人間のコミュニケーション上の誤解を防止し、ソフトウェアが確実に一律の予測可能な動作を行い、他のソフトウェアとうまく連携することです。

関心領域について正確に記述するためには、中心となる用語(しばしば語彙と呼ばれる)を考え出し、その意味を定めることが有益です。自然言語による簡潔な定義のほかに、用語が他の用語とどのような相関関係にあるかを述べることによって、その用語の意味に特性を与えることができます。用語は、そのような相関関係の情報と共に語彙を提供することで、典型的なOWL 2ドキュメントの最も重要な部分を構成します。オントロジーには、この用語の知識(terminological knowledge)のほかに、一般的な概念ではなく、考えられる領域の具体的対象を扱う、いわゆる言明的知識(assertional knowledge)も含まれます。

OWL 2はプログラミング言語ではありません。OWL 2は宣言的、すなわち、状況を論理的に述べます。そして、その状況に関する詳細を推論するために、適切なツール(推論システムという)を使用できます。これらの推論がアルゴリズム的にどのように実現されるかは、OWLドキュメントには含まれておらず、特定の実装に依存します。それでもなお、そのような質問に対する正しい答えは、形式意味論(それは、ダイレクト・セマンティクス[OWL 2 Direct Semantics]とRDFベースのセマンティクス[OWL 2 RDF-Based Semantics]という2つのバージョンになる)であらかじめ決まっています。これらのセマンティクスに準拠した実装のみが、OWL 2に適合していると見なされるでしょう([OWL 2 Conformance]を参照)。OWL 2ドキュメントの作成作業は、宣言的な性質を有するため、プログラミングとは概念的に異なります。さらに、どちらの場合も、複雑な形式的ドキュメントが作成されるため、方法論的で共同的な面、モジュール化、パターンのような、ソフトウェア工学の概念の一部をオントロジー工学に受け渡すことができます。

OWL 2は、構文上の適合性を目指したスキーマ言語ではありません。XMLとは違って、OWL 2は、ドキュメントをどのように構文的に構造化すべきかを規定するための高度な手段を提供しません。特に、ある情報(ある人の社会保険番号のような)を構文的に必ず存在させる方法はありません。ユーザがこのような誤解を持つ可能性がある特徴がOWLにはあるということを覚えておくべきです。

OWL 2は、データベースのフレームワークではありません。確かに、OWL 2ドキュメントは情報を蓄積するため、データベースと言えます。さらに、言明情報とデータベース・コンテンツとの類似性や用語情報とデータベース・スキーマとの類似性も指摘できます。しかし、通常は、根本的な前提(技術的には、使用するセマンティクス)に決定的な違いがあります。データベースでは、ある事実が存在していなければ、通常、「偽」とみなされます(いわゆる、閉世界仮説)が、OWL 2ドキュメントの場合は、開世界仮説に従い、それが存在していない(しかし「真」かもしれない)だけでありえます。さらに、前記の通り、データベース・スキーマには、規定の制約付きセマンティクスが備えられていることが多いです。しかし、データベースは、技術的に、多くのオントロジー指向のシステムに実行可能なバックボーンを与えます。

3 知識のモデル化:基本概念

OWL 2は、関心領域に関する知識を、組織化、交換、推論するように設計された知識表現言語です。OWL 2において知識がどのように表現されるかを理解するために、いくつかの根本的な観念を最初に説明すべきでしょう。これらの基本概念は次の通りです。

OWL 2は知識の捕捉を目的としていますが、OWLが表現できる「知識」は、当然ながら、人間の知識のあらゆる側面を反映しているわけではありません。OWLは、人間の知識のある部分に関する強力な汎用モデル化言語であると考えることができます。モデル化作業の結果は、オントロジーと呼ばれます。オントロジーは、知識表現において「モデル」という用語がかなり異なる意味で用いられることが多いため、混乱を避けるために用いられている用語です。

ところで、知識を明確に組織化するためには、知識はステートメント命題と呼ばれる基本的な断片から構成されることが多いと想定すると良いです。「雨が降っている」や「すべての人間の命には限りがある」といったステートメントは、このような基本的命題の典型例です。実際、あらゆるOWL 2オントロジーは本質的に、このような基本的な「知識の断片」の単なる集合です。オントロジーで出されるステートメントは、OWL 2では公理と呼ばれ、オントロジーは公理が真であると言明します。一般に、ある状況が与えられた場合、OWLステートメントは、真か偽かのいずれかでありえます。以下で詳細を説明するように、この点で、エンティティーと異なっています。

人間が考えるときには、自分達の知識から結論を導き出します。OWLの重要な機能は、人間の知能のこの特徴を、それが表現できる知識の形式で捕捉するということです。しかし、ステートメントが他のステートメントの結果であるとは、概して何を意味するのでしょうか?本質的に、それは、このステートメントは、他のステートメントが真であれば常に真であるということを意味します。OWLの用語では、Aのすべてのステートメントが真である状況において、aも真である場合、ステートメントAはステートメントa含意すると言います。さらに、ステートメントの集合は、整合性がある(すなわち、その集合の中のすべてのステートメントを合わせて真であるような状況がありえる)ことも、矛盾している(そのような状況がない)こともありえます。OWLの形式意味論は、実質的に、特定のOWLステートメントが、どのようなありえる「状況」に対して真であるかを定めます。

自動的に結果を算出できるOWLツール(推論システム)があります。オントロジー上の公理のやりとりは、非常に微妙であり、人が理解するのは難しい場合があります。これは、OWL 2の長所でもあり短所でもあります。OWL 2ツールは、人が気付かない情報を発見できるため、長所と言えます。これにより、知識工学者はより直接的にモデル化を行うことができ、システムはモデル化に関する有益なフィードバックや批評を提供することができるようになります。様々に組み合わせられた様々な構成子の実際の効果を人間が即座に見通すことは比較的難しいため、弱点と言えます。ツールのサポートにより状況は改善しますが、知識設計の成功には、さらにいくらかの訓練と経験が必要なことが多いです。

OWLのステートメントをよく見ると、ステートメントが「単体」であることは稀であり、明示的に表現できる何らかの内部構造を有していることが多いことがわかります。通常、世界のオブジェクトを参照し、例えば、カテゴリ分け(「メアリーは女性である」のような)を行ったり、その関係について何かを述べる(「ジョンとメアリーは結婚している」)ことによって記述します。オブジェクト(ジョン、メアリー)であれ、カテゴリ(女性)であれ、関係(結婚している)であれ、ステートメントのあらゆる原子的構成要素をエンティティーと呼びます。OWL 2では、オブジェクトを個体として、カテゴリをクラスとして、関係をプロパティーとして表します。OWL 2のプロパティーは、さらに細分化されています。オブジェクト・プロパティーは、オブジェクトをオブジェクトに関連づけ(例えば、ある人をその配偶者に関連づける)、データ型プロパティーはデータ値をオブジェクトに割り当てます(例えば、人に年齢を割り当てる)。注釈プロパティーは、関心領域ではなく、オントロジー自身(の一部)に関する情報(公理の作者と作成日のような)をコード化するために用います。

OWLの主要機能として、いわゆるコンストラクタを用いて、エンティティー名を結合してにすることができます。簡単な例としては、女性の教授というクラスを記述するために、「女性」と「教授」という原子クラスを結合できます。後者は、OWLクラスの式で記述し、それをステートメントや他の式に利用できます。この意味において、式は、その構造により定義された新たなエンティティーとみなすことができます。OWLでは、エンティティーの種類ごとにコンストラクタは大きく異なっています。クラス用の表現言語は非常に豊かで洗練されていますが、プロパティー用の表現言語はあまりそうではありません。これらの違いには、歴史的かつ技術的な理由があります。

4 クラス、プロパティー、個体 ― および、それらを用いた基本的モデル化

一般的な考察の後に、ここでは、OWL 2でのモデル化に関して詳細に扱います。次の項では、OWL 2が提供する重要なモデル化機能を、例とその利用方法に関して、一般的なコメントを示しながら紹介しています。基本的にあらゆるモデル言語で利用できる基本機能から始め、より高度なコンストラクタへと進みます。

ここでは、特定の家族に関する情報を提示しています。この例は、OWLを用いるべき領域を代表するものではなく、さらに、OWLを用いた良いモデル化の規範例でも、かなり複雑で、変わりやすく、文化に依存した、家族に関する領域を正く表現したものでもありません。むしろ、OWLの様々な機能を、かなり簡潔に示そうとしたものです。

4.1 クラスとインスタンス

ここで話題にする人々を紹介することから始めます。それは、次の通りに行うことができます。

関数型構文
 ClassAssertion( :Person :Mary ) 
RDF/XML構文
 <Person rdf:about="Mary"/>
Turtle構文
 :Mary rdf:type :Person .
マンチェスター構文
 Individual: Mary
   Types: Person
OWL/XML構文
 <ClassAssertion>
    <Class IRI="Person"/>
    <NamedIndividual IRI="Mary"/>
 </ClassAssertion>


このステートメントは、メアリー(Mary)という個体に関して述べており、この個体が人(Person)であると述べています。より技術的には、人であることは、メアリーがあらゆる人のクラスに属している(または「メンバーである」や、より技術的には「インスタンスである」)と述べることによって表されます。一般に、クラスは、共通点がある個体をグルーピングし、それを参照するために用います。したがって、本来、クラスは個体の集合を表します。モデル化においては、クラスは、という概念や女性(Woman)という概念などの、人間の思考の概念から成るオブジェクトの集合を示すために用いられることが多いです。その結果、同種類のステートメントを用い、彼女が女性のクラスのインスタンスであると表現することによって、メアリーが女性であると示すことができます。

関数型構文
 ClassAssertion( :Woman :Mary ) 
RDF/XML構文
 <Woman rdf:about="Mary"/>
Turtle構文
 :Mary rdf:type :Woman .
マンチェスター構文
 Individual: Mary
   Types: Woman
OWL/XML構文
 <ClassAssertion>
    <Class IRI="Woman"/>
    <NamedIndividual IRI="Mary"/>
 </ClassAssertion>

これにより、クラスのメンバーシップが排他的でないことも明確になります。個体のグルーピングにはさまざまな基準(性別、年齢、靴のサイズなどの)がありえるため、1つの個体は、恐らく、同時に複数のクラスに属しているでしょう。

4.2 クラスの階層

前項で、あらゆる人のクラスとあらゆる女性のクラスという、2つのクラスについて話しました。人間の読者にとっては、これらの2つのクラスが特別な関係にあることは明確です。つまり、人は女性より一般的であり、ある個体が女性であることを知っていれば、その個体は常に人であるに違いないということは明確です。しかし、この対応関係は、「人」と「女性」というラベルからは得られるものではなく、世界や用語の用法に関する人間の予備知識の一部です。したがって、システムが望ましい結果を得られるようにするためには、この対応関係に関する知識を持っていなければなりません。 OWL 2では、いわゆるサブクラス公理によってこれを実現します。

関数型構文
 SubClassOf( :Woman :Person )
RDF/XML構文
 <owl:Class rdf:about="Woman">
   <rdfs:subClassOf rdf:resource="Person"/>
 </owl:Class>
Turtle構文
 :Woman rdfs:subClassOf :Person .
マンチェスター構文
 Class: Woman
   SubClassOf: Person
OWL/XML構文
 <SubClassOf>
   <Class IRI="Woman"/>
   <Class IRI="Person"/>
 </SubClassOf>

この公理がオントロジーに存在していることにより、女性というクラスのインスタンス(人というクラスのインスタンスでもある)として指定したすべての個体に対して推論を行う推論システムが可能になります。大ざっぱに言えば、「あらゆるAがBである」という表現が意味をなし、正しい場合には、2つのクラスAとBのサブクラス関係を指定できます。

オントロジーのモデル化では、そのような相互依存性を散発的に宣言するためだけでなく、関心領域のあらゆるクラスの汎化関係を定めることによって、クラスの階層全体をモデル化するために、サブクラスのステートメントを用いるのが一般です。あらゆる母(Mother)が女性であるということも述べたいと仮定してください。

関数型構文
 SubClassOf( :Mother :Woman )
RDF/XML構文
 <owl:Class rdf:about="Mother">
   <rdfs:subClassOf rdf:resource="Woman"/>
 </owl:Class>
Turtle構文
 :Mother rdfs:subClassOf :Woman .
マンチェスター構文
 Class: Mother
   SubClassOf: Woman
OWL/XML構文
 <SubClassOf>
   <Class IRI="Mother"/>
   <Class IRI="Woman"/>
 </SubClassOf>

推論システムは、母であると分類されているあらゆる一つの個体が、女性(それゆえに、人)でもあるということだけでなく、母は人のサブクラスでなければならない(我々の直観通りに)ということも導き出せます。技術的には、これは、クラスとのサブクラス関係が推移的であるということを意味します。一方で、反射的でもあります。これは、あらゆるクラスがそれ自身のサブクラスであることを意味し、明らかにすべての人は人であるため、直感的でもあります。

我々の語彙の複数のクラスは、事実上、同じ集合を指す可能性があり、OWLは、それらが意味的に同等であると見なすメカニズムを備えています。例えば、「人」と「人間」という用語を同じ意味で用い、それは、人というクラスのあらゆるインスタンスが人間というクラスのインスタンスでもあり、その逆もまた同様であることを意味します。全く同じ個体を含む場合には、2つのクラスは同等であると見なされます。次の例は、人というクラスが人間(Human)というクラスと同等であると述べています。

関数型構文
 EquivalentClasses( :Person :Human )
RDF/XML構文
 <owl:Class rdf:about="Person">
   <owl:equivalentClass rdf:resource="Human"/>
 </owl:Class>
Turtle構文
 :Person owl:equivalentClass :Human .
マンチェスター構文
 Class: Person
   EquivalentTo: Human
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="Person"/>
   <Class IRI="Human"/>
 </EquivalentClasses>

人と人間が同等であると述べることは、人は人間のサブクラスであり、人間は人のサブクラスでもあると述べることと完全に同じです。

4.3 素であるクラス

4.1項で、個体は複数のクラスのインスタンスになりえることを述べました。しかし、あるクラスのメンバーシップが別のクラスのメンバーシップを明らかに排除する場合があります。例えば、男性と女性のクラスの例では、両方のクラスのインスタンスである個体が存在することを排除できます(例示を目的としているため、ここでは、生物学的に不明確な事例を無視します)。クラス間のこの「不一致関係」は、素である(クラス)と呼びます。先と同様に、2つのクラスが素であるという情報は、我々の予備知識の一部であり、推論システムがそれを利用するためには、明示しておく必要があります。これは、次のように実現します。

関数型構文
 DisjointClasses( :Woman :Man )
RDF/XML構文
 <owl:AllDisjointClasses>
   <owl:members rdf:parseType="Collection">
     <owl:Class rdf:about="Woman"/>
     <owl:Class rdf:about="Man"/>
   </owl:members>
 </owl:AllDisjointClasses>
Turtle構文
 []  rdf:type     owl:AllDisjointClasses ;
     owl:members  ( :Woman  :Man ) . 
マンチェスター構文
 DisjointClasses: Woman, Man
OWL/XML構文
 <DisjointClasses>
     <Class IRI="Woman"/>
     <Class IRI="Man"/>
 </DisjointClasses>

実際には、素のステートメントは、忘れらたり無視されることが多いです。その理由は、議論の余地がありますが、他の証拠がなければ、直観的にクラスは素であると見なされるためかもしれません。素のステートメントを省略すると、多くの潜在的に有益な結果を失う可能性があります。ここの例では、メアリーが男性でないと推論するために、素の公理が必要であることに注意してください。さらに、上記の公理に対し、推論システムは、母というクラスと男性というクラスが素であることを推論できます。

4.4 オブジェクト・プロパティー

以前の項では、一つの個体、そのクラスのメンバーシップ、そして、インスタンスに基づいて複数のクラスを互いに関連づける方法を説明しました。しかし、しばしば、オントロジーは、個体を他の個体に関連づける方法を指定するためのものでもあります。家族について記述する場合には、これらの関係は重要です。 メアリーがジョンの妻であることを示すことから始めます。

関数型構文
 ObjectPropertyAssertion( :hasWife :John :Mary )
RDF/XML構文
 <rdf:Description rdf:about="John">
   <hasWife rdf:resource="Mary"/>
 </rdf:Description>
Turtle構文
 :John :hasWife :Mary .
マンチェスター構文
 Individual: John
   Facts: hasWife Mary
OWL/XML構文
 <ObjectPropertyAssertion>
   <ObjectProperty IRI="hasWife"/>
   <NamedIndividual IRI="John"/>
   <NamedIndividual IRI="Mary"/>
 </ObjectPropertyAssertion>

ここで、個体がどのような方法で関連づけられているかを記述しているエンティティー(例えば、ここの例では、hasWife(妻を持つ))は、プロパティーと呼ばれます。

個体が記述されている順序が重要であることに注意してください。「メアリーはジョンの妻である」は、真でありえますが、「ジョンはメアリーの妻である」は全く真ではありません。実際、これは、モデル化にありがちなエラーの原因で、一つの直感的な解釈のみが認められたプロパティー名を用いることによって避けることができます。名詞(「妻」(wife)など)の場合、そのような一意の名前は「of」や「has」を付与した構造(wifeOfやhasWife)でありえます。動詞(「愛する」(to love)など)の場合には、活用形(愛する(loves))や「by」を付与した受動態(lovedBy)により、予期せぬ解釈を防げるでしょう。

2つの個体がプロパティーによって結合されていないと述べることもできます。例えば、次は、メアリーがビルの妻でないと述べています。

関数型構文
 NegativeObjectPropertyAssertion( :hasWife :Bill :Mary )
RDF/XML構文
 <owl:NegativePropertyAssertion>
   <owl:sourceIndividual rdf:resource="Bill"/>
   <owl:assertionProperty rdf:resource="hasWife"/>
   <owl:targetIndividual rdf:resource="Mary"/>
 </owl:NegativePropertyAssertion>
Turtle構文
 []  rdf:type               owl:NegativePropertyAssertion ;
     owl:sourceIndividual   :Bill ;
     owl:assertionProperty  :hasWife ;
     owl:targetIndividual   :Mary .
マンチェスター構文
 Individual: Bill
   Facts: not hasWife Mary
OWL/XML構文
 <NegativeObjectPropertyAssertion>
   <ObjectProperty IRI="hasWife"/>
   <NamedIndividual IRI="Bill"/>
   <NamedIndividual IRI="Mary"/>
 </NegativeObjectPropertyAssertion>

否定のプロパティー言明は、真でないことが分かっているステートメントを行う唯一の機会を提供してくれます。何かを述べるまでは何でもありえるというのが既定の姿勢であるOWLにおいては、この種の情報は特に重要です。

4.5 プロパティーの階層

4.2項では、1つのクラスのメンバーシップが別のメンバーシップを含むと記述することが有益であると論じました。基本的に、プロパティーの場合も同じ状況は起こりえます。例えば、BがAの妻であることが分かっている場合には、Bは常にAの配偶者でもあることは明らかです(その逆は真でないことに注意)。OWLでは、このステートメントを次の通りに記述します。

関数型構文
 SubObjectPropertyOf( :hasWife :hasSpouse )
RDF/XML構文
 <owl:ObjectProperty rdf:about="hasWife">
   <rdfs:subPropertyOf rdf:resource="hasSpouse"/>
 </owl:ObjectProperty>
Turtle構文
 :hasWife rdfs:subPropertyOf :hasSpouse .
マンチェスター構文
 ObjectProperty: hasWife
   SubPropertyOf: hasSpouse
OWL/XML構文
 <SubObjectPropertyOf>
   <ObjectProperty IRI="hasWife"/>
   <ObjectProperty IRI="hasSpouse"/>
 </SubObjectPropertyOf>

プロパティー同等には、構文の省略形もあり、その点で、クラスの同等性と類似しています。

4.6 定義域と値域の制限

しばしば、2つの個体が特定のプロパティーによって互いに関連づけられているという情報によって、個体自身に関する更なる結論を出すことが可能になります。特に、クラスのメンバーシップを推論することができます。例えば、BがAの妻であるというステートメントは、明らかにBが女性でAが男性であることを含意します。そのため、ある意味で、2つの個体が特定のプロパティーで関連づけられているというステートメントは、これらの個体に関する暗黙の追加情報を含んでいます。ここの例では、この追加情報は、クラスのメンバーシップで表現できます。OWLはこの対応関係を記述する方法を提供します。

関数型構文
 ObjectPropertyDomain( :hasWife :Man ) 
 ObjectPropertyRange( :hasWife :Woman ) 
RDF/XML構文
 <owl:ObjectProperty rdf:about="hasWife">
   <rdfs:domain rdf:resource="Man"/>
   <rdfs:range rdf:resource="Woman"/>
 </owl:ObjectProperty>
Turtle構文
 :hasWife rdfs:domain :Man ;
          rdfs:range  :Woman .
マンチェスター構文
 ObjectProperty: hasWife
   Domain: Man
   Range: Woman
OWL/XML構文
 <ObjectPropertyDomain>
   <ObjectProperty IRI="hasWife"/>
   <Class IRI="Man"/>
 </ObjectPropertyDomain>
 <ObjectPropertyRange>
   <ObjectProperty IRI="hasWife"/>
   <Class IRI="Woman"/>
 </ObjectPropertyRange>

これらの2つの公理が存在していて、例えば、サーシャはhasWifeというプロパティーでヒラリーと関連づられているという情報があれば、推論システムは、サーシャが男性であり、ヒラリーが女性であると推論できるでしょう。

4.7 個体の同等性と不同等性

今までに提供した情報から、ジョンとメアリーは、それぞれ男性と女性という素のクラスのインスタントであることが分かっているため、彼らが同じ個体でないと推論できることに注意してください。しかし、別の家族の情報、例えばビルを追加して、彼が男性であると示せば、今までのところ、ジョンとビルが同じでないことを意味することは何も述べられていません。OWLは、異なる名前が異なる個体の名前であるとは想定しません。(この、必須の「単一名仮定」の欠如は、同じ個体を参照している名前が様々なタイミングで様々な組織によって知らないうちに作られるセマンティック・ウェブのアプリケーションに特に適しています。) したがって、ジョンとビルが同じ個体であるという選択肢を排除したい場合は、次の通り、それを明示的に指定しなければなりません。

関数型構文
 DifferentIndividuals( :John :Bill )
RDF/XML構文
 <rdf:Description rdf:about="John">
   <owl:differentFrom rdf:resource="Bill"/>
 </rdf:Description>
Turtle構文
 :John owl:differentFrom :Bill .
マンチェスター構文
 Individual: John 
   DifferentFrom: Bill 
OWL/XML構文
 <DifferentIndividuals>
   <NamedIndividual IRI="John"/>
   <NamedIndividual IRI="Bill"/>
 </DifferentIndividuals>

2つの名前が同じ個体を参照している(意味している)と述べることも可能です。例えば、ジェームズとジムが同じ個体であると述べることができます。

関数型構文
 SameIndividual( :James :Jim )
RDF/XML構文
 <rdf:Description rdf:about="James">
   <owl:sameAs rdf:resource="Jim"/>
 </rdf:Description>
Turtle構文
 :James owl:sameAs :Jim.
マンチェスター構文
 Individual: James   SameAs: Jim
OWL/XML構文
 <SameIndividual>
   <NamedIndividual IRI="James"/>
   <NamedIndividual IRI="Jim"/>
 </SameIndividual>

これにより、推論システムは、ジェームズという個体に関して付与される情報が、ジムという個体にも成り立つと推論することが可能になります。

4.8 データ型

これまで、クラスのメンバーシップ、および、他の個体との関連性によって、どのように個体を記述できるかを見てきました。しかし、多くの場合、個体はデータ値で記述されます。ある人の生年月日、年齢、Eメールアドレスなどを考えてみてください。この目的ために、OWLは別のプロパティー、いわゆるデータ型プロパティーを提供します。これらのプロパティーは、個体を(他の個体ではなく)データ値に関連づけます。そして、XMLスキーマ・データ型[XML Schema Datatypes]の多くを使用できます。 下記は、データ型プロパティーの使用例です。ジョンの年齢が51歳であると述べています。

関数型構文
 DataPropertyAssertion( :hasAge :John "51"^^xsd:integer )
RDF/XML構文
 <Person rdf:about="John">
   <hasAge rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">51</hasAge>
 </Person>
Turtle構文
 :John  :hasAge  51 .
マンチェスター構文
 Individual: John
   Facts: hasAge "51"^^xsd:integer
OWL/XML構文
 <DataPropertyAssertion>
   <DataProperty IRI="hasAge"/>
   <NamedIndividual IRI="John"/>
   <Literal datatypeIRI="http://www.w3.org/2001/XMLSchema#integer">51</Literal>
 </DataPropertyAssertion>

同様に、ジャックの年齢は、53歳ではないと述べることができます。

関数型構文
 NegativeDataPropertyAssertion( :hasAge :Jack "53"^^xsd:integer )
RDF/XML構文
 <owl:NegativePropertyAssertion>
   <owl:sourceIndividual rdf:resource="Jack"/>
   <owl:assertionProperty rdf:resource="hasAge"/>
   <owl:targetValue rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">
     53
   </owl:targetValue>
 </owl:NegativePropertyAssertion>
Turtle構文
 []  rdf:type               owl:NegativePropertyAssertion ;
     owl:sourceIndividual   :Jack ;
     owl:assertionProperty  :hasAge ;
     owl:targetValue        53 .
マンチェスター構文
 Individual: Jack
   Facts: not hasAge "53"^^xsd:integer
OWL/XML構文
 <NegativeDataPropertyAssertion>
   <DataProperty IRI="hasAge"/>
   <NamedIndividual IRI="Jack"/>
   <Literal datatypeIRI="http://www.w3.org/2001/XMLSchema#integer">53</Literal>
 </NegativeDataPropertyAssertion>

定義域と値域は、オブジェクト・プロパティーと同じように、データ型プロパティーに対しても記述できます。しかし、その場合、値域はクラスではなくデータ型でしょう。下記は、hasAgeというプロパティーは、人を負でない整数に関連づけるためだけに用いられると述べています。

関数型構文
 DataPropertyDomain( :hasAge :Person ) 
 DataPropertyRange( :hasAge xsd:nonNegativeInteger ) 
RDF/XML構文
 <owl:DatatypeProperty rdf:about="hasAge">
   <rdfs:domain rdf:resource="Person"/>
   <rdfs:range rdfs:Datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"/> </owl:DatatypeProperty>
Turtle構文
 :hasAge  rdfs:domain  :Person ;
          rdfs:range   xsd:nonNegativeInteger .
マンチェスター構文
 DataProperty: hasAge
   Domain: Person
   Range:  xsd:nonNegativeInteger
OWL/XML構文
 <DataPropertyDomain>
   <DataProperty IRI="hasAge"/>
   <Class IRI="Person"/>
 </DataPropertyDomain>
 <DataPropertyRange>
   <DataProperty IRI="hasAge"/>
   <Datatype IRI="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"/>
 </DataPropertyRange>

この段階で、プロパティーの定義域と値域を用いるときに発生しやすい、ありがちなミスを指摘したいと思います。つい先ほど示した例では、hasAgeというプロパティーが、人を負でない整数に関連づけるためだけに用いられると述べましたが、フェリックスが猫(Cat)というクラスに属しているという情報と、フェリックスの年齢が9歳である(Felix hasAge 9)という情報も指定すると想定してください。これらの情報を結合した場合、フェリックスが人というクラスにも属していると推論される可能性がありますが、これは、たぶん意図しないものです。これは、モデル化にありがちなエラーです。定義域(または、値域)のステートメントは、知識に対する制約ではありませんが、推論システムが更なる知識を推論できることに注意してください。例にあるとおり、年齢が人にのみ付与されると述べた場合、年齢を付与したものはすべて自動的に人になります。

5 高度なクラス関係

前項では、クラスを、名前を持った「曖昧な」ものとして扱いました。個体に特性を付与するためにクラスを使用し、サブクラスや素のステートメントでクラスを他のクラスに関連づけました。

ここでは、名前付きクラス、プロパティー、個体を、新しいクラスを定義するための構成要素としてどのように使用できるかについて説明します。

5.1 複合クラス

今までに説明した言語要素によって、簡単なオントロジーをモデル化できます。より複雑な知識を表わすために、OWLは論理的なクラスのコンストラクタを提供します。特に、OWLは、言語要素に論理積(AND)、論理和(OR)、論理否定(NOT)を提供します。対応するOWLの用語((クラス)積集合和集合補集合)は、集合論から借りたものです。これらのコンストラクタは、原子クラス(すなわち、名前付きクラス)を複合クラスに結合します。

2つのクラスの積集合は、両方のクラスのインスタンスである個体で厳密に構成されます。次の例では、母というクラスが、女性と親(Parent)の両方のインスタンスであるオブジェクトで厳密に構成されていると述べています。

関数型構文
 EquivalentClasses(
   :Mother 
   ObjectIntersectionOf( :Woman :Parent )
 ) 
RDF/XML構文
 <owl:Class rdf:about="Mother">
   <owl:equivalentClass>
     <owl:Class>
       <owl:intersectionOf rdf:parseType="Collection">
         <owl:Class rdf:about="Woman"/>
         <owl:Class rdf:about="Parent"/>
       </owl:intersectionOf>
     </owl:Class>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 :Mother  owl:equivalentClass  [
   rdf:type            owl:Class ;
   owl:intersectionOf  ( :Woman :Parent ) 
 ] .
マンチェスター構文
 Class: Mother
   EquivalentTo: Woman and Parent
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="Mother"/>
   <ObjectIntersectionOf>
     <Class IRI="Woman"/>
     <Class IRI="Parent"/>
   </ObjectIntersectionOf>
 </EquivalentClasses>

これから得られる推論の例は、母というクラスのすべてのインスタンスは、親というクラスにも属しているということを意味します。

2つのクラスの和集合には、少なくともこれらのクラスのうちの1つに含まれているすべての個体が含まれます。したがって、すべての両親のクラスは、母と父のクラスの和集合であると見なすことができます。

関数型構文
 EquivalentClasses(
   :Parent 
   ObjectUnionOf( :Mother :Father )
 ) 
RDF/XML構文
 <owl:Class rdf:about="Parent">
   <owl:equivalentClass>
     <owl:Class>
       <owl:unionOf rdf:parseType="Collection">
         <owl:Class rdf:about="Mother"/>
         <owl:Class rdf:about="Father"/>
       </owl:unionOf>
     </owl:Class>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 :Parent  owl:equivalentClass  [
   rdf:type     owl:Class ;
   owl:unionOf  ( :Mother :Father )
 ] .
マンチェスター構文
 Class: Parent
   EquivalentTo: Mother or Father
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="Parent"/>
   <ObjectUnionOf>
     <Class IRI="Mother"/>
     <Class IRI="Father"/>
   </ObjectUnionOf>
 </EquivalentClasses>

クラスの補集合は、論理否定に相当し、クラス自体のメンバーでないオブジェクトで厳密に構成されます。下記の、子供のいない人の定義は、クラスの補集合を用いており、クラスのコンストラクタを入れ子にできることを示しています。

関数型構文
 EquivalentClasses(
   :ChildlessPerson 
   ObjectIntersectionOf(
     :Person 
     ObjectComplementOf( :Parent )
   )
 ) 
RDF/XML構文
 <owl:Class rdf:about="ChildlessPerson">
   <owl:equivalentClass>
     <owl:Class>
       <owl:intersectionOf rdf:parseType="Collection">
         <owl:Class rdf:about="Person"/>
         <owl:Class>
           <owl:complementOf rdf:resource="Parent"/>
         </owl:Class>
       </owl:intersectionOf>
     </owl:Class>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 :ChildlessPerson  owl:equivalentClass  [
   rdf:type            owl:Class ;
   owl:intersectionOf  ( :Person  [ owl:complementOf  :Parent ] ) 
 ] .
マンチェスター構文
 Class: ChildlessPerson
   EquivalentTo: Person and not Parent
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="ChildlessPerson"/>
   <ObjectIntersectionOf>
     <Class IRI="Person"/>
     <ObjectComplementOf>
       <Class IRI="Parent"/>
     </ObjectComplementOf>
   </ObjectIntersectionOf>
 </EquivalentClasses>

上のすべての例は、新しいクラスが他のクラスを組み合わせたものであると定義するために、クラスのコンストラクタの使用例を示しています。しかし、もちろん、クラスにとって必要だが十分ではない状況を示すために、クラスのコンストラクタをサブクラスのステートメントと一緒に用いることもできます。次のステートメントは、あらゆる祖父(Grandfather)は、男性と親の両方である(その逆は、必ずしも真ではない)ことを示しています。

関数型構文
 SubClassOf( 
   :Grandfather 
   ObjectIntersectionOf( :Man :Parent )
 )
RDF/XML構文
 <owl:Class rdf:about="Grandfather">
   <rdfs:subClassOf>
     <owl:Class>
       <owl:intersectionOf rdf:parseType="Collection">
         <owl:Class rdf:about="Man"/>
         <owl:Class rdf:about="Parent"/>
       </owl:intersectionOf>
     </owl:Class>
   </rdfs:subClassOf>
 </owl:Class>
Turtle構文
 :Grandfather  rdfs:subClassOf  [
   rdf:type            owl:Class ;
   owl:intersectionOf  ( :Man  :Parent )
 ] .
マンチェスター構文
 Class: Grandfather
   SubClassOf: Man and Parent
OWL/XML構文
 <SubClassOf>
   <Class IRI="Grandfather"/>
   <ObjectIntersectionOf>
     <Class IRI="Man"/>
     <Class IRI="Parent"/>
   </ObjectIntersectionOf>
 </SubClassOf>

一般的に、複合クラスは、名前付きクラスが出現可能なあらゆる場所、つまり、クラス言明で使用できます。これは、ジャックが人ではあるが親ではないと言明している次の例で示しています。

関数型構文
 ClassAssertion(
   ObjectIntersectionOf(
     :Person 
     ObjectComplementOf( :Parent )
   ) 
   :Jack )
RDF/XML構文
 <rdf:Description rdf:about="Jack">
   <rdf:type>
     <owl:Class>
       <owl:intersectionOf  rdf:parseType="Collection">
         <owl:Class rdf:about="Person"/>
         <owl:Class>
           <owl:complementOf rdf:resource="Parent"/>
         </owl:Class>
       </owl:intersectionOf>
     </owl:Class>
   </rdf:type>
 </rdf:Description>
Turtle構文
 :Jack  rdf:type  [
   rdf:type            owl:Class ;
   owl:intersectionOf  ( :Person  
                         [ rdf:type          owl:Class ;
                           owl:complementOf  :Parent     ]
                       )
 ] .
マンチェスター構文
 Individual: Jack
   Types: Person and not Parent
OWL/XML構文
 <ClassAssertion>
   <ObjectIntersectionOf>
    <Class IRI="Person"/>
    <ObjectComplementOf>
      <Class IRI="Parent"/>
    </ObjectComplementOf>
   </ObjectIntersectionOf>
   <NamedIndividual IRI="Jack"/>
 </ClassAssertion>

5.2 プロパティー制限

プロパティーの制限は、複合クラスに別のタイプの論理ベースのコンストラクタを提供します。名前が示すように、プロパティー制限は、プロパティーを含んだコンストラクタを用います。

特称量化と呼ばれるプロパティー制限は、クラスは、ある特定のプロパティーによって、あるクラスのインスタンスである別の個体に関連づけられたすべての個体の集合であると定義します。これは、両親のクラスは、hasChildというプロパティーによって人にリンクされた個体のクラスであると定義している次の例のように、例を用いて説明するのが最も良いでしょう。

関数型構文
 EquivalentClasses(
   :Parent 
   ObjectSomeValuesFrom( :hasChild :Person )
 )
RDF/XML構文
 <owl:Class rdf:about="Parent">
   <owl:equivalentClass>
     <owl:Restriction>
       <owl:onProperty rdf:resource="hasChild"/>
       <owl:someValuesFrom rdf:resource="Person"/>
     </owl:Restriction>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 :Parent  owl:equivalentClass  [
   rdf:type            owl:Restriction ;
   owl:onProperty      :hasChild ;
   owl:someValuesFrom  :Person
 ] .
マンチェスター構文
 Class: Parent
   EquivalentTo: hasChild some Person
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="Parent"/>
   <ObjectSomeValuesFrom>
     <ObjectProperty IRI="hasChild"/>
     <Class IRI="Person"/>
   </ObjectSomeValuesFrom>
 </EquivalentClasses>

これは、親のすべてのインスタンスに対して少なくとも1人の子供が存在し、その子供が人というクラスのメンバーであると予期されることを意味します。これは、不完全な知識を捕捉するために有用です。例えば、ボブは親であるとサリーが述べると、我々は、彼らの名前を知らなくても彼には少なくとも1人の子供がいると推論できます。特称量化を使用する際の自然言語インジケータは、「いくつか」(some)や「1つ」(one)のような単語です。

全称量化と呼ばれる、別のプロパティー制限は、関連づけられているすべての個体が特定のクラスのインスタンスでなければならない個体のクラスを記述するために用います。次のステートメントを用いて、自分のすべての子供が幸せな人(HappyPerson)であれば、その人は幸せな人であるということを示すことができます。

関数型構文
 EquivalentClasses(
   :HappyPerson 
   ObjectAllValuesFrom( :hasChild :HappyPerson )
 )
RDF/XML構文
 <owl:Class>
   <owl:Class rdf:about="HappyPerson"/>
   <owl:equivalentClass>
     <owl:Restriction>
       <owl:onProperty rdf:resource="hasChild"/>
       <owl:allValuesFrom rdf:resource="HappyPerson"/>
     </owl:Restriction>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 []  rdf:type             owl:Class ;
     :HappyPerson ;
     owl:equivalentClass  [
       rdf:type           owl:Restriction ;
       owl:onProperty     :hasChild ;
       owl:allValuesFrom  :Happy
     ] .
マンチェスター構文
 Class: HappyPerson
   EquivalentTo: hasChild only HappyPerson
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="HappyPerson"/>
   <ObjectAllValuesFrom>
     <ObjectProperty IRI="hasChild"/>
     <Class IRI="Happy"/>
   </ObjectAllValuesFrom>
 </EquivalentClasses>

この例では、OWLステートメントは、一種の自己参照が可能であることも示しています。幸せな人というクラスが、同等ステートメントの両側で用いられています。

プロパティー制限の使用は、「モデル化の初心者」に、ある種の概念上の混乱を生じさせるかもしれません。大ざっぱに言えば、自然言語のステートメントを論理的な公理に翻訳する場合には、特称量化の方がはるかに頻繁に発生します。全称量化を使用する際の自然言語インジケータは、「単に/唯一の」(only)、「排他的に」(exclusively)や「~にすぎない」(nothing but)のような単語です。

全称的な役割の制限には、ある特定の誤解があります。上記の幸せの公理を例として考えてみます。直感的には、幸せであるためには、少なくとも1人の幸せな子供を持っていなければならないと解釈できます。しかし、そうではありません。hasChildというプロパティーの「出発点」ではない個体は、hasChildに対する全称量化によって定義されたクラスのメンバーです。したがって、上記のステートメントでは、すべての子供のない人は幸せでありえます。前述の通りに意図した解釈を形式化するためには、ステートメントを次の通りに書かなければならないでしょう。

関数型構文
 EquivalentClasses(
   :HappyPerson 
   ObjectIntersectionOf(
     ObjectAllValuesFrom( :hasChild :HappyPerson )
     ObjectSomeValuesFrom( :hasChild :HappyPerson )
   )
 )
RDF/XML構文
 <owl:Class>
   <owl:Class rdf:about="HappyPerson"/>
   <owl:equivalentClass>
     <owl:Class>
       <owl:intersectionOf rdf:parseType="Collection">
         <owl:Restriction>
           <owl:onProperty rdf:resource="hasChild"/>
           <owl:allValuesFrom rdf:resource="HappyPerson"/>
         </owl:Restriction>
         <owl:Restriction>
           <owl:onProperty rdf:resource="hasChild"/>
           <owl:someValuesFrom rdf:resource="HappyPerson"/>
         </owl:Restriction>
        </owl:intersectionOf>
     </owl:Class>
   </owl:equivalentClass> </owl:Class>
Turtle構文
 []  rdf:type             owl:Class ;
     :HappyPerson ;
     owl:equivalentClass  [
       rdf:type            owl:Class ;
       owl:intersectionOf  ( [ rdf:type            owl:Restriction ;
                               owl:onProperty      :hasChild ;
                               owl:allValuesFrom   :Happy            ]
                             [ rdf:type            owl:Restriction ;
                               owl:onProperty      :hasChild ;
                               owl:someValuesFrom  :Happy            ]
                           )
     ] .
マンチェスター構文
 Class: HappyPerson
   EquivalentTo: hasChild only HappyPerson and hasChild some HappyPerson
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="HappyPerson"/>
   <ObjectIntersectionOf>
     <ObjectAllValuesFrom>
       <ObjectProperty IRI="hasChild"/>
       <Class IRI="HappyPerson"/>
     </ObjectAllValuesFrom>
     <ObjectSomeValuesFrom>
       <ObjectProperty IRI="hasChild"/>
       <Class IRI="HappyPerson"/>
     </ObjectSomeValuesFrom>
   </ObjectIntersectionOf>
 </EquivalentClasses>

この例は、プロパティー制限を、複合クラスとどのように入れ子にできるかも示しています。

1つの特定の個体に関連づけられている個体のクラスを記述するためにプロパティー制限を使用できます。例えば、ジョンの子供のクラスを、次の通りに定義できます。

関数型構文
 EquivalentClasses( 
   :JohnsChildren 
   ObjectHasValue( :hasParent :John )
 )
RDF/XML構文
 <owl:Class rdf:about="JohnsChildren">
   <owl:equivalentClass>
     <owl:Restriction>
       <owl:onProperty rdf:resource="hasParent"/>
       <owl:hasValue rdf:resource="John"/>
     </owl:Restriction>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 :JohnsChildren  owl:equivalentClass  [
   rdf:type        owl:Restriction ;
   owl:onProperty  :hasParent ;
   owl:hasValue    :John
 ] .
マンチェスター構文
 Class: JohnsChildren
   EquivalentTo: hasParent value John
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="JohnsChildren"/>
   <ObjectHasValue>
     <ObjectProperty IRI="hasParent"/>
     <NamedIndividual IRI="John"/>
   </ObjectHasValue>
 </EquivalentClasses>

プロパティーでリンクされている個体という特殊なケースでは、個体は、自身にリンクされているかもしれません。次の例は、すべてのナルシストが自身を愛しているという考えを表わす方法を示しています。

関数型構文
 EquivalentClasses(
   :NarcisticPerson 
   ObjectHasSelf( :loves ) 
 )
RDF/XML構文
 <owl:Class rdf:about="NarcisticPerson">
   <owl:equivalentClass>
     <owl:Restriction>
       <owl:onProperty rdf:resource="loves"/>
       <owl:hasSelf rdf:datatype="&xsd;boolean">
         true
       </owl:hasSelf>
     </owl:Restriction>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 :NarcisticPerson owl:equivalentClass  [
   rdf:type        owl:Restriction ;
   owl:onProperty  :loves ;
   owl:hasSelf     "true"^^xsd:boolean .
 ] .
マンチェスター構文
 Class: NarcisticPerson
   EquivalentTo: loves Self
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="NarcisticPerson"/>   <ObjectHasSelf>
     <ObjectProperty IRI="loves"/>
   </ObjectHasSelf>
 </EquivalentClasses>

5.3 プロパティーのカーディナリティー制限

全称量化および特称量化を用いると、だれかの子供のうちの少なくとも1人などの、すべてに関して、個々に何かを述べることができます。しかし、制限に含まれる個体の数を指定したい場合があります。実際、子供の数に応じたクラスを作成できます。 次の例は、ジョンには、自身も親である子供が最大4人いると述べています。

関数型構文
 ClassAssertion(
   ObjectMaxCardinality( 4 :hasChild :Parent ) 
   :John
 )
RDF/XML構文
 <rdf:Description rdf:about="John">
   <rdf:type>
     <owl:Restriction>
       <owl:maxQualifiedCardinality rdf:datatype="&xsd;nonNegativeInteger">
         4
       </owl:maxQualifiedCardinality>
       <owl:onProperty rdf:resource="hasChild"/>
       <owl:onClass rdf:resource="Parent"/>
     </owl:Restriction>
   </rdf:type>
 </rdf:Description>
Turtle構文
 :John  rdf:type  [
   rdf:type                     owl:Restriction ;
   owl:maxQualifiedCardinality  "4"^^xsd:nonNegativeInteger ;
   owl:onProperty               :hasChild ;
   owl:onClass                  :Parent
 ] .
マンチェスター構文
 Individual: John
   Types: hasChild max 4 Parent
OWL/XML構文
 <ClassAssertion>
   <ObjectMaxCardinality cardinality="4">
     <ObjectProperty IRI="hasChild"/>
     <Class IRI="Parent"/>
   </ObjectMaxCardinality>
   <NamedIndividual IRI="John"/>
 </ClassAssertion>

このステートメントにより、ジョンが、親ではない子供を任意の数だけ持つことができることに注意してください。

同様に、ジョンが、親である子供が少なくとも2人いる個体のクラスのインスタンスであると述べることによって、最小の数を宣言することも可能です。

関数型構文
 ClassAssertion(
   ObjectMinCardinality( 2 :hasChild :Parent ) 
   :John
 )
RDF/XML構文
 <rdf:Description rdf:about="John">
   <rdf:type>
     <owl:Restriction>
       <owl:minQualifiedCardinality rdf:datatype="&xsd;nonNegativeInteger">
         2
       </owl:minQualifiedCardinality>
       <owl:onProperty rdf:resource="hasChild"/>
       <owl:onClass rdf:resource="Parent"/>
     </owl:Restriction>
   </rdf:type>
 </rdf:Description>
Turtle構文
 :John  rdf:type  [
   rdf:type                     owl:Restriction ;
   owl:minQualifiedCardinality  "2"^^xsd:nonNegativeInteger ;
   owl:onProperty               :hasChild ;
   owl:onClass                  :Parent
 ] .
マンチェスター構文
 Individual: John
   Types: hasChild min 2 Parent
OWL/XML構文
 <ClassAssertion>
   <ObjectMinCardinality cardinality="2">
     <ObjectProperty IRI="hasChild"/>
     <Class IRI="Parent"/>
   </ObjectMinCardinality>
   <NamedIndividual IRI="John"/>
 </ClassAssertion>

親であるジョンの子供の正確な数をたまたま知っていれば、次の通りに指定できます。

関数型構文
 ClassAssertion( 
   ObjectExactCardinality( 3 :hasChild :Parent ) 
   :John
 ) 
RDF/XML構文
 <rdf:Description rdf:about="John">
   <rdf:type>
     <owl:Restriction>
       <owl:qualifiedCardinality rdf:datatype="&xsd;nonNegativeInteger">
         3
       </owl:qualifiedCardinality>
       <owl:onProperty rdf:resource="hasChild"/>
       <owl:onClass rdf:resource="Parent"/>
     </owl:Restriction>
   </rdf:type>
 </rdf:Description>
Turtle構文
 :John  rdf:type  [
   rdf:type                  owl:Restriction ;
   owl:qualifiedCardinality  "3"^^xsd:nonNegativeInteger ;
   owl:onProperty            :hasChild ;
   owl:onClass               :Parent
 ] .
マンチェスター構文
 Individual: John
   Types: hasChild exactly 3 Parent
OWL/XML構文
 <ClassAssertion>
   <ObjectExactCardinality cardinality="3">
     <ObjectProperty IRI="hasChild"/>
     <Class IRI="Parent"/>
   </ObjectExactCardinality>
   <NamedIndividual IRI="John"/>
 </ClassAssertion>

カーディナリティー制限では、クラスの提供は任意です。ジョンのすべての子供の数について述べたいだけであれば、次の通りに記述できます。

関数型構文
 ClassAssertion(
   ObjectExactCardinality( 5 :hasChild )    :John
 )
RDF/XML構文
 <rdf:Description rdf:about="John">
   <rdf:type>
     <owl:Restriction>
       <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">
         5
       </owl:cardinality>
       <owl:onProperty rdf:resource="hasChild"/>
     </owl:Restriction>
   </rdf:type>
 </rdf:Description>
Turtle構文
 :John  rdf:type  [
   rdf:type         owl:Restriction ;
   owl:cardinality  "5"^^xsd:nonNegativeInteger ;   owl:onProperty   :hasChild
 ] .
マンチェスター構文
 Individual: John
   Types: hasChild exactly 5
OWL/XML構文
 <ClassAssertion>
   <ObjectExactCardinality cardinality="5">
     <ObjectProperty IRI="hasChild"/>
   </ObjectExactCardinality>
   <NamedIndividual IRI="John"/>
 </ClassAssertion>

5.4 個体の列挙

クラスを記述する非常に簡単な方法は、すべてのインスタンスを列挙することです。OWLでは、これが可能です。例えば、誕生日のゲストのクラスを作成できます。

関数型構文
 EquivalentClasses(
   :MyBirthdayGuests
   ObjectOneOf( :Bill :John :Mary)
 )
RDF/XML構文
 <owl:Class rdf:about="MyBirthdayGuests">
   <owl:equivalentClass>
     <owl:Class>
       <owl:oneOf rdf:parseType="Collection">
         <rdf:Description rdf:about="Bill"/>
         <rdf:Description rdf:about="John"/>
         <rdf:Description rdf:about="Mary"/>
       </owl:oneOf>
     </owl:Class>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 :MyBirthdayGuests  owl:equivalentClass  [
   rdf:type   owl:Class ;
   owl:oneOf  ( :Bill  :John  :Mary )
 ] .
マンチェスター構文
 Class: MyBirthdayGuests
   EquivalentTo: { Bill, John, Mary }
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="MyBirthdayGuests"/>
   <ObjectOneOf>
     <NamedIndividual IRI="Bill"/>
     <NamedIndividual IRI="John"/>
     <NamedIndividual IRI="Mary"/>
   </ObjectOneOf>
 </EquivalentClasses>

4.1項で説明しているように、この公理が、ビル、ジョン、メアリーというクラスのメンバーシップを単に言明するより多くの情報を提供していることに注意してください。それに加えて、ビル、ジョン、メアリーが、誕生日のゲスト(MyBirthdayGuests)の唯一の(only)メンバーであることを規定しています。したがって、このように定義されたクラスは、閉じたクラスや列挙された集合と呼ばれることがあります。ここで、ジェフをMyBirthdayGuestsのインスタンスであると言明すれば、その結果、ジェフは上記の3人のうちのひとりに相当しなければならないことになります。

6 プロパティーの高度な使用

これまでは、クラス式の構成要素として使用されているだけのクラスとプロパティーに焦点を合わせてきました。以下では、OWL 2が、プロパティーを用いたどのようなモデル化性能を他に備えているかを見ていきます。

6.1 プロパティーの特性

あるプロパティーは、別のプロパティーを持ってきて、その方向性を変える(すなわち、逆にする)ことで得られることがあります。例えば、親を持つ(hasParent)は、子どもを持つ(hasChild)の逆のプロパティーと定義できます。

関数型構文
 InverseObjectProperties( :hasParent :hasChild ) 
RDF/XML構文
 <owl:ObjectProperty rdf:about="hasParent">
   <owl:inverseOf rdf:resource="hasChild"/> </owl:ObjectProperty>
Turtle構文
 :hasParent owl:inverseOf :hasChild .
マンチェスター構文
 ObjectProperty: hasParent
   InverseOf: hasChild
OWL/XML構文
 <InverseObjectProperties>
   <ObjectProperty IRI="hasParent"/>
   <ObjectProperty IRI="hasChild"/> </InverseObjectProperties>

例えば、これは、任意の個体AとBに関し、子供を持つというプロパティーでAがBにリンクされていれば、BとAは、親を持つというプロパティーによってリンクされていると推論することができます。 しかし、たとえば、クラス式に使いたいだけであれば、プロパティの逆に対して明示的に名前を付ける必要はありません。孤児(Orphan)というクラスの定義に、親を持つ(hasParent)という新しいプロパティーを用いる代わりに、子供を持つの逆(hasChild-inverse)と直接的に記述できます。

関数型構文
 EquivalentClasses(
   :Orphan
   ObjectAllValuesFrom(
     ObjectInverseOf( :hasChild )
     :Dead
   )
 ) 
RDF/XML構文
 <owl:Class rdf:about="Orphan">
   <owl:equivalentClass>
     <owl:Restriction>
       <owl:onProperty>
         <owl:ObjectProperty>
           <owl:inverseOf rdf:resource="hasChild"/>
         </owl:ObjectProperty>
       </owl:onProperty>
       <owl:Class rdf:resource="Dead"/>
     </owl:Restriction>
   </owl:equivalentClass>
 </owl:Class>
Turtle構文
 :Orphan  owl:equivalentClass  [
   rdf:type           owl:Restriction ;
   owl:onProperty     [ owl:inverseOf  :hasChild ] ;
   owl:allValuesFrom  :Dead 
 ] .
マンチェスター構文
 Class: Orphan
   EquivalentTo: inverse hasChild only Dead
OWL/XML構文
 <EquivalentClasses>
   <Class IRI="Orphan"/>
   <ObjectAllValuesFrom>
     <ObjectInverseOf>
       <ObjectProperty IRI="hasChild"/>
     </ObjectInverseOf>
     <Class IRI="Dead"/>
   </ObjectAllValuesFrom>
 </EquivalentClasses>

プロパティーとその逆が一致すること、言い換えれば、プロパティーの方向性が重要ではない場合があります。例えば、配偶者を持つ(hasSpouse)というプロパティーによって、BがAと関連づけられていれば、AはBに必ず関連づけられています。理由は明らかですが、この特性を有するプロパティーを対称的と呼びます。次の通りに指定できます。

関数型構文
 SymmetricObjectProperty( :hasSpouse ) 
RDF/XML構文
 <owl:SymmetricProperty rdf:about="hasSpouse"/>
Turtle構文
 :hasSpouse  rdf:type  owl:SymmetricProperty .
マンチェスター構文
 ObjectProperty: hasSpouse
   Characteristics: Symmetric
OWL/XML構文
 <SymmetricObjectProperty>
   <ObjectProperty IRI="hasSpouse"/>
 </SymmetricObjectProperty>

その一方で、プロパティーは非対称的でもありえ、これによってAがBに関連づけられていれば、BはAに決して関連づけられていないことを意味します。明らかに(タイムトラベルによって起こる逆説的なシナリオを除き)、これは、子供を持たないというプロパティーに当てはまるケースであり、次のように表現されます。

関数型構文
 AsymmetricObjectProperty( :hasChild ) 
RDF/XML構文
 <owl:AsymmetricProperty rdf:about="hasChild"/>
Turtle構文
 :hasChild  rdf:type  owl:AsymmetricProperty .
マンチェスター構文
 ObjectProperty: hasChild
   Characteristics: Asymmetric
OWL/XML構文
 <AsymmetricObjectProperty>
   <ObjectProperty IRI="hasChild"/>
 </AsymmetricObjectProperty>

非対称的であることが、対称的ではないという概念よりはるかに強いことに注意してください。同様に、対称的であることは、非対称ではないという概念よりはるかに強いです。

以前、サブプロパティーはサブクラスと類似していると考えていました。素のクラスの概念を、プロパティーに転用することも成り立つことが判明しました。つまり、2つのプロパティーは、その両方のプロパティーによってリンクされている2つの個体が存在していない場合には、素です。次に、普通法に従えば、親子間の結婚は発生しえないと述べることができます。

関数型構文
 DisjointObjectProperties( :hasParent :hasSpouse )  
RDF/XML構文
 <rdf:Description rdf:about="hasParent">
   <owl:propertyDisjointWith rdf:resource="hasSpouse"/>
 </rdf:Description>
Turtle構文
 :hasParent  owl:propertyDisjointWith  :hasSpouse .
マンチェスター構文
 DisjointProperties: hasParent, hasSpouse
OWL/XML構文
 <DisjointObjectProperties>
   <ObjectProperty IRI="hasParent"/>
   <ObjectProperty IRI="hasSpouse"/>
 </DisjointObjectProperties>

プロパティーは、反射的でもありえます。そのようなプロパティーは、すべてを自身と関連づけています。次の例では、誰もが自身を親類として持っていることに注意してください。

関数型構文
 ReflexiveObjectProperty( :hasRelative )
RDF/XML構文
 <owl:ReflexiveProperty rdf:about="hasRelative"/>
Turtle構文
 :hasRelative  rdf:type  owl:ReflexiveProperty .
マンチェスター構文
 ObjectProperty: hasRelative
   Characteristics: Reflexive
OWL/XML構文
 <ReflexiveObjectProperty>
   <ObjectProperty IRI="hasRelative"/>
 </ReflexiveObjectProperty>

これは、反射的なプロパティーによって関係づけられている2つの個体が同一であることを必ずしも意味するわけではないことに注意してください。

さらに、プロパティーは非反射的でもありえ、個体は、その役割のままで自身に関係づけることができないことを意味します。典型的な例は、次の通り、だれも自分自身の親にはなれないと単に述べるものです。

関数型構文
 IrreflexiveObjectProperty( :parentOf )   
RDF/XML構文
 <owl:IrreflexiveProperty rdf:about="parentOf"/>
Turtle構文
 :parentOf  rdf:type  owl:IrreflexiveProperty .
マンチェスター構文
 ObjectProperty: parentOf
   Characteristics: Irreflexive
OWL/XML構文
 <IrreflexiveObjectProperty>
   <ObjectProperty IRI="parentOf"/>
 </IrreflexiveObjectProperty>

次に、夫を持つ(hasHusband)というプロパティーを考えてみます。どんな人も1人の夫しか持てない(例のために、それが当然であるとする)ため、すべての個体は、夫を持つというプロパティーによって、最大1つだけ他の個体にリンクできます。この種のプロパティーは、関数型と呼ばれ、次の通りに記述します。

関数型構文
 FunctionalObjectProperty( :hasHusband ) 
RDF/XML構文
 <owl:FunctionalProperty rdf:about="hasHusband"/>
Turtle構文
 :hasHusband  rdf:type  owl:FunctionalProperty .
マンチェスター構文
 ObjectProperty: hasHusband
   Characteristics: Functional
OWL/XML構文
 <FunctionalObjectProperty>
   <ObjectProperty IRI="hasHusband"/>
 </FunctionalObjectProperty>

このステートメントが、すべての個体が夫を持つ必要はなく、1人以下の夫を持つことができると述べているだけであることに注意してください。さらに、メアリーの夫がジェームズであるというステートメントと、メアリーの夫がジムであるというステートメントが加われば、ジムとジェームズが同じ個体を意味しなければならないと推論できます。

また、特定のプロパティーの逆が関数型であることを示すことも可能です。

関数型構文
 InverseFunctionalObjectProperty( :hasHusband ) 
RDF/XML構文
 <owl:InverseFunctionalProperty rdf:about="hasHusband"/>
Turtle構文
 :hasHusband  rdf:type  owl:InverseFunctionalProperty .
マンチェスター構文
 ObjectProperty: hasHusband
   Characteristics: InverseFunctional
OWL/XML構文
 <InverseFunctionalObjectProperty>
   <ObjectProperty IRI="hasHusband"/>
 </InverseFunctionalObjectProperty>

これは、個体が最大1つの他の個体の夫でありえることを示します。例では、一夫多妻の状況下では、前者の公理は有効だけども、後者は有効ではないという、関数と逆関数の違いも示しています。

次に、個体AがBの直接の子孫である場合には、AとBを必ずリンクさせることになる、先祖を持つ(hasAncestor)というプロパティーを見てみましょう。明らかに、親を持つというプロパティーは、先祖を持つというプロパティーの「特別なケース」であり、そのサブプロパティーであると定義できます。さらに、「自動的に」親の親(また、親の親の親)を含められると良いでしょう。これは、祖先を持つを推移的なプロパティーと定義することで実現できます。ある個体Bが存在しているとき、推移的なプロパティーによって、個体AとB、かつ、BとCがリンクされている場合、2つの個体AとCは常にリンクされています。

関数型構文
 TransitiveObjectProperty( :hasAncestor )
RDF/XML構文
 <owl:TransitiveProperty rdf:about="hasAncestor"/>
Turtle構文
 :hasAncestor  rdf:type  owl:TransitiveProperty .
マンチェスター構文
 ObjectProperty: hasAncestor
   Characteristics: Transitive
OWL/XML構文
 <TransitiveObjectProperty>
   <ObjectProperty IRI="hasAncestor"/>
 </TransitiveObjectProperty>

6.2 プロパティー連鎖

前項の最後の例では、親を持つプロパティーの連鎖があれば、祖先を持つというプロパティーの存在が必ず含意されていましたが、その代わりに、もう少し具体的に、例えば、祖父母を持つ(hasGrandparent)というプロパティーを定義したいと考えるかもしれません。技術的には、これは、きっかり2人の親を持つ(hasParent)プロパティーの連鎖でリンクされているすべての個体を、祖父母を持つ(hasGrandparent)によって、関連づけたいということを意味します。祖先を持つ(hasAncestor)という、前の例と異なるのは、親を持つ(hasParent)が、祖父母を持つ(hasGrandparent)の特別なケースであることも、祖父母を持つ(hasGrandparent)が、曽祖父母などを意味することも望んでいない点です。次のように、そのような連鎖の範囲は、すべて、祖父母を持つ(hasGrandparent)プロパティーによって、決まらなければならないと表現できます。

関数型構文
 SubObjectPropertyOf( 
   ObjectPropertyChain( :hasParent :hasParent ) 
   :hasGrandparent 
 )
RDF/XML構文
 <rdf:Description rdf:about="hasGrandparent">
       <owl:propertyChainAxiom rdf:parseType="Collection">
               <owl:ObjectProperty rdf:about="hasParent"/>
               <owl:ObjectProperty rdf:about="hasParent"/>
       </owl:propertyChainAxiom> </rdf:Description>
Turtle構文
 :hasGrandparent  owl:propertyChainAxiom  ( :hasParent  :hasParent ) .
マンチェスター構文
 ObjectProperty: hasGrandparent
   SubPropertyChain: hasParent o hasParent
OWL/XML構文
 <SubObjectPropertyOf>
   <ObjectPropertyChain>
     <ObjectProperty IRI="hasParent"/>     <ObjectProperty IRI="hasParent"/>
   </ObjectPropertyChain>
   <ObjectProperty IRI="hasGrandparent"/>
 </SubObjectPropertyOf>

6.3 キー

OWL2では、プロパティーの集合(データかオブジェクト)を、クラス式のキーとして割り当てることができます。これは、インスタンスとの関係によって、これらのプロパティーが得る値の集合によって、クラス式の名前付きインスタンスが一意に特定されることを意味します。

これに関する分かりやすい例は、社会保険番号による人の識別でしょう。

関数型構文
 HasKey( :Person () ( :hasSSN ) )
RDF/XML構文
 <owl:Class rdf:about="Person">
   <owl:hasKey rdf:parseType="Collection">
     <owl:ObjectProperty rdf:about="hasSSN"/>
   </owl:hasKey>
 </owl:Class>
Turtle構文
 :Person owl:hasKey ( :hasSSN ) .
マンチェスター構文
 Class: Person
   HasKey: hasSSN
OWL/XML構文
 <HasKey>
   <Class IRI="Person"/>
   <ObjectProperty IRI="hasSSN"/>
 </HasKey>

7 データ型の高度な使用

4.8項では、オブジェクト・プロパティーを他の定義域の個体へリンクするのとちょうど同じように、基本的には、個体をデータ型プロパティーでデータ値に関連づけることにより、個体に数字の情報を与えられることを学びました。実際には、これらの類似点は、データ型の使用に関するより高度な機能にまで及びます。

まず、データ値はデータ型に分類されます。そして、4.8項では、データ型プロパティーの値域制限をどのように用いると、このプロパティーがリンクできる値の種類を示すことができるかを見ました。さらに、既存のデータ型を制約したり結合することで新しいデータ型を表現し、定義することができます。データ型は、いわゆるファセットで制限し、XMLスキーマ・データ型[XML Schema Datatypes]から借りることができます。次の例では、データ型の整数を(すべてを包含する)0から150の間の値に制約することにより、人の年齢の新しいデータ型を定義しています。

関数型構文
 DatatypeDefinition(
   :personAge
   DatatypeRestriction( xsd:integer           
     xsd:minInclusive "0"^^xsd:integer
     xsd:maxInclusive "150"^^xsd:integer
   )
 ) 
RDF/XML構文
 <rdf:Description rdf:about="personAge">
   <owl:equivalentClass>
     <rdfs:Datatype>
       <owl:onDatatype rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/>
       <owl:withRestrictions rdf:parseType="Collection">
         <rdf:Description>
           <xsd:minInclusive rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">0</xsd:minInclusive>
         </rdf:Description>
         <rdf:Description>
           <xsd:maxInclusive rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">150</xsd:maxInclusive> 
         </rdf:Description>         
       </owl:withRestrictions>
     </rdfs:Datatype>
   </owl:equivalentClass>
 </rdf:Description>
Turtle構文
 :personAge  owl:equivalentClass
  [ rdf:type  rdfs:Datatype;
    owl:onDatatype  xsd:integer;
    owl:withRestrictions (
       [ xsd:minInclusive  "0"^^xsd:integer ]
       [ xsd:maxInclusive  "150"^^xsd:integer ] 
    )
  ] .
マンチェスター構文
 Datatype: personAge
   EquivalentTo: integer[<= 0 , >= 150]
OWL/XML構文
 <DatatypeDefinition>
    <Datatype IRI="personAge"/>
    <DatatypeRestriction>
       <Datatype IRI="&xsd;integer"/>
       <FacetRestriction facet="&xsd;minInclusive">
         <Literal datatypeIRI="&xsd;integer">0</Literal>
       </FacetRestriction>
       <FacetRestriction facet="&xsd;maxInclusive">
         <Literal datatypeIRI="&xsd;integer">150</Literal>
       </FacetRestriction>
    </DatatypeRestriction>
  </DatatypeDefinition>

同様に、データ型は、クラスと同じように、補集合、積集合、和集合によって結合できます。その結果、未成年(minorAge)というデータ型を既に定義していると仮定した場合、未成年(minorAge)のあらゆるデータ値を、人の年齢(personAge)から除外することによって、成年(majorAge)というデータ型を定義できます。

関数型構文
 DatatypeDefinition(
   :majorAge
   DataIntersectionOf(
     :personAge 
     DataComplementOf( :minorAge ) 
   ) 
 ) 
RDF/XML構文
 <rdf:Description rdf:about="majorAge">
   <owl:equivalentClass>
     <rdfs:Datatype>
       <owl:intersectionOf rdf:parseType="Collection">
         <rdf:Description rdf:about="personAge"/>
         <rdfs:Datatype>
           <owl:datatypeComplementOf rdf:resource="minorAge"/> 
         </rdfs:Datatype>
       </owl:intersectionOf>
     </rdfs:Datatype>
   </owl:equivalentClass>
 </rdf:Description> 
Turtle構文
 :majorAge  owl:equivalentClass
   [ rdf:type  rdfs:Datatype;
     owl:intersectionOf (
        :personAge
        [ rdf:type  rdfs:Datatype;
          owl:datatypeComplementOf  :minorAge ] 
     )
   ] .
マンチェスター構文
 Datatype: majorAge
    EquivalentTo: personAge and not minorAge
OWL/XML構文
 <DatatypeDefinition>
    <Datatype IRI="majorAge"/>
    <DataIntersectionOf>
       <Datatype IRI="personAge"/>
       <DataComplementOf>
         <Datatype IRI="minorAge"/>
       </DataComplementOf>
    </DataIntersectionOf>
  </DatatypeDefinition>

さらに、それに含まれるデータ値を列挙するだけで、新しいデータ型を作成できます。

関数型構文
 DatatypeDefinition(
   :toddlerAge
   DataOneOf( "1"^^xsd:integer "2"^^xsd:integer ) 
 ) 
RDF/XML構文
 <rdf:Description rdf:about="toddlerAge">
   <owl:equivalentClass>
     <rdfs:Datatype>
       <owl:oneOf>
         <rdf:Description>
           <rdf:first rdf:datatype="&xsd;integer">1</rdf:first>
           <rdf:rest>
             <rdf:Description>
               <rdf:first rdf:datatype="&xsd;integer">2</rdf:first>
               <rdf:rest rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/>
             </rdf:Description>
           </rdf:rest>
         </rdf:Description>
       </owl:oneOf>
     </rdfs:Datatype>
   </owl:equivalentClass>
 </rdf:Description>
Turtle構文
 :toddlerAge  owl:equivalentClass
   [ rdf:type rdfs:Datatype;
     owl:oneOf (  "1"^^xsd:integer  "2"^^xsd:integer )
   ] .
マンチェスター構文
 Datatype: toddlerAge
    EquivalentTo: { 1, 2 }
OWL/XML構文
 <DatatypeDefinition>
    <Datatype IRI="toddlerAge"/>
    <DataOneOf>
      <Literal datatypeIRI="http://www.w3.org/2001/XMLSchema#integer">1</Literal> 
      <Literal datatypeIRI="http://www.w3.org/2001/XMLSchema#integer">2</Literal>
    </DataOneOf>
 </DatatypeDefinition>

6.1項では、オブジェクト・プロパティーに特性を付与する方法を見ました。また、それらの一部は、データ型プロパティーに利用できます。例えば、年齢を持つ(hasAge)というデータ型プロパティーに関数型という特性を付与することで、すべての人は1つの年齢しか持てないと表現できます。

関数型構文
 FunctionalDataProperty( :hasAge ) 
RDF/XML構文
 <owl:FunctionalProperty rdf:about="hasAge"/>
Turtle構文
 :hasAge  rdf:type  owl:FunctionalProperty .
マンチェスター構文
 DataProperty: hasHusband
   Characteristics: Functional
OWL/XML構文
 <FunctionalDataProperty>
  <DataProperty IRI="hasHusband"/>
</FunctionalDataProperty>

データ型プロパティーを制限することにより、新しいクラスを定義できます。次の例では、ティーンエイジャーというクラスを、年齢が13と19の間であるすべての個体と定義しています。

関数型構文
 SubClassOf(
   :Teenager
   DataSomeValuesFrom( :hasAge
     DatatypeRestriction( xsd:integer
       xsd:minExclusive "12"^^xsd:integer
       xsd:maxInclusive "19"^^xsd:integer
     )
   )
 )
RDF/XML構文
<owl:Class rdf:about="Teenager">
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="hasAge"/>
      <owl:someValuesFrom>
        <rdfs:Datatype>
          <owl:onDataType rdf:resource="&xsd;integer"/>
          <owl:withRestrictions rdf:parseType="Collection">
            <rdf:Description>
              <xsd:minExclusive rdf:datatype="&xsd;integer">12</xsd:minExclusive>
            </rdf:Description>
            <rdf:Description>
              <xsd:maxInclusive rdf:datatype="&xsd;integer">19</xsd:maxInclusive>
            </rdf:Description>
          </owl:withRestrictions>
        </rdfs:Datatype>
      </owl:someValuesFrom>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>
Turtle構文
:Teenager  rdfs:subClassOf
       [ rdf:type             owl:Restriction ;
         owl:onProperty       :hasAge ;
         owl:someValuesFrom   
          [ rdf:type             rdfs:Datatype ;
            owl:onDatatype       xsd:integer ;
            owl:withRestrictions (  [ xsd:minExclusive     "12"^^xsd:integer ]
                                    [ xsd:maxInclusive     "19"^^xsd:integer ]
            )
          ]
       ] .
マンチェスター構文
Class: Teenager
  SubClassOf: hasAge some integer[< 12 , >= 19]
OWL/XML構文
<SubClassOf>
  <Class IRI="Teenager"/>
  <DataSomeValuesFrom>
    <DataProperty IRI="hasAge"/>
    <DatatypeRestriction>
      <Datatype IRI="&xsd;integer"/>
      <FacetRestriction facet="&xsd;minExclusive">
        <Literal datatypeIRI="&xsd;integer">12</Literal>
      </FacetRestriction>
      <FacetRestriction facet="&xsd;maxInclusive">
        <Literal datatypeIRI="&xsd;integer">19</Literal>
      </FacetRestriction>
    </DatatypeRestriction>
  </DataSomeValuesFrom>
</SubClassOf>

8 ドキュメント情報と注釈

以下では、オントロジーで定められた「論理的な」知識に実際には関係のないOWL 2の機能について説明します。これらは、オントロジー自身、公理、または、ひとつのエンティティーに関する追加情報を提供するために用いられます。

8.1 公理とエンティティーの注釈

多くの場合、OWLオントロジーの一部に実際にその定義域自体を記述するのではなく、定義域の記述に関して記述した情報を提供したいと考えます。OWLはこのために注釈を提供します。OWL注釈は、プロパティーと値の対を、オントロジーの一部、またはオントロジー全体自体にシンプルに関連づけます。注釈自体を注釈することさえ可能です。注釈情報は、オントロジーの理論的意味の一部というわけではありません。

そのため、例えば、意味を自然言語で記述することで、オントロジーのクラスの1つに情報を追加できます。

関数型構文
 AnnotationAssertion( rdfs:comment :Person "Represents the set of all people." )
RDF/XML構文
 <owl:Class rdf:about="Person">
   <rdfs:comment>Represents the set of all people.</rdfs:comment>
 </owl:Class>
Turtle構文
 :Person  rdfs:comment  "Represents the set of all people."^^xsd:string .
マンチェスター構文
 Class: Person
   Annotations: rdfs:comment "Represents the set of all people."
OWL/XML構文
 <AnnotationAssertion>
   <AnnotationProperty IRI="&rdfs;comment"/>
   <IRI>Person</IRI>                       
   <Literal>Represents the set of all people.</Literal>
 </AnnotationAssertion>

下記は、注釈がある公理の例です。

関数型構文
 SubClassOf( 
   Annotation( rdfs:comment "States that every man is a person." )
   :Man 
   :Person 
 )
RDF/XML構文
 <owl:Class rdf:about="Man">
   <rdfs:subClassOf rdf:resource="Person"/>
 </owl:Class>
 <owl:Axiom>
   <owl:annotatedSource rdf:resource="Man"/>
   <owl:annotatedProperty rdf:resource="&rdfs;subClassOf"/>
   <owl:annotatedTarget rdf:resource="Person"/>
   <rdfs:comment>States that every man is a person.</rdfs:comment>
 </owl:Axiom>
Turtle構文
 :Man rdfs:subClassOf :Person .
 []  rdf:type       owl:Axiom ;
     owl:annotatedSource    :Man ;
     owl:annotatedProperty  rdfs:subClassOf ;
     owl:annotatedTarget    :Person ;
     rdfs:comment     "States that every man is a person."^^xsd:string .
マンチェスター構文
 Class: Man
   SubClassOf: Annotations: rdfs:comment "States that every man is a person." Person
OWL/XML構文
 <SubClassOf>
   <Annotation>
       <AnnotationProperty IRI="&rdfs;comment"/>
       <Literal datatypeIRI="xsd:string">"States that every man is a person."</Literal>
   </Annotation>
   <Class IRI="Man"/>
   <Class IRI="Person"/>
 </SubClassOf>

しばしば、そのような注釈は、ヘルプのインタフェースに表示するための自然言語テキストへのアクセスを提供するツールで用いられます。

8.2 オントロジーの管理

OWLでは、あるテーマに関する一般的な情報は、ほぼ必ず、オントロジーに集約され、後で様々なアプリケーションに用いられまる。OWLオントロジーに名前を与えることもでき、この名前は通常、オントロジー・ドキュメントがウェブに置かれている場所です。あるテーマに関する特定の情報も、異なるアプリケーションで用いられていれば、オントロジー内に置くことができます。

関数型構文
 Ontology(<http://example.com/owl/families>
   ...
 )
RDF/XML構文
 <rdf:RDF ...>
   <owl:Ontology rdf:about="http://example.com/owl/families"/>
   ...
 </rdf:RDF>
Turtle構文
 <http://example.com/owl/families> rdf:type owl:Ontology .
マンチェスター構文
 Ontology: <http://example.com/owl/families>
OWL/XML構文
 <Ontology ...
   ontologyIRI="http://example.com/owl/families">
   ...
 </Ontology>

OWLオントロジーは、OWLドキュメント内に置かれ、その後で、ローカルのファイル・システムやWWWに置かれます。OWLドキュメントは、OWLオントロジーを含んでいるだけではなく、接頭辞の展開によって、OWLオントロジー(例えば、人(Person))で通常用いられる省略名をIRIに変換するための情報を含んでいます。その結果、IRIは、接頭辞の展開と参照とを連結したものとなります。

例では、今までに、xsdや空白の接頭辞などの、多くの接頭辞を用いてきました。前者の接頭辞は、XMLスキーマ・データ型のコンパクト名に用いられおり、そのIRIは、XMLスキーマ勧告で定められています。したがって、http://www.w3.org/2001/XMLSchema#というxsdの標準的な展開を用いなければなりません。もう一方の接頭辞用に選ぶ展開は、オントロジーのクラス、プロパティー、個体の名前にも、また、オントロジー自身の名前にも影響するでしょう。オントロジーをウェブに置くときには、他の誰かの名前を偶然使用してしまわないように、自分が管理しているウェブの一部に存在する展開を選ぶべきです。(ここでは、だれも制御していない、架空の場所を使用しています。)2つのXMLベースの構文には、組み込み名用の名前空間が必要で、名前空間としてXMLエンティティーを用いることもできます。一般に、似たキーワードが使われていても、利用可能な省略メカニズムとその特定の構文は、それぞれのOWLのシリアル化によって異なることに注意すべきです。

関数型構文
 Prefix(:=<http://example.com/owl/families/>)
 Prefix(otherOnt:=<http://example.org/otherOntologies/families/>)
 Prefix(xsd:=<http://www.w3.org/2001/XMLSchema#>)
 Prefix(owl:=<http://www.w3.org/2002/07/owl#>)
 
 Ontology(<http://example.com/owl/families>
    ...
 )
RDF/XML構文
 <!DOCTYPE rdf:RDF [
     <!ENTITY owl "http://www.w3.org/2002/07/owl#" >
     <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
     <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
     <!ENTITY otherOnt "http://example.org/otherOntologies/families/" >
 ]>
 
 <rdf:RDF xml:base="http://example.com/owl/families/"
     xmlns="http://example.com/owl/families/"
     xmlns:otherOnt="http://example.org/otherOntologies/families/"
     xmlns:owl="http://www.w3.org/2002/07/owl#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:xml="http://www.w3.org/2001/XMLSchema#">
 
     <owl:Ontology rdf:about="http://example.com/owl/families"/>
 ...
Turtle構文
 @prefix : <http://example.com/owl/families/> .
 @prefix otherOnt: <http://example.org/otherOntologies/families/> .
 @prefix owl: <http://www.w3.org/2002/07/owl#> .
 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
マンチェスター構文
 Prefix: : <http://example.com/owl/families/>
 Prefix: xsd: <http://www.w3.org/2001/XMLSchema#>
 Prefix: owl: <http://www.w3.org/2002/07/owl#>
 Prefix: otherOnt: <http://example.org/otherOntologies/families/>
OWL/XML構文
 <!DOCTYPE Ontology [
    <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
 ]>
 <Ontology
   xml:base="http://example.com/owl/families/"
   ontologyIRI="http://example.com/owl/families"
   xmlns="http://www.w3.org/2002/07/owl#">
   <Prefix name="owl" IRI="http://www.w3.org/2002/07/owl#"/>
 
  ...
 </Ontology>

OWLでは、あるオントロジーに格納されている一般的な情報を他のオントロジーで再利用することも一般的です。OWLでは、この情報をコピーする必要はなく、次の通り、インポート・ステートメントを用いると、他のオントロジー内のオントロジー全体のコンテンツをインポートできます。

関数型構文
 Import( <http://example.org/otherOntologies/families.owl> )
RDF/XML構文
 <owl:Ontology rdf:about="http://example.com/owl/families">
   <owl:imports rdf:resource="http://example.org/otherOntologies/families.owl" />
 </owl:Ontology>
Turtle構文
 <http://example.com/owl/families> owl:imports <http://example.org/otherOntologies/families.owl> .
マンチェスター構文
 Import: <http://example.org/otherOntologies/families.owl>
OWL/XML構文
 <Prefix name="otherOnt" IRI="http://example.org/otherOntologies/families/"/>
 <Import>http://example.org/otherOntologies/families.owl</Import>


セマンティック・ウェブとオントロジーの構築は分散的に提供されるため、オントロジーは、一般的に、同じ概念、プロパティーや個体に、異なる名前を用います。これまで見てきたように、OWLのいくつかの構成子は、異なる名前が同じクラスプロパティー個体を参照していると述べるために使用できるため、例えば、(エンティティーを改名するのではなく)次のように、自分のオントロジーに使用している名前を、インポートしたオントロジーに用いられている名前と関連づけることができます。

関数型構文
 SameIndividual( :John otherOnt:JohnBrown )
 SameIndividual( :Mary otherOnt:MaryBrown )
 EquivalentClasses( :Adult otherOnt:Grownup )
 EquivalentObjectProperties( :hasChild otherOnt:child )
 EquivalentDataProperties( :hasAge otherOnt:age )
RDF/XML構文
 <rdf:Description rdf:about="John">
   <owl:sameAs rdf:resource="&otherOnt;JohnBrown"/>
 </rdf:Description>

 <rdf:Description rdf:about="Mary">
   <owl:sameAs rdf:resource="&otherOnt;MaryBrown"/>
 </rdf:Description>

 <owl:Class rdf:about="Adult">
   <owl:equivalentClass rdf:resource="&otherOnt;Grownup"/>
 </owl:Class>

 <owl:DatatypeProperty rdf:about="hasAge">
   <owl:equivalentProperty rdf:resource="&otherOnt;age"/>
 </owl:DatatypeProperty>

 <owl:Class rdf:about="Adult">
   <owl:equivalentClass rdf:resource="&otherOnt;Grownup"/>
 </owl:Class>
Turtle構文
 :Mary      owl:sameAs              otherOnt:MaryBrown .
 :John      owl:sameAs              otherOnt:JohnBrown .
 :Adult     owl:equivalentClass     otherOnt:Grownup .
 :hasChild  owl:equivalentProperty  otherOnt:child .
 :hasAge    owl:equivalentProperty  otherOnt:age .
マンチェスター構文
 SameIndividual: John, otherOnt:JohnBrown 
 SameIndividual: Mary, otherOnt:MaryBrown
 EquivalentClasses: Adult, otherOnt:Grownup
 EquivalentProperties: hasChild, otherOnt:child
 EquivalentProperties: hasAge,   otherOnt:age
OWL/XML構文
 <SameIndividual>
   <NamedIndividual IRI="John"/>
   <NamedIndividual abbreviatedIRI="otherOnt:JohnBrown"/>
 </SameIndividual>

 <SameIndividual>
   <NamedIndividual IRI="Mary"/>
   <NamedIndividual abbreviatedIRI="otherOnt:MaryBrown"/>
 </SameIndividual>

 <EquivalentClasses>
   <Class IRI="Adult"/>
   <Class abbreviatedIRI="otherOnt:Grownup"/>
 </EquivalentClasses>

 <EquivalentObjectProperties>
   <ObjectProperty IRI="hasChild"/>
   <ObjectProperty abbreviatedIRI="otherOnt:child"/>
 </EquivalentObjectProperties>

 <EquivalentDataProperties>
   <DataProperty IRI="hasAge"/>
   <DataProperty abbreviatedIRI="otherOnt:age"/>
 </EquivalentDataProperties>

8.3 エンティティー宣言

オントロジーの管理に役立つように、OWLには、宣言という考えがあります。基本的な考え方は、クラス、プロパティーや個体はオントロジーで宣言すべきであり、その後で、それをそのオントロジーやそのオントロジーをインポートするオントロジーで使用できるというものです。

マンチェスター構文では、宣言は暗示的です。クラス、プロパティー、個体に関する情報を提供する構成子は、必要に応じて、そのクラス、プロパティー、個体を暗示的に宣言します。それ以外の構文には、明示的な宣言があります。

関数型構文
 Declaration( NamedIndividual( :John ) )
 Declaration( Class( :Person ) )
 Declaration( ObjectProperty( :hasWife ) )
 Declaration( DataProperty( :hasAge ) )
RDF/XML構文
 <owl:NamedIndividual rdf:about="John"/>
 <owl:Class rdf:about="Person"/>
 <owl:ObjectProperty rdf:about="hasWife"/>
 <owl:DatatypeProperty rdf:about="hasAge"/>
Turtle構文
 :John    rdf:type owl:NamedIndividual .
 :Person  rdf:type owl:Class .
 :hasWife rdf:type owl:ObjectProperty .
 :hasAge  rdf:type owl:DatatypeProperty .
マンチェスター構文
 Individual: John
 Class: Person
 ObjectProperty: hasWife
 DataProperty: hasAge
OWL/XML構文
 <Declaration>
     <NamedIndividual IRI="John"/>
 </Declaration>
 <Declaration>
     <Class IRI="Person"/>
 </Declaration>
 <Declaration>
     <ObjectProperty IRI="hasWife"/>
 </Declaration>
 <Declaration>
     <DataProperty IRI="hasAge"/>
 </Declaration>

しかし、IRIは、異なるエンティティーの型(例えば、個体とクラスの両方)を同時に指すことができます。一定量のメタモデリングが可能となるように「パニング」(punning)と呼ばれるこの性能を導入しました。これに関する例は、9項で示します。さらに、OWL 2では、名前を利用したり再利用したりする際には、ある原理原則が必要です。より可読性の高い構文を実現するため、また、その他の技術的な理由により、OWL 2 DLは、1つ以上のプロパティー・タイプ(オブジェクト、データ型または注釈プロパティー)で名前が使われておらず、IRIがクラスとデータ型の両方を指すことができない必要があります。そのうえ、OWLでは、「組み込み」名(RDF、RDFS、および、様々な構文のOWLで使用されるものなど)を自由に用いることはできません。

9 OWL 2 DLとOWL 2 Full

OWL 2のオントロジーに意味を割り当てる方法には、ダイレクト・モデル理論セマンティクス[OWL 2 Direct Semantics]とRDFベースのセマンティクス[OWL 2 RDF-Based Semantics]と呼ばれる2つの選択肢があります。非公式には、「OWL 2 DL」という概念は、ダイレクト・セマンティクスを用いて解釈されたOWL 2オントロジーを指すために用いられ、RDFベースのセマンティクスを考慮する際には「OWL 2 Full」という概念が使用されます。OWL 2関数型構文ドキュメント[OWL 2 Specification]では、さらに、OWL 2 DLとして認められるためにOWL 2オントロジーが満たさなければならない条件をいくつかリストアップしています。

ダイレクト・モデル理論セマンティクス[OWL 2 Direct Semantics]は、記述論理[Description Logics]形式のOWL 2に意味を提供します。RDFベースのセマンティクス[OWL 2 RDF-Based Semantics]は、RDFS[RDF Semantics]のためのセマンティクスの拡張であり、OWL 2オントロジーのRDFグラフとしての表示に基づいています。

オントロジーを考えるときに、これらの2つのセマンティクスの違いは、一般的には、かなり小さいです。実際に、OWL 2 DLオントロジーの場合、ダイレクト・セマンティクスを用いて出された推論は、RDFベースのセマンティクス下でも有効性を保っています。RDFベースのセマンティクスのドキュメント[OWL 2 RDF-Based Semantics]の7.2項の対応定理を参照してください。2つの主な違いは、ダイレクト・モデル理論セマンティクス下では注釈は形式的な意味を持っておらず、RDFベースのセマンティクス下ではRDFの宇宙観から生じるいくつかの追加の推論があります。

概念的に、OWL 2 DLとOWL 2 Fullの違いを、次の2通りに考えることができます。

もちろん、2つのセマンティクスは一緒に設計されたため、互いに影響を及ぼしました。例えば、OWL 2の1つの設計目標は、OWL 2 DLをOWL 2 Fullに構文上近づける(つまり、より多くのRDFグラフ/OWL 2 Fullオントロジーが、正当なOWL 2 DLオントロジーになるようにする)ことでした。これは、OWL 2へのいわゆるパニングの組み込み(例えば、クラスと個体の両方の名前と同じIRIとして用いた)につながりました。そのような用法の例は下記にあり、ジョンが父親(Father)であり、父親は社会的役割(SocialRole)あると述べています。

関数型構文
ClassAssertion( :Father :John ) 
ClassAssertion( :SocialRole :Father ) 
RDF/XML構文
<Father rdf:about="John"/>
<SocialRole rdf:about="Father"/>
Turtle構文
:John rdf:type :Father .
:Father rdf:type :SocialRole .
マンチェスター構文
Individual: John   
  Types: Father
Individual: Father 
  Types: SocialRole
OWL/XML構文
<ClassAssertion>
    <Class IRI="Father"/>
    <NamedIndividual IRI="John"/>
</ClassAssertion>
<ClassAssertion>
    <Class IRI="SocialRole"/>
    <NamedIndividual IRI="Father"/>
</ClassAssertion>

最初のステートメントでは父親がクラスとして用いられており、2番目ステートメントでは個体として用いられていることに注意してください。その意味で、社会的な役割は、父親というクラスのメタクラスとして機能します。

OWL 1では、これらの2つのステートメントを含むドキュメントは、OWL 1 DLドキュメントではなく、OWL 1 Fullドキュメントでしょう。しかし、OWL 2 DLでは、これが可能です。もっとも、OWL 2 DLのダイレクト・モデル理論セマンティクスが、クラスの父親と個体の父親を同じIRIに対する2つの異なる見方と理解する(つまり、まるでそれらが異なっているかのように意味的に解釈する)ことによって、これに対応することに注意しなければなりません。

10 OWL 2プロフィル

OWL 2は、OWL 2 DLとOWL 2 Fullに加え、3つのプロファイルを定めています。一般的に、OWL 2は、非常に表現力のある言語(コンピュータ上、そして、ユーザにとって)であるため、実装し、連携するのが難しい場合があります。これらの追加プロフィールは、さまざまなアプリケーションにとって分かりやすいOWL 2のサブセットとなるように設計されています。OWL 2 DLのように、コンピュータに関する課題が、これらのプロファイルの主要な要件(そして、それらはすべて、既存技術を考えると、強力なスケーラビリティにより、はるかに実装しやすい)ですが、優れたコンピュータ特性を有するOWL 2のサブセットが多く存在しています。選択したOWL 2プロファイルには、既にかなりのユーザー・コミュニティがあることが確認されており、関与していないものも他にいくつかあるものの、もっと出現することが予想されます。[OWL 2 Profiles]ドキュメントは、追加プロファイルを指定するための分かりやすいテンプレートを提供しています。

スケーラブルな推論を確保するため、既存のプロファイルは、表現の豊かさに関するいくつかの制限を共有しています。これらの構成子が推論を複雑化し、モデル化には極めてまれにしか必要ではないことが分かっているため、それらでは一般的に、論理否定と論理和を認められていません。例えば、どのプロファイルにおいても、すべての人が男性である、または、女性であると指定することはできません。より詳細なプロファイルのモデル化制限については、個々のプロファイルに関する項で扱っています。

我々は、各プロファイルとその設計原理について議論し、どのプロファイルを扱うかを選択する際の案内をユーザに提供します。この議論が包括的なものではなく、包括的であるはずもないことに留意してください。決定の要素は、利用可能なツールと、それがどのようにシステムや作業フローの残りの部分と適合するかに基づかなければなりません。

概して、様々なプロファイル間に包含関係が存在することで、構文上異なるプロファイルを区別できます。例えば、OWL 2 DLはOWL 2 Fullの構文の断片であり、OWL 2 QLはOWL 2 DL(したがって、OWL 2 Full)の構文の断片であると見ることができます。以下のプロファイルは、どれも別のプロファイルのサブセットではありません。理想的には、同じ結果を導き出すサブプロファイル上のスーパープロファイルに準拠した推論システム(または、その他のツール)を使用できます。OWL 2 DLと関連のあるOWL 2 ELとOWL 2 QLのプロファイルの場合、すべての適合OWL 2 DL推論システムは、OWL 2 ELとOWL 2 QLの推論システムである(しかし、OWL 2 DL推論システムは、より一般的なケースに合わせて調整されているため、性能が異なるかもしれない)という原則が成り立ちます。

10.1 OWL 2 EL

OWL 2 ELの扱いは、OWL 2 DLの扱いとかなり同じです。クラス式をsubClassOfステートメントの両側で用い、そのような関係を推論することも可能です。多くの大規模なクラス式指向のオントロジーでは、少しの簡素化を行うだけで、OWL 2 ELオントロジーを入手し、元のオントロジーの意味のほとんどを保存できます。

OWL 2 ELは、SNOMED-CTや、NCIシソーラスや、Galenなどの大規模なバイオヘルスのオントロジーを念頭において設計されています。このようなオントロジーに共通する特徴には、複雑な構造の記述(例えば、身体の部分について、それがどのような部分を含み、どのような部分に含まれているかの観点、または、部分―下位部分関係に沿った病気の伝播の観点で定義する)、膨大な数のクラス、用語を管理するための分類の多用、結果として得られた用語の大量データへの応用が含まれます。したがって、OWL 2 ELには比較的表現力のあるクラス式言語が存在しており、公理における使用方法に制限がありません。これは、かなり表現力のあるプロパティー式も有しており、プロパティー連鎖は含むものの、逆は除外されています。

言うまでもなく、OWL 2 ELの実際的な使用は、バイオヘルスの定義域に限られてはいません。他のプロファイルのように、OWL 2 ELは、定義域には依存しません。しかし、OWL 2 ELは、構造的に複雑なオブジェクトの認識が定義域とアプリケーションに必要な場合に優れています。このような定義域には、システム構成、製品目録、多くの科学的な定義域が含まれます。

OWL 2 ELでは、論理否定と論理和以外にも、プロパティーの全称量化は許されていません。したがって、「金持ちの子供はみんな金持ちである」のような命題を述べることはできません。さらに、すべての種類の役割の逆が利用できるわけではないないため、たとえば、parentOfとchildOfが互いに逆であるということを指定する方法はありません。

ELという頭字語は、プロファイルの基礎が、記述論理[EL++]のいわゆるELファミリー(主に変数の特称量化を提供する言語)にあることを反映しています。

次は、OWL 2 ELで利用できる典型的なモデル化機能のいくつかを用いた例です。

関数型構文
 SubClassOf(
   :Father 
   ObjectIntersectionOf( :Man :Parent )
 )
 
 EquivalentClasses(
   :Parent    ObjectSomeValuesFrom(
     :hasChild 
     :Person
   )
 )
 
 EquivalentClasses( 
   :NarcisticPerson 
   ObjectHasSelf( :loves ) 
 )
 
 DisjointClasses( 
   :Mother 
   :Father 
   :YoungChild 
 )
 
 SubObjectPropertyOf( 
   ObjectPropertyChain( :hasFather :hasBrother ) 
   :hasUncle 
 )
 
 NegativeObjectPropertyAssertion( 
   :hasDaughter 
   :Bill 
   :Susan 
 )
RDF/XML構文
 <owl:Class rdf:about="Father">
   <rdfs:subClassOf>
     <owl:Class>
       <owl:intersectionOf rdf:parseType="Collection">
         <owl:Class rdf:about="Man"/>
         <owl:Class rdf:about="Parent"/>
       </owl:intersectionOf>
     </owl:Class>   </rdfs:subClassOf>
 </owl:Class>
 
 <owl:Class rdf:about="Parent">
   <owl:equivalentClass>
     <owl:Restriction>
       <owl:onProperty rdf:about="hasChild"/>
       <owl:someValuesFrom rdf:resource="Person"/>
     </owl:Restriction>
   </owl:equivalentClass>
 </owl:Class>
 
 <owl:Class rdf:about="NarcisticPerson">   <owl:equivalentClass>
     <owl:Restriction>
       <owl:onProperty rdf:resource="loves"/>
       <owl:hasSelf rdf:datatype="&xsd;boolean">
         true
       </owl:hasSelf>
     </owl:Restriction>
   </owl:equivalentClass>
 </owl:Class>
 
 <owl:AllDisjointClasses>
   <owl:members rdf:parseType="Collection">
     <owl:Class rdf:about="Mother"/>
     <owl:Class rdf:about="Father"/>
     <owl:Class rdf:about="YoungChild"/>
   </owl:members>
 </owl:AllDisjointClasses>

 <rdf:Description rdf:about="hasUncle">
   <owl:propertyChainAxiom rdf:parseType="Collection">
     <owl:ObjectProperty rdf:about="hasFather"/>
     <owl:ObjectProperty rdf:about="hasBrother"/>
   </owl:propertyChainAxiom>
 </rdf:Description>
 
 <owl:NegativePropertyAssertion>
   <owl:sourceIndividual rdf:resource="Bill"/>
   <owl:assertionProperty rdf:resource="hasDaughter"/>
   <owl:targetIndividual rdf:resource="Susan"/>
 </owl:NegativePropertyAssertion>
Turtle構文
 :Father  rdfs:subClassOf  [
   rdf:type            owl:Class ;
   owl:intersectionOf  ( :Man  :Parent )
 ] .
 
 :Parent  owl:equivalentClass  [
   rdf:type            owl:Restriction ;
   owl:onProperty      :hasChild ;
   owl:someValuesFrom  :Person
 ] .
 
 :NarcisticPerson  owl:equivalentClass  [
   rdf:type        owl:Restriction ;
   owl:onProperty  :loves ;
   owl:hasSelf     true
 ] .
 
 [] rdf:type     owl:AllDisjointClasses ;
    owl:members  ( :Mother  :Father :YoungChild ) .
 
 :hasUncle  owl:propertyChainAxiom  ( :hasFather  :hasBrother ) .
 
 []  rdf:type               owl:NegativePropertyAssertion ;
     owl:sourceIndividual   :Bill ;
     owl:assertionProperty  :hasDaughter ;
     owl:targetIndividual   :Susan .
マンチェスター構文
 Class: Father
   SubClassOf: Man and Parent
 
 Class: Parent
   EquivalentTo: hasChild some Person
 
 Class: NarcisticPerson
   EquivalentTo: loves Self
 
 DisjointClasses: Mother, Father, YoungChild
 
 ObjectProperty: hasUncle
   SubPropertyChain: hasFather o hasBrother
 
 Individual: Bill
   Facts: not hasDaughter Susan
OWL/XML構文
 <SubClassOf>
   <Class IRI="Father"/>
   <ObjectIntersectionOf>
     <Class IRI="Man"/>
     <Class IRI="Parent"/>
   </ObjectIntersectionOf>
 </SubClassOf>
 
 <EquivalentClasses>
   <Class IRI="Parent"/>
   <ObjectSomeValuesFrom>
     <ObjectProperty IRI="hasChild"/>
     <Class IRI="Person"/>
   </ObjectSomeValuesFrom>
 </EquivalentClasses>
 
 <EquivalentClasses>   <Class IRI="NarcisticPerson"/>
   <ObjectHasSelf>
     <ObjectProperty IRI="loves"/>
   </ObjectHasSelf>
 </EquivalentClasses>
 
 <DisjointClasses>
     <Class IRI="Father"/>
     <Class IRI="Mother"/>
     <Class IRI="YoungChild"/>
 </DisjointClasses>
 
 <SubObjectPropertyOf>
   <ObjectPropertyChain>
     <ObjectProperty IRI="hasFather"/>
     <ObjectProperty IRI="hasBrother"/>
   </ObjectPropertyChain>
   <ObjectProperty IRI="hasUncle"/>
 </SubObjectPropertyOf>
 
 <NegativeObjectPropertyAssertion>
   <ObjectProperty IRI="hasDaughter"/>
   <NamedIndividual IRI="Bill"/>
   <NamedIndividual IRI="Susan"/>
 </NegativeObjectPropertyAssertion>

10.2 OWL 2 QL

OWL 2 QLは、標準的なリレーショナル・データベース技術(例えば、SQL)を用いて、クラス公理の観点でクエリを拡張するだけで実現できます。これは、RDBMSと密接に統合可能で、その強力な実装とマルチユーザ機能の恩恵を受けられることを意味します。さらに、「データに触れる」必要がないため、実際に翻訳/前処理レイヤーとして実装できます。それは、実体関連図とUML図(少なくとも関数制限があるもの)の重要な機能を表現力豊かに表わすことができます。したがって、データベース・スキーマの表現と、クエリの書き換えによるそのスキーマの統合に適しています。その結果、ユーザは図に基づいた構文を好むかもしれませんが、高度なデータベース・スキーマ言語としても直接使用できます。

OWL 2 QLは、逆プロパティーやサブプロパティー階層のような、RDFSとその小さな拡張において一般的に用いられる機能の多くも取り入れています。OWL 2 QLは、クラス公理を非対称的に制限します。すなわち、スーパークラスとして使用できないサブクラスとして構成子を使用できます。

構成子の中でも、とりわけOWL 2 QLでは、クラス式に対する役割の特称量化は許されていません。すなわち、すべての人には親がいるけれども、すべての人に女性の親がいるとは限らないと述べることができます。さらに、プロパティー連鎖公理はサポオートされていません。

QLという頭字語は、クエリを標準的なリレーショナル型クエリ言語[DL-Lite]に書き換えることによって、このプロファイルで回答を行うクエリを実装できるという事実を反映しています。

次は、OWL 2 QLで利用可能な典型的なモデル化機能のいくつかを用いた例です。最初の公理は、すべての子供のいない人は、親という一人称を持っていない人であると述べています。

関数型構文
 SubClassOf( 
   :ChildlessPerson 
   ObjectIntersectionOf(
     :Person 
     ObjectComplementOf(
       ObjectSomeValuesFrom(
         ObjectInverseOf( :hasParent )
         owl:Thing
       )
     )
   )
 ) 
 
 DisjointClasses( 
   :Mother 
   :Father
   :YoungChild 
 )
  DisjointObjectProperties( 
   :hasSon 
   :hasDaughter 
 )
 
 SubObjectPropertyOf( 
   :hasFather 
   :hasParent
 )
RDF/XML構文
 <owl:Class rdf:about="ChildlessPerson">
   <rdfs:subClassOf>
     <owl:Class>
       <owl:intersectionOf rdf:parseType="Collection">
         <owl:Class rdf:about="Person"/>
         <owl:Class>
           <owl:complementOf>
             <owl:Restriction>
               <owl:onProperty>
                 <owl:ObjectProperty>
                   <owl:inverseOf rdf:resource="hasParent"/>
                 </owl:ObjectProperty>
               </owl:onProperty>
               <owl:someValuesFrom rdf:resource="Person"/>
             </owl:Restriction>
           </owl:complementOf>
         </owl:Class>
       </owl:intersectionOf>
     </owl:Class>
   </rdfs:subClassOf>
 </owl:Class>
 
 <owl:AllDisjointClasses>
   <owl:members rdf:parseType="Collection">
     <owl:Class rdf:about="Mother"/>
     <owl:Class rdf:about="Father"/>
     <owl:Class rdf:about="YoungChild"/>
   </owl:members>
 </owl:AllDisjointClasses>
 
 <owl:ObjectProperty rdf:about="hasSon">
   <owl:propertyDisjointWith rdf:resource="hasDaughter"/>
 </owl:ObjectProperty>
 
 <owl:ObjectProperty rdf:about="hasFather">
   <rdfs:subPropertyOf rdf:resource="hasParent"/>
 </owl:ObjectProperty>
Turtle構文
 :ChildlessPerson  owl:subClassOf  [
   rdf:type            owl:Class ;
   owl:intersectionOf  ( :Person 
                         [ owl:complementOf  [
                             rdf:type            owl:Restriction ;
                             owl:onProperty      [ owl:inverseOf  :hasParent ] ;
                             owl:someValuesFrom  owl:Thing
                           ]
                         ]
                       )
 ] .
 
 []  rdf:type    owl:AllDisjointClasses ;
     owl:members ( :Mother  :Father  :YoungChild ) .
 
 :hasSon  owl:propertyDisjointWith  :hasDaughter.
 
 :hasFather  rdfs:subPropertyOf  :hasParent.
マンチェスター構文
 Class: ChildlessPerson
   SubClassOf: Person and not inverse hasParent some owl:Thing
 
 DisjointClasses: Mother, Father, YoungChild
 
 DisjointProperties: hasSon, hasDaughter
 
 ObjectProperty: hasFather
   SubPropertyOf: hasParent
OWL/XML構文
 <SubClassOf>
   <Class IRI="ChildlessPerson"/>
   <ObjectIntersectionOf>
     <Class IRI="Person"/>
     <ObjectComplementOf>
       <ObjectSomeValuesFrom>
         <ObjectInverseOf>
           <ObjectProperty IRI="hasParent"/>
         </ObjectInverseOf>         <Class abbreviatedIRI="owl:Thing"/>
       </ObjectSomeValuesFrom>
     </ObjectComplementOf>
   </ObjectIntersectionOf>
 </SubClassOf>
 
 <DisjointClasses>
     <Class IRI="Father"/>
     <Class IRI="Mother"/>
     <Class IRI="YoungChild"/>
 </DisjointClasses>
 
 <DisjointObjectProperties>
   <ObjectProperty IRI="hasSon"/>
   <ObjectProperty IRI="hasDaughter"/>
 </DisjointObjectProperties>
 
 <SubObjectPropertyOf>
   <ObjectProperty IRI="hasFather"/>
   <ObjectProperty IRI="hasParent"/>
 </SubObjectPropertyOf>

10.3 OWL 2 RL

OWL 2 RLプロファイルは、表現力をあまり犠牲にすることなく、スケーラブルな推論を必要とするアプリケーションを対象としています。これは、言語の完全な表現力と効率とを交換できるOWL 2アプリケーションと、OWL 2の表現力を追加する必要があるRDF(S)アプリケーションの両方に対応するように作られています。これは、規則ベースの技術を用いた実装が可能なOWL 2の構文上のサブセットを定義し、そのような実装の基礎として使用できる一次含意の形でOWL 2 RDFベースのセマンティクスの部分的な公理化を示すことによって達成されます。

OWL 2 RLの適切な規則ベースの実装は、任意のRDFグラフと一緒に使用できます。その結果、OWL 2 RLは、特に規則を追加してデータを操作しなければならないときに、RDFデータを豊かにするために理想的です。しかし、モデル化の観点では、これは、クラス式の扱いからかけ離れてしまいます。OWL 2 RLでは、スーパークラスの式で未知の個体に関して(容易に)述べることは確実にできません(この制限は、規則の性質から生じる)。OWL 2 QLと比べて、OWL 2 RLは、データを既に操作してRDFにし、それをRDFとして扱う場合にうまく機能します。

構成子の中でも、とりわけOWL 2 RLでは、個体の存在が別の個体の存在を強制するようなステートメントは許されていません。例えば、「すべての人には親がいる」というステートメントは、OWL RLでは表現できません。

OWL 2 RLは、クラス公理を非対称的に制限します。すなわち、スーパークラスとして使用できないサブクラスとして構成子を使用できます。

RLという頭字語は、標準的な規則言語[DLP]を用いることで、このプロファイルの推論を実装できるという事実を反映しています。

次の例では、OWL 2 RLで利用可能な典型的なモデル化機能のいくつかを用いています。最初の(やや不自然な)公理は、女性であるメアリー、ビル、メグのそれぞれに関し、彼女は最大1人の子供を持つ親であり、彼女のすべての子供(彼女に子供がいれば)は女性であるということが成立すると述べています。

関数型構文
 SubClassOf(
   ObjectIntersectionOf(
     ObjectOneOf( :Mary :Bill :Meg )
     :Female
   )
   ObjectIntersectionOf(
     :Parent
     ObjectMaxCardinality( 1 :hasChild )
     ObjectAllValuesFrom( :hasChild :Female )
   )
 )
 
 DisjointClasses( 
   :Mother 
   :Father 
   :YoungChild 
 )
 
 SubObjectPropertyOf( 
   ObjectPropertyChain( :hasFather :hasBrother ) 
   :hasUncle 
 )
RDF/XML構文
 <owl:Class>
   <owl:intersectionOf rdf:parseType="Collection">
     <owl:Class>
       <owl:oneOf rdf:parseType="Collection">
         <rdf:Description rdf:about="Mary"/>
         <rdf:Description rdf:about="Bill"/>
         <rdf:Description rdf:about="Meg"/>
       </owl:oneOf>     </owl:Class>
     <owl:Class rdf:about="Female"/>
   </owl:intersectionOf>
   <rdfs:subClassOf>
     <owl:Class>
       <owl:intersectionOf rdf:parseType="Collection">
         <owl:Class rdf:about="Parent"/>
         <owl:Restriction>
           <owl:maxCardinality rdf:datatype="&xsd;nonNegativeInteger">
             2
           </owl:maxCardinality>
           <owl:onProperty rdf:resource="hasChild"/>
         </owl:Restriction>
         <owl:Restriction>
           <owl:onProperty rdf:resource="hasChild"/>
           <owl:allValuesFrom rdf:resource="Female"/>
         </owl:Restriction>
       </owl:intersectionOf>
     </owl:Class>
   </rdfs:subClassOf>
 </owl:Class>
 
 <owl:AllDisjointClasses>
   <owl:members rdf:parseType="Collection">
     <owl:Class rdf:about="Mother"/>
     <owl:Class rdf:about="Father"/>
     <owl:Class rdf:about="YoungChild"/>
   </owl:members>
 </owl:AllDisjointClasses>

 <rdf:Description rdf:about="hasUncle">
   <owl:propertyChainAxiom rdf:parseType="Collection">
     <owl:ObjectProperty rdf:about="hasFather"/>
     <owl:ObjectProperty rdf:about="hasBrother"/>
   </owl:propertyChainAxiom>
 </rdf:Description>
Turtle構文
 []  rdf:type            owl:Class ;
     owl:intersectionOf  ( [ rdf:type   owl:Class ;
                             owl:oneOf  ( :Mary  :Bill  :Meg ) ]
                           :Female 
                         ) ;
     rdfs:subClassOf     [
       rdf:type            owl:Class ;
       owl:intersectionOf  ( :Parent  
                             [ rdf:type            owl:Restriction ;
                               owl:maxCardinality  "1"^^xsd:nonNegativeInteger ;
                               owl:onProperty      :hasChild ]
                             [ rdf:type           owl:Restriction ;
                               owl:onProperty     :hasChild ;
                               owl:allValuesFrom  :Female ]
                           )
     ] .

 []  rdf:type     owl:AllDisjointClasses ;
     owl:members  ( :Mother  :Father  :YoungChild ) .
 
 :hasUncle  owl:propertyChainAxiom  ( :hasFather  :hasBrother ) .
マンチェスター構文
 Class: X
   SubClassOf: Parent and hasChild max 1 and hasChild only Female
 Class: X
   EquivalentTo: {Mary, Bill, Meg} and Female
 
 DisjointClasses: Mother, Father, YoungChild
 
 ObjectProperty: hasUncle
   SubPropertyChain: hasFather o hasBrother
OWL/XML構文
 <SubClassOf>   <ObjectIntersectionOf>
     <ObjectOneOf>
       <NamedIndividual IRI="Mary"/>
       <NamedIndividual IRI="Bill"/>
       <NamedIndividual IRI="Meg"/>
     </ObjectOneOf>
     <Class IRI="Female"/>
   </ObjectIntersectionOf>
   <ObjectIntersectionOf>
     <Class IRI="Parent"/>
     <ObjectMaxCardinality cardinality="1">
       <ObjectProperty IRI="hasChild"/>
     </ObjectMaxCardinality>
     <ObjectAllValuesFrom>
       <ObjectProperty IRI="hasChild"/>
       <Class IRI="Female"/>
     </ObjectAllValuesFrom>
   </ObjectIntersectionOf>
 </SubClassOf>
 
 <DisjointClasses>
     <Class IRI="Father"/>
     <Class IRI="Mother"/>
     <Class IRI="YoungChild"/>
 </DisjointClasses>
 
 <SubObjectPropertyOf>
   <ObjectPropertyChain>
     <ObjectProperty IRI="hasFather"/>
     <ObjectProperty IRI="hasBrother"/>   </ObjectPropertyChain>
   <ObjectProperty IRI="hasUncle"/>
 </SubObjectPropertyOf>

11 OWLツール

OWLオントロジーを扱うためには、ツールのサポートは不可欠です。基本的に、オントロジーのライフ・サイクルの2つの主要な段階に対応した2種類のツールがあります。オントロジー・エディタは、オントロジーを作成、編集するために用いられ、推論システムは、オントロジーにクエリを実行して暗黙知を得るために用いられます。言い換えれば、これは、問題のステートメントがオントロジーにおいて論理的帰結であるか否かを決定します。

現在最も広く使用されているOWLエディタは、スタンフォード大学で開発された無料オープン・ソースの編集フレームワークであるProtégéです。オープンなプラグイン構造により、特殊用途のオントロジー編集コンポーネントの統合が容易に可能になります。他のエディタには、TopQuadrantの市販のTopBraid Composerやオープン・ソース・システムであるSWOOPおよびNeOn-Toolkitがあります。

推論機能のサポート範囲が異なるOWL DL用の推論システムがいくつかあります。これらの一部は、OWL 2への適合化が現在計画されており、対応する実装を進めています。テスト・スイート・ステータスのドキュメントでは、以下で述べる推論システムの一部が、どの範囲テストケースに準拠しているかを記述しています。

OWL DLの推論システムの場合、最も有名なシステムは、マンチェスター大学のFact++、オックスフォード大学コンピューティング研究所のHermit、Clark & Parsia, LLCのPellet、およびレーサー・システムズのRacerProです。

OWL DLの完全なサポートを目指している汎用推論システムのほかに、OWLの扱いやすいプロファイルに適合させた推論システムがあります。ドレスデン工科大学のCELは、OWL ELをサポートしています。ローマ・ラ・サピエンツァ大学のQuOntoは、OWL QLをサポートしています。ORACLE 11gは、OWL RLをサポートしています。

オープン・ソースのOWL APIは、OWLに関する現在最も重要な開発ツールとしてかなり大きな役割を果たしています。

このドキュメントが作成された時点でいくつかのOWLツールが開発中であり、したがって、現在の概要は、最新の概要ではなく、この開発のスナップショットであると考えるべきと言わなければなりません。OWLツールの詳細リストは、semanticweb.orgESW-Wikiにあります。

12 次に読むべきもの

この短い入門では、OWLの表面をなでることしかできません。ウェブで探せば、OWLとOWLツールの使い方に関すより長く、より詳細なチュートリアルを多く発見できます。これらのドキュメントを読んだり、OWLオントロジーを構築するためにツールを用いることが、OWLに関する実用的な知識を得るには、おそらく最も良い方法です。OWLの基礎をもっと学ぶために、最初に、[FOST]という教科書を読み、次に、そこで引用されている原著を読むことをお勧めします。

また、この短い入門はOWLの規範的な定義ではありません。OWL構文の規範的な定義と、各OWL構成子の意味に関する参考情報は、OWL 2構造仕様ドキュメントおよび関数型構文ドキュメント[OWL 2 Specification]にあります。

OWL 2 クィック・リファレンス・ガイド[OWL 2 Quick Guide]は、特定の言語機能の情報を探す際の参考として便利です。

より形式的なドキュメントに興味がある場合は、OWL 2の形式的な意味は、OWL 2セマンティクス・ドキュメント[OWL 2 Direct Semantics] [OWL 2 RDF-Based Semantics]にあるかもしれません。

OWL構文とRDFトリプルとの間のマッピングは、OWL 2 RDFグラフへのマッピングというドキュメント[OWL 2 RDF Mapping]にあります。

13 付録: 完全なサンプル・オントロジー

ここで、完全なサンプルOWLオントロジーを掲載します。オントロジーの原理は、それが用いるトップレベルの表現力を有する機能によって順序付けられています。さらに、最初にオントロジーおよび宣言情報、その後でプロパティーに関する情報、その次にクラスとデータ型、そして、次に個体という一般的な順序に従います。


関数型構文
 Prefix(:=<http://example.com/owl/families/>)
 Prefix(otherOnt:=<http://example.org/otherOntologies/families/>)
 Prefix(xsd:=<http://www.w3.org/2001/XMLSchema#>)
 Prefix(owl:=<http://www.w3.org/2002/07/owl#>)
 Ontology(<http://example.com/owl/families>
   Import( <http://example.org/otherOntologies/families.owl> )
 
   Declaration( NamedIndividual( :John ) )
   Declaration( NamedIndividual( :Mary ) )
   Declaration( NamedIndividual( :Jim ) )
   Declaration( NamedIndividual( :James ) )
   Declaration( NamedIndividual( :Jack ) )
   Declaration( NamedIndividual( :Bill ) )
   Declaration( NamedIndividual( :Susan ) )
   Declaration( Class( :Person ) )   AnnotationAssertion( rdfs:comment :Person "Represents the set of all people." )
   Declaration( Class( :Woman ) )
   Declaration( Class( :Parent ) )
   Declaration( Class( :Father ) )
   Declaration( Class( :Mother ) )
   Declaration( Class( :SocialRole ) )
   Declaration( Class( :Man ) )
   Declaration( Class( :Teenager ) )
   Declaration( Class( :ChildlessPerson ) )
   Declaration( Class( :Human ) )
   Declaration( Class( :Female ) )
   Declaration( Class( :HappyPerson ) )
   Declaration( Class( :JohnsChildren ) )
   Declaration( Class( :NarcisticPerson ) )
   Declaration( Class( :MyBirthdayGuests ) )
   Declaration( Class( :Dead ) )
   Declaration( Class( :Orphan ) )
   Declaration( Class( :Adult ) )
   Declaration( Class( :YoungChild ) )
   Declaration( ObjectProperty( :hasWife ) )
   Declaration( ObjectProperty( :hasChild ) )
   Declaration( ObjectProperty( :hasDaughter ) )
   Declaration( ObjectProperty( :loves ) )
   Declaration( ObjectProperty( :hasSpouse ) )
   Declaration( ObjectProperty( :hasGrandparent ) )
   Declaration( ObjectProperty( :hasParent ) )
   Declaration( ObjectProperty( :hasBrother ) )
   Declaration( ObjectProperty( :hasUncle ) )
   Declaration( ObjectProperty( :hasSon ) )
   Declaration( ObjectProperty( :hasAncestor ) )
   Declaration( ObjectProperty( :hasHusband ) )
   Declaration( DataProperty( :hasAge ) )
   Declaration( DataProperty( :hasSSN ) )
   Declaration( Datatype( :personAge ) )
   Declaration( Datatype( :majorAge ) )
   Declaration( Datatype( :toddlerAge ) )
 
   SubObjectPropertyOf( :hasWife :hasSpouse )
   SubObjectPropertyOf(
     ObjectPropertyChain( :hasParent :hasParent )
     :hasGrandparent
   )
   SubObjectPropertyOf(
     ObjectPropertyChain( :hasFather :hasBrother )
     :hasUncle
   )
   SubObjectPropertyOf(
     :hasFather
     :hasParent
   )
 
   EquivalentObjectProperties( :hasChild otherOnt:child )
   InverseObjectProperties( :hasParent :hasChild )
   EquivalentDataProperties( :hasAge otherOnt:age )
   DisjointObjectProperties( :hasSon :hasDaughter )
   ObjectPropertyDomain( :hasWife :Man )
   ObjectPropertyRange( :hasWife :Woman )
   DataPropertyDomain( :hasAge :Person )
   DataPropertyRange( :hasAge xsd:nonNegativeInteger )
 
   SymmetricObjectProperty( :hasSpouse )
   AsymmetricObjectProperty( :hasChild )
   DisjointObjectProperties( :hasParent :hasSpouse )
   ReflexiveObjectProperty( :hasRelative )
   IrreflexiveObjectProperty( :parentOf )
   FunctionalObjectProperty( :hasHusband )
   InverseFunctionalObjectProperty( :hasHusband )
   TransitiveObjectProperty( :hasAncestor )
   FunctionalDataProperty( :hasAge )
 
   SubClassOf( :Woman :Person )
   SubClassOf( :Mother :Woman )
   SubClassOf(
     :Grandfather
     ObjectIntersectionOf( :Man :Parent )
   )
   SubClassOf(
     :Teenager
     DataSomeValuesFrom( :hasAge
       DatatypeRestriction( xsd:integer
         xsd:minExclusive "12"^^xsd:integer
         xsd:maxInclusive "19"^^xsd:integer
       )
     )
   )
   SubClassOf(
     Annotation( rdfs:comment "States that every man is a person." )
     :Man
     :Person
   )
   SubClassOf(
     :Father
     ObjectIntersectionOf( :Man :Parent )
   )
   SubClassOf(
     :ChildlessPerson
     ObjectIntersectionOf(
       :Person
       ObjectComplementOf(
         ObjectSomeValuesFrom(
           ObjectInverseOf( :hasParent )
           owl:Thing
         )
       )
     )
   )
   SubClassOf(
     ObjectIntersectionOf(
       ObjectOneOf( :Mary :Bill :Meg )
       :Female
     )
     ObjectIntersectionOf(
       :Parent
       ObjectMaxCardinality( 1 :hasChild )
       ObjectAllValuesFrom( :hasChild :Female )
     )
   )
 
   EquivalentClasses( :Person :Human )
   EquivalentClasses(
     :Mother
     ObjectIntersectionOf( :Woman :Parent )
   )
   EquivalentClasses(
     :Parent
     ObjectUnionOf( :Mother :Father )
   )
   EquivalentClasses(
     :ChildlessPerson     ObjectIntersectionOf(
       :Person
       ObjectComplementOf( :Parent )
     )
   )
   EquivalentClasses(
     :Parent 
     ObjectSomeValuesFrom( :hasChild :Person )
   )
   EquivalentClasses(
     :HappyPerson
     ObjectIntersectionOf(
        ObjectAllValuesFrom( :hasChild :HappyPerson )
        ObjectSomeValuesFrom( :hasChild :HappyPerson )
     )
   )
   EquivalentClasses(
     :JohnsChildren
     ObjectHasValue( :hasParent :John )
   )
   EquivalentClasses(
     :NarcisticPerson
     ObjectHasSelf( :loves )
   )
   EquivalentClasses(
     :MyBirthdayGuests
     ObjectOneOf( :Bill :John :Mary)
   )
   EquivalentClasses(
     :Orphan     ObjectAllValuesFrom(
       ObjectInverseOf( :hasChild )
       :Dead
     )
   )
   EquivalentClasses( :Adult otherOnt:Grownup )
   EquivalentClasses(
     :Parent
     ObjectSomeValuesFrom(
       :hasChild
       :Person
     )
   ) 
   DisjointClasses( :Woman :Man )
   DisjointClasses(
     :Mother
     :Father
     :YoungChild
   )
   HasKey( :Person () ( :hasSSN ) )
 
   DatatypeDefinition(     :personAge
     DatatypeRestriction( xsd:integer
       xsd:minInclusive "0"^^xsd:integer
       xsd:maxInclusive "150"^^xsd:integer
     )
   )
   DatatypeDefinition(     :majorAge
     DataIntersectionOf(
       :personAge
       DataComplementOf( :minorAge )
     )
   )
   DatatypeDefinition(
     :toddlerAge
     DataOneOf( "1"^^xsd:integer "2"^^xsd:integer ) 
   )
 
   ClassAssertion( :Person :Mary )
   ClassAssertion( :Woman :Mary )
   ClassAssertion(
     ObjectIntersectionOf(
       :Person
       ObjectComplementOf( :Parent )
     )
     :Jack
   )
   ClassAssertion(
     ObjectMaxCardinality( 4 :hasChild :Parent )
     :John
   )
   ClassAssertion(
     ObjectMinCardinality( 2 :hasChild :Parent )
     :John
   )
   ClassAssertion(
     ObjectExactCardinality( 3 :hasChild :Parent ) 
     :John
   )
   ClassAssertion(
     ObjectExactCardinality( 5 :hasChild )
     :John
   )
   ClassAssertion( :Father :John )
   ClassAssertion( :SocialRole :Father )
 
   ObjectPropertyAssertion( :hasWife :John :Mary )
   NegativeObjectPropertyAssertion( :hasWife :Bill :Mary )
   NegativeObjectPropertyAssertion(
     :hasDaughter
     :Bill
     :Susan
   )
   DataPropertyAssertion( :hasAge :John "51"^^xsd:integer )
   NegativeDataPropertyAssertion( :hasAge :Jack "53"^^xsd:integer )
 
   SameIndividual( :John :Jack )
   SameIndividual( :John otherOnt:JohnBrown )
   SameIndividual( :Mary otherOnt:MaryBrown )
   DifferentIndividuals( :John :Bill )
 )
RDF/XML構文
<!DOCTYPE rdf:RDF [
    <!ENTITY owl "http://www.w3.org/2002/07/owl#" >
    <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
    <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
    <!ENTITY otherOnt "http://example.org/otherOntologies/families/" >
]>
 
 <rdf:RDF xml:base="http://example.com/owl/families/"
   xmlns="http://example.com/owl/families/"
   xmlns:otherOnt="http://example.org/otherOntologies/families/"
   xmlns:owl="http://www.w3.org/2002/07/owl#"   xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:xsd="http://www.w3.org/2001/XMLSchema#">
 
   <owl:Ontology rdf:about="http://example.com/owl/families">
     <owl:imports rdf:resource="http://example.org/otherOntologies/families.owl" />
   </owl:Ontology>
 
 
   <owl:ObjectProperty rdf:about="hasWife">
     <rdfs:subPropertyOf rdf:resource="hasSpouse"/>
     <rdfs:domain rdf:resource="Man"/>
     <rdfs:range rdf:resource="Woman"/>
   </owl:ObjectProperty>
 
   <owl:ObjectProperty rdf:about="hasParent">
     <owl:inverseOf rdf:resource="hasChild"/>
     <owl:propertyDisjointWith rdf:resource="hasSpouse"/>
   </owl:ObjectProperty>
 
   <owl:ObjectProperty rdf:about="hasSon">
     <owl:propertyDisjointWith rdf:resource="hasDaughter"/>
   </owl:ObjectProperty>
 
   <owl:ObjectProperty rdf:about="hasFather">
     <rdfs:subPropertyOf rdf:resource="hasParent"/>
   </owl:ObjectProperty>
 
   <owl:SymmetricProperty rdf:about="hasSpouse"/>
   <owl:AsymmetricProperty rdf:about="hasChild"/>
   <owl:ReflexiveProperty rdf:about="hasRelative"/>
   <owl:IrreflexiveProperty rdf:about="parentOf"/>
   <owl:FunctionalProperty rdf:about="hasHusband"/>
   <owl:InverseFunctionalProperty rdf:about="hasHusband"/>
   <owl:TransitiveProperty rdf:about="hasAncestor"/>
 
   <rdf:Description rdf:about="hasGrandparent">
     <owl:propertyChainAxiom rdf:parseType="Collection">
       <owl:ObjectProperty rdf:about="hasParent"/>
       <owl:ObjectProperty rdf:about="hasParent"/>
     </owl:propertyChainAxiom>
   </rdf:Description>
 
   <rdf:Description rdf:about="hasUncle">
     <owl:propertyChainAxiom rdf:parseType="Collection">
       <owl:ObjectProperty rdf:about="hasFather"/>
       <owl:ObjectProperty rdf:about="hasBrother"/>
     </owl:propertyChainAxiom>
   </rdf:Description>
 
   <owl:DatatypeProperty rdf:about="hasAge">
     <rdfs:domain rdf:resource="Person"/>
     <rdfs:range rdfs:Datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"/>
     <owl:equivalentProperty rdf:resource="&otherOnt;age"/>
   </owl:DatatypeProperty>
   <owl:FunctionalProperty rdf:about="hasAge"/>
 
 
   <owl:Class rdf:about="Woman">
     <rdfs:subClassOf rdf:resource="Person"/>
   </owl:Class>
 
   <owl:Class rdf:about="Mother">
     <rdfs:subClassOf rdf:resource="Woman"/>
     <owl:equivalentClass>
       <owl:Class>
         <owl:intersectionOf rdf:parseType="Collection">
           <owl:Class rdf:about="Woman"/>
           <owl:Class rdf:about="Parent"/>
         </owl:intersectionOf>
       </owl:Class>
     </owl:equivalentClass>
   </owl:Class>
 
   <owl:Class rdf:about="Person">
     <rdfs:comment>Represents the set of all people.</rdfs:comment>
     <owl:equivalentClass rdf:resource="Human"/>
     <owl:hasKey rdf:parseType="Collection">
       <owl:ObjectProperty rdf:about="hasSSN"/>
     </owl:hasKey>
   </owl:Class>
 
   <owl:Class rdf:about="Parent">
     <owl:equivalentClass>
       <owl:Class>
         <owl:unionOf rdf:parseType="Collection">
           <owl:Class rdf:about="Mother"/>
           <owl:Class rdf:about="Father"/>
         </owl:unionOf>
       </owl:Class>     </owl:equivalentClass>
     <owl:equivalentClass>
       <owl:Restriction>
         <owl:onProperty rdf:resource="hasChild"/>
         <owl:someValuesFrom rdf:resource="Person"/>
       </owl:Restriction>
     </owl:equivalentClass>
   </owl:Class>
 
   <owl:Class rdf:about="ChildlessPerson">
     <owl:equivalentClass>
       <owl:Class>
         <owl:intersectionOf rdf:parseType="Collection">
           <owl:Class rdf:about="Person"/>
           <owl:Class>
             <owl:complementOf rdf:resource="Parent"/>
           </owl:Class>
         </owl:intersectionOf>
       </owl:Class>
     </owl:equivalentClass>
   </owl:Class>
 
   <owl:Class rdf:about="Grandfather">
     <rdfs:subClassOf>
       <owl:Class>
         <owl:intersectionOf rdf:parseType="Collection">
           <owl:Class rdf:about="Man"/>
           <owl:Class rdf:about="Parent"/>
         </owl:intersectionOf>
       </owl:Class>
     </rdfs:subClassOf>
   </owl:Class>
 
   <owl:Class rdf:about="HappyPerson">
     <owl:equivalentClass>
       <owl:Class>
         <owl:intersectionOf rdf:parseType="Collection">
           <owl:Restriction>
             <owl:onProperty rdf:resource="hasChild"/>
             <owl:allValuesFrom rdf:resource="HappyPerson"/>
           </owl:Restriction>
           <owl:Restriction>
             <owl:onProperty rdf:resource="hasChild"/>
             <owl:someValuesFrom rdf:resource="HappyPerson"/>
           </owl:Restriction>
         </owl:intersectionOf>       </owl:Class>
     </owl:equivalentClass>
   </owl:Class>
 
   <owl:Class rdf:about="JohnsChildren">
     <owl:equivalentClass>
       <owl:Restriction>
         <owl:onProperty rdf:resource="hasParent"/>
         <owl:hasValue rdf:resource="John"/>
       </owl:Restriction>
     </owl:equivalentClass>
   </owl:Class>
 
   <owl:Class rdf:about="NarcisticPerson">
     <owl:equivalentClass>
       <owl:Restriction>
         <owl:onProperty rdf:resource="loves"/>
         <owl:hasSelf rdf:datatype="&xsd;boolean">
           true
         </owl:hasSelf>
       </owl:Restriction>
     </owl:equivalentClass>
   </owl:Class>
 
   <owl:Class rdf:about="MyBirthdayGuests">
     <owl:equivalentClass>
       <owl:Class>
         <owl:oneOf rdf:parseType="Collection">
           <rdf:Description rdf:about="Bill"/>
           <rdf:Description rdf:about="John"/>
           <rdf:Description rdf:about="Mary"/>
         </owl:oneOf>
       </owl:Class>
     </owl:equivalentClass>
   </owl:Class>
 
   <owl:Class rdf:about="Orphan">
     <owl:equivalentClass>
       <owl:Restriction>
         <owl:onProperty>
           <owl:ObjectProperty>
             <owl:inverseOf rdf:resource="hasChild"/>
           </owl:ObjectProperty>
         </owl:onProperty>
         <owl:Class rdf:resource="Dead"/>
       </owl:Restriction>
     </owl:equivalentClass>
   </owl:Class>
 
   <owl:Class rdf:about="Teenager">
     <rdfs:subClassOf>
       <owl:Restriction>
         <owl:onProperty rdf:resource="hasAge"/>
         <owl:someValuesFrom>
           <rdfs:Datatype>
             <owl:onDataType rdf:resource="&xsd;integer"/>
             <owl:withRestrictions rdf:parseType="Collection">
               <rdf:Description>
                 <xsd:minExclusive rdf:datatype="&xsd;integer">12</xsd:minExclusive>
               </rdf:Description>
               <rdf:Description>
                 <xsd:maxInclusive rdf:datatype="&xsd;integer">19</xsd:maxInclusive>
               </rdf:Description>
             </owl:withRestrictions>
           </rdfs:Datatype>
         </owl:someValuesFrom>
       </owl:Restriction>
     </rdfs:subClassOf>
   </owl:Class>
 
   <owl:Class rdf:about="Man">
     <rdfs:subClassOf rdf:resource="Person"/>
   </owl:Class>
   <owl:Axiom>
     <owl:annotatedSource rdf:resource="Man"/>
     <owl:annotatedProperty rdf:resource="&rdfs;subClassOf"/>
     <owl:annotatedTarget rdf:resource="Person"/>
     <rdfs:comment>States that every man is a person.</rdfs:comment>
   </owl:Axiom>
 
   <owl:Class rdf:about="Adult">
     <owl:equivalentClass rdf:resource="&otherOnt;Grownup"/>
   </owl:Class>
    <owl:Class rdf:about="Father">
     <rdfs:subClassOf>
       <owl:Class>
         <owl:intersectionOf rdf:parseType="Collection">
           <owl:Class rdf:about="Man"/>
           <owl:Class rdf:about="Parent"/>
         </owl:intersectionOf>
       </owl:Class>
     </rdfs:subClassOf>
   </owl:Class>
 
   <owl:Class rdf:about="ChildlessPerson">
     <rdfs:subClassOf>
       <owl:Class>
         <owl:intersectionOf rdf:parseType="Collection">
           <owl:Class rdf:about="Person"/>
           <owl:Class>
             <owl:complementOf>
               <owl:Restriction>
                 <owl:onProperty>
                   <owl:ObjectProperty>
                     <owl:inverseOf rdf:resource="hasParent"/>
                   </owl:ObjectProperty>
                 </owl:onProperty>
                 <owl:someValuesFrom rdf:resource="&owl;Thing"/>
               </owl:Restriction>
             </owl:complementOf>
           </owl:Class>
         </owl:intersectionOf>
       </owl:Class>
     </rdfs:subClassOf>
   </owl:Class>
 
   <owl:Class>
     <owl:intersectionOf rdf:parseType="Collection">
       <owl:Class>
         <owl:oneOf rdf:parseType="Collection">
           <rdf:Description rdf:about="Mary"/>
           <rdf:Description rdf:about="Bill"/>
           <rdf:Description rdf:about="Meg"/>
         </owl:oneOf>
       </owl:Class>
       <owl:Class rdf:about="Female"/>
     </owl:intersectionOf>
     <rdfs:subClassOf>
       <owl:Class>
         <owl:intersectionOf rdf:parseType="Collection">
           <owl:Class rdf:about="Parent"/>
           <owl:Restriction>
             <owl:maxCardinality rdf:datatype="&xsd;nonNegativeInteger">
               2
             </owl:maxCardinality>
             <owl:onProperty rdf:resource="hasChild"/>
           </owl:Restriction>
           <owl:Restriction>
             <owl:onProperty rdf:resource="hasChild"/>
             <owl:allValuesFrom rdf:resource="Female"/>
           </owl:Restriction>
         </owl:intersectionOf>
       </owl:Class>
     </rdfs:subClassOf>
   </owl:Class>
 
   <owl:AllDisjointClasses>
     <owl:members rdf:parseType="Collection">
       <owl:Class rdf:about="Woman"/>
       <owl:Class rdf:about="Man"/>
     </owl:members>
   </owl:AllDisjointClasses>
 
   <owl:AllDisjointClasses>
     <owl:members rdf:parseType="Collection">
       <owl:Class rdf:about="Mother"/>
       <owl:Class rdf:about="Father"/>
       <owl:Class rdf:about="YoungChild"/>
     </owl:members>
   </owl:AllDisjointClasses>
 
 
   <rdf:Description rdf:about="personAge">
     <owl:equivalentClass>
       <rdfs:Datatype>         <owl:onDatatype rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/>
         <owl:withRestrictions rdf:parseType="Collection">
           <rdf:Description>
             <xsd:minInclusive rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">0</xsd:minInclusive>
           </rdf:Description>
           <rdf:Description>
             <xsd:maxInclusive rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">150</xsd:maxInclusive>
           </rdf:Description>
         </owl:withRestrictions>
       </rdfs:Datatype>
     </owl:equivalentClass>
   </rdf:Description>
 
   <rdf:Description rdf:about="majorAge">
     <owl:equivalentClass>
       <rdfs:Datatype>
         <owl:intersectionOf rdf:parseType="Collection">
           <rdf:Description rdf:about="personAge"/>
           <rdfs:Datatype>
             <owl:datatypeComplementOf rdf:resource="minorAge"/>
           </rdfs:Datatype>
         </owl:intersectionOf>
       </rdfs:Datatype>
     </owl:equivalentClass>
   </rdf:Description>
 
   <rdf:Description rdf:about="toddlerAge">
     <owl:equivalentClass>
       <rdfs:Datatype>
         <owl:oneOf>
           <rdf:Description>
             <rdf:first rdf:datatype="&xsd;integer">1</rdf:first>
             <rdf:rest>
               <rdf:Description>
                 <rdf:first rdf:datatype="&xsd;integer">2</rdf:first>
                 <rdf:rest rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/>
               </rdf:Description>
             </rdf:rest>
           </rdf:Description>
         </owl:oneOf>
       </rdfs:Datatype>
     </owl:equivalentClass>
   </rdf:Description>
 
 
   <Person rdf:about="Mary">
     <rdf:type rdf:resource="Woman"/>
     <owl:sameAs rdf:resource="&otherOnt;MaryBrown"/>
   </Person>
 
   <owl:NamedIndividual rdf:about="James">
     <owl:sameAs rdf:resource="Jim"/>
   </owl:NamedIndividual>
 
   <rdf:Description rdf:about="Jack">
     <rdf:type>
       <owl:Class>
         <owl:intersectionOf  rdf:parseType="Collection">
           <owl:Class rdf:about="Person"/>
           <owl:Class>
             <owl:complementOf rdf:resource="Parent"/>
           </owl:Class>
         </owl:intersectionOf>
       </owl:Class>
     </rdf:type>
   </rdf:Description>
 
   <owl:NamedIndividual rdf:about="John">
     <hasWife rdf:resource="Mary"/>
     <hasAge rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">51</hasAge>
     <owl:differentFrom rdf:resource="Bill"/>
     <owl:sameAs rdf:resource="&otherOnt;JohnBrown"/>
     <rdf:type rdf:resource="Person"/>
     <rdf:type rdf:resource="Father"/>
     <rdf:type>
       <owl:Restriction>
         <owl:maxQualifiedCardinality rdf:datatype="&xsd;nonNegativeInteger">
           4
         </owl:maxQualifiedCardinality>
         <owl:onProperty rdf:resource="hasChild"/>
         <owl:onClass rdf:resource="Parent"/>
       </owl:Restriction>
     </rdf:type>
     <rdf:type>
       <owl:Restriction>
         <owl:minQualifiedCardinality rdf:datatype="&xsd;nonNegativeInteger">
           2
         </owl:minQualifiedCardinality>
         <owl:onProperty rdf:resource="hasChild"/>
         <owl:onClass rdf:resource="Parent"/>
       </owl:Restriction>
     </rdf:type>
     <rdf:type>
       <owl:Restriction>
         <owl:qualifiedCardinality rdf:datatype="&xsd;nonNegativeInteger">
           3
         </owl:qualifiedCardinality>
         <owl:onProperty rdf:resource="hasChild"/>
         <owl:onClass rdf:resource="Parent"/>
       </owl:Restriction>
     </rdf:type>
     <rdf:type>
       <owl:Restriction>
         <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">
           5
         </owl:cardinality>
         <owl:onProperty rdf:resource="hasChild"/>
       </owl:Restriction>
     </rdf:type>
   </owl:NamedIndividual>
 
   <SocialRole rdf:about="Father"/>
 
   <owl:NegativePropertyAssertion>
     <owl:sourceIndividual rdf:resource="Bill"/>
     <owl:assertionProperty rdf:resource="hasWife"/>
     <owl:targetIndividual rdf:resource="Mary"/>
   </owl:NegativePropertyAssertion>
 
   <owl:NegativePropertyAssertion>
     <owl:sourceIndividual rdf:resource="Jack"/>
     <owl:assertionProperty rdf:resource="hasAge"/>
     <owl:targetValue rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">53</owl:targetValue>
   </owl:NegativePropertyAssertion>
 
   <owl:NegativePropertyAssertion>     <owl:sourceIndividual rdf:resource="Bill"/>
     <owl:assertionProperty rdf:resource="hasDaughter"/>
     <owl:targetIndividual rdf:resource="Susan"/>
   </owl:NegativePropertyAssertion>
 </rdf:RDF>
Turtle構文
@prefix : <http://example.com/owl/families/> .
@prefix otherOnt: <http://example.org/otherOntologies/families/> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://example.com/owl/families> 
     rdf:type owl:Ontology ;
     owl:imports <http://example.org/otherOntologies/families.owl> .

:hasSpouse    rdf:type  owl:SymmetricProperty .
:hasRelative  rdf:type  owl:ReflexiveProperty .
:parentOf     rdf:type  owl:IrreflexiveProperty .
:hasAncestor  rdf:type  owl:TransitiveProperty .

:hasHusband   rdf:type  owl:FunctionalProperty .
:hasHusband   rdf:type  owl:InverseFunctionalProperty .

:hasWife rdf:type           owl:ObjectProperty .
:hasWife rdfs:domain        :Man ;
         rdfs:range         :Woman .
:hasWife rdfs:subPropertyOf :hasSpouse .

:hasSon     owl:propertyDisjointWith  :hasDaughter.
:hasFather  rdfs:subPropertyOf        :hasParent.
 
:hasParent owl:inverseOf             :hasChild .
:hasParent owl:propertyDisjointWith  :hasSpouse .

:hasGrandparent  owl:propertyChainAxiom  ( :hasParent  :hasParent ) .
:hasUncle        owl:propertyChainAxiom  ( :hasFather  :hasBrother ) .

:hasAge  owl:equivalentProperty  otherOnt:age .
:hasAge  rdf:type                owl:DatatypeProperty .
:hasAge  rdf:type                owl:FunctionalProperty .:hasAge  rdfs:domain             :Person ;
         rdfs:range              xsd:nonNegativeInteger .

:hasChild  owl:equivalentProperty  otherOnt:child .:hasChild  rdf:type                owl:AsymmetricProperty .

:Woman   rdfs:subClassOf :Person .

:Mother  rdfs:subClassOf :Woman .
:Mother  owl:equivalentClass  [
  rdf:type            owl:Class ;
  owl:intersectionOf  ( :Woman :Parent ) 
] .

:Person  rdf:type            owl:Class .
:Person  owl:equivalentClass :Human .
:Person  rdfs:comment        "Represents the set of all people."^^xsd:string .
:Person  owl:hasKey          ( :hasSSN ) .
:Parent  owl:equivalentClass [
  rdf:type     owl:Class ;
  owl:unionOf  ( :Mother :Father )
] .

:Parent  owl:equivalentClass  [
  rdf:type            owl:Restriction ;
  owl:onProperty      :hasChild ;
  owl:someValuesFrom  :Person
] .

:Grandfather  rdfs:subClassOf  [
  rdf:type            owl:Class ;
  owl:intersectionOf  ( :Man  :Parent )
] .

:HappyPerson
    owl:equivalentClass  [
      rdf:type            owl:Class ;
      owl:intersectionOf  ( [ rdf:type            owl:Restriction ;
                              owl:onProperty      :hasChild ;
                              owl:allValuesFrom   :HappyPerson      ]
                            [ rdf:type            owl:Restriction ;
                              owl:onProperty      :hasChild ;
                              owl:someValuesFrom  :HappyPerson      ]
                          )
    ] .

:JohnsChildren  owl:equivalentClass  [
  rdf:type        owl:Restriction ;
  owl:onProperty  :hasParent ;
  owl:hasValue    :John
] .

:NarcisticPerson owl:equivalentClass  [
  rdf:type        owl:Restriction ;
  owl:onProperty  :loves ;  owl:hasSelf     "true"^^xsd:boolean .
] .

:MyBirthdayGuests  owl:equivalentClass  [
  rdf:type   owl:Class ;
  owl:oneOf  ( :Bill  :John  :Mary )
] .
:Orphan  owl:equivalentClass  [
  rdf:type           owl:Restriction ;
  owl:onProperty     [ owl:inverseOf  :hasChild ] ;
  owl:allValuesFrom  :Dead 
] .

:Teenager  rdfs:subClassOf
      [ rdf:type             owl:Restriction ;
        owl:onProperty       :hasAge ;
        owl:someValuesFrom
         [ rdf:type             rdfs:Datatype ;
           owl:onDatatype       xsd:integer ;
           owl:withRestrictions (  [ xsd:minExclusive     "12"^^xsd:integer ]
                                   [ xsd:maxInclusive     "19"^^xsd:integer ]
           )
         ]
      ] .

:Man rdfs:subClassOf        :Person .
[]   rdf:type               owl:Axiom ;
     owl:annotatedSource    :Man ;
     owl:annotatedProperty  rdfs:subClassOf ;     owl:annotatedTarget    :Person ;
     rdfs:comment           "States that every man is a person."^^xsd:string .

:Adult owl:equivalentClass otherOnt:Grownup .

:Father rdfs:subClassOf  [
  rdf:type            owl:Class ;
  owl:intersectionOf  ( :Man  :Parent )
] .

:ChildlessPerson      owl:equivalentClass  [
  rdf:type            owl:Class ;  owl:intersectionOf  ( :Person  [ owl:complementOf  :Parent ] ) 
] .
:ChildlessPerson      owl:subClassOf  [
  rdf:type            owl:Class ;
  owl:intersectionOf  ( :Person
                        [ owl:complementOf  [
                            rdf:type            owl:Restriction ;
                            owl:onProperty      [ owl:inverseOf  :hasParent ] ;
                            owl:someValuesFrom  owl:Thing
                          ]
                        ]
                      )
] .

[]  rdf:type            owl:Class ;
    owl:intersectionOf  ( [ rdf:type   owl:Class ;
                            owl:oneOf  ( :Mary  :Bill  :Meg ) ]
                          :Female 
                        ) ;
    rdfs:subClassOf     [
      rdf:type            owl:Class ;
      owl:intersectionOf  ( :Parent  
                            [ rdf:type            owl:Restriction ;
                              owl:maxCardinality  "1"^^xsd:nonNegativeInteger ;
                              owl:onProperty      :hasChild ]
                            [ rdf:type           owl:Restriction ;
                              owl:onProperty     :hasChild ;
                              owl:allValuesFrom  :Female ]
                          )
    ] .

[] rdf:type     owl:AllDisjointClasses ;
   owl:members  ( :Mother  :Father  :YoungChild ) .

[] rdf:type     owl:AllDisjointClasses ;
   owl:members  ( :Woman  :Man ) .

:personAge  owl:equivalentClass
 [ rdf:type       rdfs:Datatype;
   owl:onDatatype xsd:integer;
   owl:withRestrictions (
      [ xsd:minInclusive "0"^^xsd:integer ]
      [ xsd:maxInclusive "150"^^xsd:integer ] 
   )
 ] .

:majorAge  owl:equivalentClass
  [ rdf:type           rdfs:Datatype;
    owl:intersectionOf (
       :personAge
       [ rdf:type rdfs:Datatype;
         owl:datatypeComplementOf :minorAge ] 
    )
  ] .

:toddlerAge  owl:equivalentClass
  [ rdf:type  rdfs:Datatype;
    owl:oneOf (  "1"^^xsd:integer  "2"^^xsd:integer )
  ] .

:Mary rdf:type   :Person .
:Mary rdf:type   :Woman .
:Mary owl:sameAs otherOnt:MaryBrown .

:James owl:sameAs :Jim .

:Jack  rdf:type          [
  rdf:type            owl:Class ;
  owl:intersectionOf  ( :Person  
                        [ rdf:type          owl:Class ;
                          owl:complementOf  :Parent     ]
                      )
] .

:John  owl:sameAs        otherOnt:JohnBrown .
:John  rdf:type          owl:NamedIndividual .
:John  rdf:type          :Father .
:John  :hasWife          :Mary .
:John  owl:differentFrom :Bill .
:John  :hasAge           51 .
:John  rdf:type  [
  rdf:type                     owl:Restriction ;
  owl:maxQualifiedCardinality  "4"^^xsd:nonNegativeInteger ;
  owl:onProperty               :hasChild ;
  owl:onClass                  :Parent
] .
:John  rdf:type  [
  rdf:type                     owl:Restriction ;
  owl:minQualifiedCardinality  "2"^^xsd:nonNegativeInteger ;
  owl:onProperty               :hasChild ;
  owl:onClass                  :Parent
] .
:John  rdf:type  [
  rdf:type                  owl:Restriction ;
  owl:qualifiedCardinality  "3"^^xsd:nonNegativeInteger ;
  owl:onProperty            :hasChild ;
  owl:onClass               :Parent
] .
:John  rdf:type  [
  rdf:type         owl:Restriction ;
  owl:cardinality  "5"^^xsd:nonNegativeInteger ;
  owl:onProperty   :hasChild
] .

:Father rdf:type :SocialRole .

[]  rdf:type               owl:NegativePropertyAssertion ;
    owl:sourceIndividual   :Bill ;
    owl:assertionProperty  :hasWife ;
    owl:targetIndividual   :Mary .

[]  rdf:type               owl:NegativePropertyAssertion ;
    owl:sourceIndividual   :Bill ;
    owl:assertionProperty  :hasDaughter ;
    owl:targetIndividual   :Susan .

[]  rdf:type               owl:NegativePropertyAssertion ;    owl:sourceIndividual   :Jack ;
    owl:assertionProperty  :hasAge ;
    owl:targetValue        53 .
マンチェスター構文
Prefix: : <http://example.com/owl/families/>
Prefix: xsd: <http://www.w3.org/2001/XMLSchema#>Prefix: owl: <http://www.w3.org/2002/07/owl#>
Prefix: otherOnt: <http://example.org/otherOntologies/families/>
Ontology: <http://example.com/owl/families>
Import: <http://example.org/otherOntologies/families.owl>

ObjectProperty: hasWife
  SubPropertyOf: hasSpouse
  Domain:        Man
  Range:         Woman
ObjectProperty: hasParent
  InverseOf: hasChild
ObjectProperty: hasSpouse
  Characteristics: Symmetric
ObjectProperty: hasChild
  Characteristics: Asymmetric
ObjectProperty: hasRelative
  Characteristics: Reflexive
ObjectProperty: parentOf
  Characteristics: IrreflexiveObjectProperty: hasHusband
  Characteristics: Functional
  Characteristics: InverseFunctional
ObjectProperty: hasAncestor
  Characteristics: Transitive
ObjectProperty: hasGrandparent
  SubPropertyChain: hasParent o hasParent
ObjectProperty: hasUncle
  SubPropertyChain: hasFather o hasBrother
ObjectProperty: hasFather
  SubPropertyOf: hasParent
ObjectProperty: hasBrother
ObjectProperty: hasDaughter
ObjectProperty: loves

DisjointProperties: hasParent, hasSpouse
DisjointProperties: hasSon,    hasDaughter
EquivalentProperties: hasChild, otherOnt:child
EquivalentProperties: hasAge,   otherOnt:age

DataProperty: hasAge
  Domain: Person
  Range:  xsd:nonNegativeInteger
DataProperty: hasHusband
  Characteristics: Functional
DataProperty: hasSSN

Datatype: personAge
  EquivalentTo: integer[<= 0 , >= 150]
Datatype: majorAge
   EquivalentTo: personAge and not minorAge
Datatype: toddlerAge
   EquivalentTo: { 1, 2 }
Datatype: minorAge

Class: Woman
  SubClassOf: Person
Class: Mother
  SubClassOf:   Woman
  EquivalentTo: Woman and Parent
Class: Person
  Annotations:  rdfs:comment "Represents the set of all people."
  EquivalentTo: Human
  HasKey: hasSSN
Class: Parent
  EquivalentTo: hasChild some Person
  EquivalentTo: Mother or Father
Class: ChildlessPerson
  EquivalentTo: Person and not Parent
  SubClassOf:   Person and not inverse hasParent some owl:Thing
Class: Grandfather
  SubClassOf: Man and Parent
Class: HappyPerson
  EquivalentTo: hasChild only Happy and hasChild some Happy
Class: JohnsChildren
  EquivalentTo: hasParent value John
Class: NarcisticPerson
  EquivalentTo: loves Self
Class: Orphan
  EquivalentTo: inverse hasChild only Dead
Class: Teenager
 SubClassOf: hasAge some integer[<= 13 , >= 19]
Class: Man
  SubClassOf: Annotations: rdfs:comment "States that every man is a person." Person
Class: MyBirthdayGuests
  EquivalentTo: { Bill, John, Mary }
Class: Father
  SubClassOf: Man and Parent
Class: X
  SubClassOf:   Parent and hasChild max 1 and hasChild only Female
  EquivalentTo: {Mary, Bill, Meg} and Female
Class: Dead
Class: Father
Class: Female
Class: Happy
Class: Human
Class: SocialRole
Class: YoungChild

DisjointClasses: Mother, Father, YoungChild
DisjointClasses: Woman, Man
EquivalentClasses: Adult, otherOnt:Grownup

Individual: Mary
  Types: Person
  Types: Woman
Individual: Jack
  Types: Person and not Parent
Individual: John
  Types: Father
  Types: hasChild max 4 Parent
  Types: hasChild min 2 Parent
  Types: hasChild exactly 3 Parent
  Types: hasChild exactly 5
  Facts: hasAge "51"^^xsd:integer
  Facts: hasWife Mary
  DifferentFrom: Bill 
Individual: Bill
  Facts: not hasWife     Mary
  Facts: not hasDaughter Susan
Individual: James 
  SameAs: Jim
Individual: Jack  Facts: not hasAge "53"^^xsd:integer
Individual: Father
 Types: SocialRole
Individual: Meg
Individual: Susan
Individual: Jim
Individual: otherOnt:JohnBrownIndividual: otherOnt:MaryBrown

SameIndividual: John, otherOnt:JohnBrown 
SameIndividual: Mary, otherOnt:MaryBrown
OWL/XML構文
<!DOCTYPE Ontology [
   <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
   <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
]>

 <Ontology
   xml:base="http://example.com/owl/families/"
   ontologyIRI="http://example.com/owl/families"
   xmlns="http://www.w3.org/2002/07/owl#">
   <Prefix name="owl" IRI="http://www.w3.org/2002/07/owl#"/>
   <Prefix name="otherOnt" IRI="http://example.org/otherOntologies/families/"/>
   <Import>http://example.org/otherOntologies/families.owl</Import>

   <Declaration>
     <NamedIndividual IRI="John"/>
   </Declaration>
   <Declaration>
     <NamedIndividual IRI="Mary"/>
   </Declaration>
   <Declaration>
     <NamedIndividual IRI="Jim"/>
   </Declaration>
   <Declaration>
     <NamedIndividual IRI="James"/>
   </Declaration>
   <Declaration>
     <NamedIndividual IRI="Jack"/>
   </Declaration>
   <Declaration>
     <NamedIndividual IRI="Bill"/>
   </Declaration>
   <Declaration>
     <NamedIndividual IRI="Susan"/>
   </Declaration>
   <Declaration>
     <NamedIndividual IRI="Meg"/>
   </Declaration>

   <Declaration>
     <Class IRI="Person"/>
   </Declaration>
   <AnnotationAssertion>
     <AnnotationProperty IRI="&rdfs;comment"/>
     <IRI>Person</IRI>
     <Literal>Represents the set of all people.</Literal>
   </AnnotationAssertion>
   <Declaration>
     <Class IRI="Woman"/>
   </Declaration>
   <Declaration>
     <Class IRI="Parent"/>
   </Declaration>
   <Declaration>
     <Class IRI="Father"/>
   </Declaration>
   <Declaration>
     <Class IRI="Mother"/>
   </Declaration>
   <Declaration>
     <Class IRI="SocialRole"/>
   </Declaration>
   <Declaration>     <Class IRI="Man"/>
   </Declaration>
   <Declaration>
     <Class IRI="Teenager"/>
   </Declaration>
   <Declaration>
     <Class IRI="ChildlessPerson"/>
   </Declaration>
   <Declaration>
     <Class IRI="Human"/>
   </Declaration>
   <Declaration>
     <Class IRI="Female"/>
   </Declaration>
   <Declaration>
     <Class IRI="HappyPerson"/>
   </Declaration>
   <Declaration>
     <Class IRI="JohnsChildren"/>
   </Declaration>
   <Declaration>
     <Class IRI="NarcisticPerson"/>
   </Declaration>
   <Declaration>
     <Class IRI="MyBirthdayGuests"/>
   </Declaration>
   <Declaration>
     <Class IRI="Dead"/>
   </Declaration>
   <Declaration>
     <Class IRI="Orphan"/>
   </Declaration>
   <Declaration>
     <Class IRI="Adult"/>
   </Declaration>
   <Declaration>     <Class IRI="YoungChild"/>
   </Declaration>

   <Declaration>
     <ObjectProperty IRI="hasWife"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasChild"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasDaughter"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="loves"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasSpouse"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasGrandparent"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasParent"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasBrother"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasUncle"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasSon"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasAncestor"/>
   </Declaration>
   <Declaration>
     <ObjectProperty IRI="hasHusband"/>
   </Declaration>
   <Declaration>
     <DataProperty IRI="hasAge"/>
   </Declaration>
   <Declaration>
     <DataProperty IRI="hasSSN"/>
   </Declaration>
   <Declaration>
     <Datatype IRI="personAge"/>
   </Declaration>
   <Declaration>
     <Datatype IRI="majorAge"/>
   </Declaration>
   <Declaration>
     <Datatype IRI="toddlerAge"/>
   </Declaration>

   <DatatypeDefinition>
     <Datatype IRI="personAge"/>
     <DatatypeRestriction>
       <Datatype IRI="&xsd;integer"/>
       <FacetRestriction facet="&xsd;minInclusive">
         <Literal datatypeIRI="&xsd;integer">0</Literal>
       </FacetRestriction>
       <FacetRestriction facet="&xsd;maxInclusive">
         <Literal datatypeIRI="&xsd;integer">150</Literal>
       </FacetRestriction>
     </DatatypeRestriction>
   </DatatypeDefinition>
   <DatatypeDefinition>
     <Datatype IRI="majorAge"/>
     <DataIntersectionOf>
       <Datatype IRI="personAge"/>
       <DataComplementOf>
         <Datatype IRI="minorAge"/>
       </DataComplementOf>
     </DataIntersectionOf>
   </DatatypeDefinition>
   <DatatypeDefinition>
     <Datatype IRI="toddlerAge"/>
     <DataOneOf>
       <Literal datatypeIRI="http://www.w3.org/2001/XMLSchema#integer">1</Literal> 
       <Literal datatypeIRI="http://www.w3.org/2001/XMLSchema#integer">2</Literal>
     </DataOneOf>   </DatatypeDefinition>
 
   <SymmetricObjectProperty>
     <ObjectProperty IRI="hasSpouse"/>
   </SymmetricObjectProperty>
   <AsymmetricObjectProperty>
     <ObjectProperty IRI="hasChild"/>
   </AsymmetricObjectProperty>
   <DisjointObjectProperties>
     <ObjectProperty IRI="hasParent"/>
     <ObjectProperty IRI="hasSpouse"/>
   </DisjointObjectProperties>
   <ReflexiveObjectProperty>
     <ObjectProperty IRI="hasRelative"/>
   </ReflexiveObjectProperty>
   <IrreflexiveObjectProperty>
     <ObjectProperty IRI="parentOf"/>
   </IrreflexiveObjectProperty>
   <FunctionalObjectProperty>
     <ObjectProperty IRI="hasHusband"/>
   </FunctionalObjectProperty>
   <InverseFunctionalObjectProperty>
     <ObjectProperty IRI="hasHusband"/>
   </InverseFunctionalObjectProperty>
   <TransitiveObjectProperty>
     <ObjectProperty IRI="hasAncestor"/>
   </TransitiveObjectProperty>

   <ObjectPropertyDomain>
     <ObjectProperty IRI="hasWife"/>
     <Class IRI="Man"/>   </ObjectPropertyDomain>
   <ObjectPropertyRange>
     <ObjectProperty IRI="hasWife"/>
     <Class IRI="Woman"/>
   </ObjectPropertyRange>

   <InverseObjectProperties>
     <ObjectProperty IRI="hasParent"/>
     <ObjectProperty IRI="hasChild"/>
   </InverseObjectProperties>

   <DisjointObjectProperties>
     <ObjectProperty IRI="hasSon"/>
     <ObjectProperty IRI="hasDaughter"/>
   </DisjointObjectProperties>

   <EquivalentObjectProperties>
     <ObjectProperty IRI="hasChild"/>
     <ObjectProperty abbreviatedIRI="otherOnt:child"/>
   </EquivalentObjectProperties>

   <SubObjectPropertyOf>
     <ObjectProperty IRI="hasWife"/>
     <ObjectProperty IRI="hasSpouse"/>
   </SubObjectPropertyOf>
   <SubObjectPropertyOf>
     <ObjectProperty IRI="hasFather"/>
     <ObjectProperty IRI="hasParent"/>
   </SubObjectPropertyOf>
   <SubObjectPropertyOf>
     <ObjectPropertyChain>
       <ObjectProperty IRI="hasParent"/>
       <ObjectProperty IRI="hasParent"/>
     </ObjectPropertyChain>
     <ObjectProperty IRI="hasGrandparent"/>
   </SubObjectPropertyOf>
   <SubObjectPropertyOf>
     <ObjectPropertyChain>
       <ObjectProperty IRI="hasFather"/>
       <ObjectProperty IRI="hasBrother"/>
     </ObjectPropertyChain>
     <ObjectProperty IRI="hasUncle"/>
   </SubObjectPropertyOf>
   <SubObjectPropertyOf>
     <ObjectPropertyChain>
       <ObjectProperty IRI="hasFather"/>
       <ObjectProperty IRI="hasBrother"/>
     </ObjectPropertyChain>
     <ObjectProperty IRI="hasUncle"/>
   </SubObjectPropertyOf>

   <HasKey>
     <Class IRI="Person"/>
     <ObjectProperty IRI="hasSSN"/>
   </HasKey>

   <DataPropertyDomain>
     <DataProperty IRI="hasAge"/>
     <Class IRI="Person"/>
   </DataPropertyDomain>
   <DataPropertyRange>
     <DataProperty IRI="hasAge"/>
     <Datatype IRI="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"/>
   </DataPropertyRange>
   <FunctionalDataProperty>
     <DataProperty IRI="hasHusband"/>
   </FunctionalDataProperty>
   <EquivalentDataProperties>
     <DataProperty IRI="hasAge"/>
     <DataProperty abbreviatedIRI="otherOnt:age"/>
   </EquivalentDataProperties>

   <SubClassOf>
     <Class IRI="Woman"/>
     <Class IRI="Person"/>
   </SubClassOf>
   <SubClassOf>
     <Class IRI="Mother"/>
     <Class IRI="Woman"/>
   </SubClassOf>
   <SubClassOf>
     <Class IRI="Grandfather"/>
     <ObjectIntersectionOf>
       <Class IRI="Man"/>
       <Class IRI="Parent"/>
     </ObjectIntersectionOf>
   </SubClassOf>
   <SubClassOf>
     <Class IRI="Father"/>
     <ObjectIntersectionOf>
       <Class IRI="Man"/>
       <Class IRI="Parent"/>
     </ObjectIntersectionOf>
   </SubClassOf>
   <SubClassOf>
     <Class IRI="ChildlessPerson"/>
     <ObjectIntersectionOf>
       <Class IRI="Person"/>
       <ObjectComplementOf>
         <ObjectSomeValuesFrom>
           <ObjectInverseOf>
             <ObjectProperty IRI="hasParent"/>
           </ObjectInverseOf>
           <Class abbreviatedIRI="owl:Thing"/>
         </ObjectSomeValuesFrom>
       </ObjectComplementOf>
     </ObjectIntersectionOf>
   </SubClassOf>
   <SubClassOf>
     <ObjectIntersectionOf>
       <ObjectOneOf>
         <NamedIndividual IRI="Mary"/>
         <NamedIndividual IRI="Bill"/>
         <NamedIndividual IRI="Meg"/>
       </ObjectOneOf>
       <Class IRI="Female"/>
     </ObjectIntersectionOf>
     <ObjectIntersectionOf>
       <Class IRI="Parent"/>
       <ObjectMaxCardinality cardinality="1">
         <ObjectProperty IRI="hasChild"/>
       </ObjectMaxCardinality>
       <ObjectAllValuesFrom>
         <ObjectProperty IRI="hasChild"/>         <Class IRI="Female"/>
       </ObjectAllValuesFrom>
     </ObjectIntersectionOf>
   </SubClassOf>
   <SubClassOf>
     <Class IRI="Teenager"/>
     <DataSomeValuesFrom>
       <DataProperty IRI="hasAge"/>
       <DatatypeRestriction>
         <Datatype IRI="&xsd;integer"/>
         <FacetRestriction facet="&xsd;minExclusive">
           <Literal datatypeIRI="&xsd;integer">12</Literal>
         </FacetRestriction>
         <FacetRestriction facet="&xsd;maxInclusive">
           <Literal datatypeIRI="&xsd;integer">19</Literal>
         </FacetRestriction>
       </DatatypeRestriction>
     </DataSomeValuesFrom>
   </SubClassOf>
   <SubClassOf>
     <Annotation>
       <AnnotationProperty IRI="&rdfs;comment"/>
       <Literal datatypeIRI="xsd:string">"States that every man is a person."</Literal>
     </Annotation>
     <Class IRI="Man"/>
     <Class IRI="Person"/>
   </SubClassOf>

   <EquivalentClasses>
     <Class IRI="HappyPerson"/>
     <ObjectIntersectionOf>
       <ObjectAllValuesFrom>
         <ObjectProperty IRI="hasChild"/>
         <Class IRI="HappyPerson"/>
       </ObjectAllValuesFrom>
       <ObjectSomeValuesFrom>
         <ObjectProperty IRI="hasChild"/>
         <Class IRI="HappyPerson"/>
       </ObjectSomeValuesFrom>
     </ObjectIntersectionOf>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="JohnsChildren"/>
     <ObjectHasValue>
       <ObjectProperty IRI="hasParent"/>
       <NamedIndividual IRI="John"/>
     </ObjectHasValue>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="NarcisticPerson"/>
     <ObjectHasSelf>
       <ObjectProperty IRI="loves"/>
     </ObjectHasSelf>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="Orphan"/>
     <ObjectAllValuesFrom>
       <ObjectInverseOf>
         <ObjectProperty IRI="hasChild"/>
       </ObjectInverseOf>
       <Class IRI="Dead"/>
     </ObjectAllValuesFrom>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="MyBirthdayGuests"/>
     <ObjectOneOf>
       <NamedIndividual IRI="Bill"/>
       <NamedIndividual IRI="John"/>
       <NamedIndividual IRI="Mary"/>
     </ObjectOneOf>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="Adult"/>
     <Class abbreviatedIRI="otherOnt:Grownup"/>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="Parent"/>
     <ObjectSomeValuesFrom>
       <ObjectProperty IRI="hasChild"/>
       <Class IRI="Person"/>
     </ObjectSomeValuesFrom>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="Parent"/>
     <ObjectSomeValuesFrom>
       <ObjectProperty IRI="hasChild"/>
       <Class IRI="Person"/>
     </ObjectSomeValuesFrom>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="Person"/>
     <Class IRI="Human"/>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="Mother"/>
     <ObjectIntersectionOf>
       <Class IRI="Woman"/>
       <Class IRI="Parent"/>
     </ObjectIntersectionOf>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="Parent"/>
     <ObjectUnionOf>
       <Class IRI="Mother"/>
       <Class IRI="Father"/>
     </ObjectUnionOf>
   </EquivalentClasses>
   <EquivalentClasses>
     <Class IRI="ChildlessPerson"/>
     <ObjectIntersectionOf>
       <Class IRI="Person"/>
       <ObjectComplementOf>
         <Class IRI="Parent"/>
       </ObjectComplementOf>
     </ObjectIntersectionOf>
   </EquivalentClasses>

   <DisjointClasses>
       <Class IRI="Woman"/>
       <Class IRI="Man"/>
   </DisjointClasses>
   <DisjointClasses>
     <Class IRI="Father"/>
     <Class IRI="Mother"/>
     <Class IRI="YoungChild"/>
   </DisjointClasses>

   <DifferentIndividuals>
     <NamedIndividual IRI="John"/>
     <NamedIndividual IRI="Bill"/>
   </DifferentIndividuals>

   <SameIndividual>
     <NamedIndividual IRI="James"/>
     <NamedIndividual IRI="Jim"/>
   </SameIndividual>
   <SameIndividual>
     <NamedIndividual IRI="John"/>
     <NamedIndividual abbreviatedIRI="otherOnt:JohnBrown"/>
   </SameIndividual>
   <SameIndividual>
     <NamedIndividual IRI="Mary"/>
     <NamedIndividual abbreviatedIRI="otherOnt:MaryBrown"/>
   </SameIndividual>

   <ObjectPropertyAssertion>
     <ObjectProperty IRI="hasWife"/>
     <NamedIndividual IRI="John"/>
     <NamedIndividual IRI="Mary"/>
   </ObjectPropertyAssertion>

   <DataPropertyAssertion>
     <DataProperty IRI="hasAge"/>
     <NamedIndividual IRI="John"/>
     <Literal datatypeIRI="http://www.w3.org/2001/XMLSchema#integer">51</Literal>
   </DataPropertyAssertion>

   <ClassAssertion>
       <Class IRI="Person"/>
       <NamedIndividual IRI="Mary"/>
   </ClassAssertion>
   <ClassAssertion>
       <Class IRI="Woman"/>
       <NamedIndividual IRI="Mary"/>
   </ClassAssertion>
   <ClassAssertion>
     <ObjectIntersectionOf>
       <Class IRI="Person"/>
       <ObjectComplementOf>
         <Class IRI="Parent"/>
       </ObjectComplementOf>
     </ObjectIntersectionOf>
     <NamedIndividual IRI="Jack"/>
   </ClassAssertion>

   <ClassAssertion>
     <ObjectMaxCardinality cardinality="4">
       <ObjectProperty IRI="hasChild"/>
       <Class IRI="Parent"/>
     </ObjectMaxCardinality>
     <NamedIndividual IRI="John"/>
   </ClassAssertion>   <ClassAssertion>
     <ObjectMinCardinality cardinality="2">
       <ObjectProperty IRI="hasChild"/>
       <Class IRI="Parent"/>
     </ObjectMinCardinality>
     <NamedIndividual IRI="John"/>
   </ClassAssertion>
   <ClassAssertion>
     <ObjectExactCardinality cardinality="3">
       <ObjectProperty IRI="hasChild"/>
       <Class IRI="Parent"/>
     </ObjectExactCardinality>
     <NamedIndividual IRI="John"/>
   </ClassAssertion>
   <ClassAssertion>
     <ObjectExactCardinality cardinality="5">
       <ObjectProperty IRI="hasChild"/>
     </ObjectExactCardinality>
     <NamedIndividual IRI="John"/>
   </ClassAssertion>
   <ClassAssertion>
     <Class IRI="Father"/>
     <NamedIndividual IRI="John"/>
   </ClassAssertion>
   <ClassAssertion>
     <Class IRI="SocialRole"/>
     <NamedIndividual IRI="Father"/>
   </ClassAssertion>

   <NegativeObjectPropertyAssertion>
     <ObjectProperty IRI="hasWife"/>
     <NamedIndividual IRI="Bill"/>
     <NamedIndividual IRI="Mary"/>
   </NegativeObjectPropertyAssertion>
   <NegativeDataPropertyAssertion>
     <DataProperty IRI="hasAge"/>
     <NamedIndividual IRI="Jack"/>
     <Literal datatypeIRI="http://www.w3.org/2001/XMLSchema#integer">53</Literal>
   </NegativeDataPropertyAssertion>
   <NegativeObjectPropertyAssertion>
     <ObjectProperty IRI="hasDaughter"/>
     <NamedIndividual IRI="Bill"/>
     <NamedIndividual IRI="Susan"/>
   </NegativeObjectPropertyAssertion>
 
 </Ontology>

14 付録: 更新履歴(参考情報)

14.1 勧告案以後の更新

この項は、2009年9月22日の勧告案以後のこのドキュメントへの更新をまとめています。

14.2 最終呼びかけ以後の更新

この項では、2009年6月11日の最終呼びかけ草案以後のこのドキュメントへの更新をまとめています。

15 謝辞

OWL 2の開発の出発点は、OWL 1.1メンバーの提案で、それ自身は、ユーザと開発者のフィードバックの結果であり、特に、OWL経験と説明(OWLED)ワークショップ・シリーズの間に集まった情報です。ワーキンググループは、WebOntワーキングループ先送りされていた課題についても検討しました。

このドキュメントは、OWLワーキンググループによって製作され(下記を参照)、コンテンツはワーキンググループ全体の広範囲にわたる議論を反映しています。編集者は、徹底的なレビューと有益なコメントに関し、Jie Bao (RPI)、Michel Dumontier (Carleton University)、 Christine Goldbreich (Université de Versailles St-Quentin and LIRMM)、Henson Graves (Lockheed Martin)、Ivan Herman (W3C/ERCIM)、Rinke Hoekstra (University of Amsterdam)、Doug Lenat (Cycorp)、Deborah L. McGuinness (RPI)、Alan Rector (University of Manchester)、Alan Ruttenberg (Science Commons)、Uli Sattler (University of Manchester)、Michael Schneider (FZI)とMike Smith (Clark & Parsia)に特に謝意を表します。

このドキュメントの公表時点のOWLワーキンググループの会合の正規出席者は次の通りでした。Jie Bao (RPI)、Diego Calvanese (Free University of Bozen-Bolzano)、Bernardo Cuenca Grau (Oxford University Computing Laboratory)、Martin Dzbor (Open University)、Achille Fokoue (IBM Corporation)、Christine Golbreich (Université de Versailles St-Quentin and LIRMM)、Sandro Hawke (W3C/MIT)、Ivan Herman (W3C/ERCIM)、Rinke Hoekstra (University of Amsterdam)、Ian Horrocks (Oxford University Computing Laboratory)、Elisa Kendall (Sandpiper Software)、Markus Krötzsch (FZI)、Carsten Lutz (Universität Bremen)、Deborah L. McGuinness (RPI)、Boris Motik (Oxford University Computing Laboratory)、Jeff Pan (University of Aberdeen)、Bijan Parsia (University of Manchester)、Peter F. Patel-Schneider (Bell Labs Research, Alcatel-Lucent)、Sebastian Rudolph (FZI)、Alan Ruttenberg (Science Commons)、Uli Sattler (University of Manchester)、Michael Schneider (FZI)、Mike Smith (Clark & Parsia)、Evan Wallace (NIST)、Zhe Wu (Oracle Corporation)とAntoine Zimmermann (DERI Galway)。ワーキンググループの元のメンバーであるJeremy Carroll、Jim Hendler、Vipul Kashyapにも感謝申し上げます。

16 参考文献

[Description Logics]
The Description Logic Handbook: Theory, Implementation, and Applications, second edition. Franz Baader, Diego Calvanese, Deborah L. McGuinness, Daniele Nardi, and Peter F. Patel-Schneider, eds. Cambridge University Press, 2007. Also see the Description Logics Home Page.
[DLP]
Description Logic Programs: Combining Logic Programs with Description Logic. Benjamin N. Grosof, Ian Horrocks, Raphael Volz, and Stefan Decker. in Proc. of the 12th Int. World Wide Web Conference (WWW 2003), Budapest, Hungary, 2003. pp.: 48–57
[DL-Lite]
Tractable Reasoning and Efficient Query Answering in Description Logics: The DL-Lite Family. Diego Calvanese, Giuseppe de Giacomo, Domenico Lembo, Maurizio Lenzerini, Riccardo Rosati. J. of Automated Reasoning 39(3):385–429, 2007
[EL++]
Pushing the EL Envelope. Franz Baader, Sebastian Brandt, and Carsten Lutz. In Proc. of the 19th Joint Int. Conf. on Artificial Intelligence (IJCAI 2005), 2005
[FOST]
Foundations of Semantic Web Technologies. Pascal Hitzler, Markus Krötzsch, and Sebastian Rudolph. Chapman & Hall/CRC, 2009, ISBN: 9781420090505.
[OWL 2 Conformance]
OWL 2 Web Ontology Language: Conformance Michael Smith, Ian Horrocks, Markus Krötzsch, Birte Glimm, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-conformance-20091027/. Latest version available at http://www.w3.org/TR/owl2-conformance/.
[OWL 2 Manchester Syntax]
OWL 2 Web Ontology Language: Manchester Syntax Matthew Horridge, Peter F. Patel-Schneider. W3C Working Group Note, 27 October 2009, http://www.w3.org/TR/2009/NOTE-owl2-manchester-syntax-20091027/. Latest version available at http://www.w3.org/TR/owl2-manchester-syntax/.
[OWL 2 New Features and Rationale]
OWL 2 Web Ontology Language: New Features and Rationale Christine Golbreich, Evan K. Wallace, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-new-features-20091027/. Latest version available at http://www.w3.org/TR/owl2-new-features/.
[OWL 2 Profiles]
OWL 2 Web Ontology Language: Profiles Boris Motik, Bernardo Cuenca Grau, Ian Horrocks, Zhe Wu, Achille Fokoue, Carsten Lutz, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-profiles-20091027/. Latest version available at http://www.w3.org/TR/owl2-profiles/.
[OWL 2 Quick Reference Guide]
OWL 2 Web Ontology Language: Quick Reference Guide Jie Bao, Elisa F. Kendall, Deborah L. McGuinness, Peter F. Patel-Schneider, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-quick-reference-20091027/. Latest version available at http://www.w3.org/TR/owl2-quick-reference/.
[OWL 2 RDF-Based Semantics]
OWL 2 Web Ontology Language: RDF-Based Semantics Michael Schneider, editor. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-rdf-based-semantics-20091027/. Latest version available at http://www.w3.org/TR/owl2-rdf-based-semantics/.
[OWL 2 RDF Mapping]
OWL 2 Web Ontology Language: Mapping to RDF Graphs Peter F. Patel-Schneider, Boris Motik, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-mapping-to-rdf-20091027/. Latest version available at http://www.w3.org/TR/owl2-mapping-to-rdf/.
[OWL 2 Direct Semantics]
OWL 2 Web Ontology Language: Direct Semantics Boris Motik, Peter F. Patel-Schneider, Bernardo Cuenca Grau, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-direct-semantics-20091027/. Latest version available at http://www.w3.org/TR/owl2-direct-semantics/.
[OWL 2 Specification]
OWL 2 Web Ontology Language: Structural Specification and Functional-Style Syntax Boris Motik, Peter F. Patel-Schneider, Bijan Parsia, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-syntax-20091027/. Latest version available at http://www.w3.org/TR/owl2-syntax/.
[OWL 2 XML Serialization]
OWL 2 Web Ontology Language: XML Serialization Boris Motik, Bijan Parsia, Peter F. Patel-Schneider, eds. W3C Recommendation, 27 October 2009, http://www.w3.org/TR/2009/REC-owl2-xml-serialization-20091027/. Latest version available at http://www.w3.org/TR/owl2-xml-serialization/.
[pD*]
Completeness, decidability and complexity of entailment for RDF Schema and a semantic extension involving the OWL vocabulary. Herman J. ter Horst. J. of Web Semantics 3(2–3):79–115, 2005
[RDF Concepts]
Resource Description Framework (RDF): Concepts and Abstract Syntax. Graham Klyne and Jeremy J. Carroll, eds. W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/. Latest version available as http://www.w3.org/TR/rdf-concepts/.
[RDF Semantics]
RDF Semantics. Patrick Hayes, ed., W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/. Latest version available as http://www.w3.org/TR/rdf-mt/.
[RDF Turtle Syntax]
Turtle - Terse RDF Triple Language. David Beckett and Tim Berners-Lee, 14 January 2008
[RDF Syntax]
RDF/XML Syntax Specification (Revised). Dave Beckett, ed. W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/. Latest version available as http://www.w3.org/TR/rdf-syntax-grammar/.
[RFC 3987]
RFC 3987: Internationalized Resource Identifiers (IRIs). M. Duerst and M. Suignard. IETF, January 2005, http://www.ietf.org/rfc/rfc3987.txt
[SPARQL]
SPARQL Query Language for RDF. Eric Prud'hommeaux and Andy Seaborne, eds. W3C Recommendation, 15 January 2008, http://www.w3.org/TR/2008/REC-rdf-sparql-query-20080115/. Latest version available as http://www.w3.org/TR/rdf-sparql-query/.
[XML Schema Datatypes]
XML Schema Part 2: Datatypes Second Edition. Paul V. Biron, and Ashok Malhotra, eds. W3C Recommendation 28 October 2004, http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/. Latest version available as http://www.w3.org/TR/xmlschema-2/. This reference is to be considered a reference to XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes upon its expected publication as a W3C Recommendation (see Section 2.3 in OWL 2 Conformance). The (non-normative) version of the XSD 1.1 document available at publication time is the 30 April 2009 Candidate Recommendation.