本文档《 OWL Web 本体语言参考》是 W3C 发布的 OWL Web Ontology Language Reference （ 2004-02-10 ）的中文译本。文中若存在译法不当和错误之处，欢迎批评指正，请发邮件至： zengxh@szu.edu.cn ，谢谢！

翻译说明：

·本文档的 英文版 是唯一正式版本。此处的中文译本仅供学习与交流。

·中文译本的内容是非正式的，仅代表译者的个人观点。

·中文译本的内容会根据反馈意见随时进行修订。

·中文译本同时通过 W3C Translations 网站发布。

·转载本文，请注明译者和原链接。

曾新红（ Xinhong Zeng ），深圳大学图书馆 NKOS 研究室

徐 乐（ Le Xu ），深圳大学计算机与软件学院

资助声明：

本次翻译工作得到广东省哲学社会科学“十一五”规划项目（批准号： GD10CTS02 ）和国家社科基金项目“中文知识组织系统的形式化语义描述标准体系研究”（批准号： 12BTQ045 ）的资助。

发布时间： 2013 年 1 月 18 日

请参考本文的 勘误表 , 那里会有一些规范性的修正。

也可以查看相关 翻译 。 。 . 。

Web 本体语言 OWL 是一个语义标记语言，用于在万维网上发布和共享本体。 OWL 以 RDF （资源描述框架）词汇扩展的形式开发，它源于 DAML+OIL Web 本体语言。本文档包含了对整套 OWL 语言结构的结构化的非形式化描述，目的是为想要构建 OWL 本体的 OWL 用户提供一个参考。

本文档的状态

本文档已经由 W3C 成员及其他兴趣组织审阅 , 并已被 W3C 主管（ W3C Director ）批准为 W3C 推荐标准 （ W3C Recommendation ）。 W3C 在制定推荐标准过程中担任的角色是使规范受到关注，并促使其被广泛应用。这将增强 Web 的功能性与互操作性。

本文档是 W3C 关于 Web 本体语言 OWL 的推荐标准的 六个部分 ( http://www.w3.org/TR/2004/REC-owl-features-20040210/#s1.1 ) 之一。它 由 Web 本体工作小组 开发， ( http://www.w3.org/2001/sw/WebOnt/ ) ( http://www.w3.org/2001/sw/WebOnt/charter ) 作为 W3C 语义 Web 行动 ( http://www.w3.org/2001/sw/ ) （ 行动声明 ， 小组章程 ( http://www.w3.org/2001/sw/Activity ) ） ) ）） ） 的一部分于 2004 年 2 月 10 日 发布。

本文档的早期版本中所描述的关于 OWL 的设计已被广泛 校 阅，并已满足工作小组的 技术需求 ( http://www.w3.org/TR/webont-req/ ) 。工作小组充分考虑 了 所有收到的意见 ( http://lists.w3.org/Archives/Public/public-webont-comments/ ) ，并做了必要的修改。本文档自从 建议 推荐标准版本 ( http://www.w3.org/TR/2003/PR-owl-guide-20031215/ ) 以来的所有修改都 详细列 在文后的 变 动 日志 ( http://www.w3.org/TR/2004/REC-owl-guide-20040210/#changes-since-PR ) 中。

欢迎通过 public-webont-comments@w3.org ( mailto:public-webont-comments@w3.org ) （ 历史存档 ( http://lists.w3.org/Archives/Public/public-webont-comments/ ) ）提出您的意见，也可以通过 www-rdf-logic@w3.org ( mailto:www-rdf-logic@w3.org ) （ 历史存档 ( http://lists.w3.org/Archives/Public/www-rdf-logic/ ) ）参与相关技术的 一般 讨论。

可以访问到有关 实现 ( http://www.w3.org/2001/sw/WebOnt/impls ) 的一个列表。

W3C 维护着一个 与这些工作相关的专利声明 的目录。

这节描述了本文档在发布时的状态。其他文档可能替代 该 文档。当前 W3C 的最新出版物的目录和这个技术报告的最新版本在 W3C 技术报告索引 (http://www.w3.org/TR/) http://www.w3.org/TR/ 中可以 找到。

本文档有一部分源自 DAML+OIL (2001.3) Reference Description [ DAML+OIL ] （作为 DAML+OIL W3C Note 的一部分提交）。我们对本文档和之前文档的赞助者表示诚挚的感谢。

Jeremy Carroll, Jim Hendler, Brian McBride 和 Peter Patel-Schneider 对本文档进行了实质性的审查，并为本文档贡献了文字。 Jeff Heflin 撰写了关于过时（ deprecation ）的章节 。 Jerome Euzenat 为一个枚举数据类型提供了示例。

这个文档是 Web 本体工作组 作为一个整体进行广泛讨论的结果。该工作组的参与者包括： Yasser alSafadi, Jean-François Baget, James Barnette, Sean Bechhofer, Jonathan Borden, Frederik Brysse, Stephen Buswell, Jeremy Carroll, Dan Connolly, Peter Crowther, Jonathan Dale, Jos De Roo, David De Roure, Mike Dean, Larry Eshelman, Jérôme Euzenat, Tim Finin, Nicholas Gibbins, Sandro Hawke, Patrick Hayes, Jeff Heflin, Ziv Hellman, James Hendler, Bernard Horan, Masahiro Hori, Ian Horrocks, Jane Hunter, Francesco Iannuzzelli, Rüdiger Klein, Natasha Kravtsova, Ora Lassila, Massimo Marchiori, Deborah McGuinness, Enrico Motta, Leo Obrst, Mehrdad Omidvari, Martin Pike, Marwan Sabbouh, Guus Schreiber, Noboru Shimizu, Michael Sintek, Michael K. Smith, John Stanton, Lynn Andrea Stein, Herman ter Horst, David Trastour, Frank van Harmelen, Bernard Vatant, Raphael Volz, Evan Wallace, Christopher Welty, Charles White ，以及 John Yanosy 。

1.1 本文档的目的

本文档给出了 OWL 的所有建模原语（ modelling primitives ）的系统、紧凑和资料性的描述 ，使用了 OWL 的 RDF/XML 交换语法。我们希望本文档能够为 OWL 语言的用户提供参考指南。

本文档是 OWL 即 Web 本体语言描述的一部分，由 W3C Web 本体工作组制定。“ OWL 概述”的 文档 路线图 部分描述了文档的每一个不同部分以及它们是如何组合在一起的。对 OWL 不熟悉的读者不妨先查阅“ OWL 概述”文档 [ OWL Overview ] ，然后再查阅“ OWL 指南” [ OWL Guide ] 上关于 OWL 语言使用的更具叙述性的说明和例子。

本文档假定读者熟悉 RDF 的基本概念 [ RDF Concepts ] ，具有 RDF/XML 语法 [ RDF/XML Syntax ] 和 RDF Schema[ RDF Vocabulary ] 的应用知识 。

可以在“ OWL 语义和抽象语法”文档 [ OWL S&AS ] 中找到关于 OWL 语言结构（ constructs ）精确语法的规范 参考。 那份文档还包含一个语言结构含义的确切定义，这个定义以模型 - 理论（ model-theoretic ）语义的形式给出。 诸如 OWL 本体的一致性 等概念在该文档中也有讨论。

在“ OWL 需求”文档 [ OWL Requirements ] 中描述了 OWL 语言的用例和需求。在测试文档 [ OWL Test Cases ] 中对 OWL 工具的测试用例（ 例如 蕴含测试 、一致性测试）做了详细说明。

1.2 OWL Full / DL / Lite

正如在 OWL 概述文档 [ OWL Overview ] 以及随后的 OWL 指南 [ OWL Guide ] 中所讨论的，我们相信 OWL 语言提供的两种特定的子集对于实现者和语言使用者是有用的。 OWL Lite 专门为易于实现的开发而设计，它提供了一个功能子集帮助使用者开始使用 OWL 。 设计 OWL DL （ DL 即“ Description Logic ”） 是为了支持现有的描述逻辑业务， OWL DL 提供了一个对推理系统有着理想计算性能的语言子集 。完整的 OWL 语言（称为 OWL Full 以区别于其子集）放宽了一些对 OWL DL 的约束，以使得许多数据库和知识表达系统可以使用那些对它们可能有用的特性，但是这违反了描述逻辑推理器的约束条件。

注意： 除非专门以 OWL DL 或 Lite 构造，否则 RDF 文档 通常都采用 OWL Full 。

OWL Full 和 OWL DL 支持相同的 OWL 语言结构集合。 它们的差别在于对那些特性和 RDF 特性的使用限制。 OWL Full 允许 OWL 和 RDF Schema 自由混合，它和 RDF Schema 一样，不强制要求 类、属性、个体和数据值严格 分离。 OWL DL 限制了与 RDF 的混合，要求类、属性、个体和数据值不相交。 OWL DL 子语言之所以存在，是因为工具制造者已经开发出了强大的推理系统，支持 OWL DL 所需限制条件的本体约束。 OWL Full 和 OWL DL 之间差异的形式定义，读者可以参考 语义和抽象语法文档 [ OWL S&AS ] 。 Sec. 8.2 "OWL DL" 对 OWL Full 和 OWL DL 之间的差异做了总结。

OWL Lite 是 OWL DL 的子语言，仅支持 OWL 语言结构的一个子集。 OWL Lite 特别针对这样一类工具制造者，他们想要支持 OWL ，但想从一个相对简单的语言特性的基本集合开始。 OWL Lite 和 OWL DL 遵守相同的语义限制，允许推理引擎保证某些所需的性能。 Sec. 8.3 给出了 OWL Lite 中被允许的语言结构的总结。读者可以参考语义和抽象语法文档 [ OWL S&AS ] 获得 OWL Lite 支持的 OWL 语言结构子集的更形式化的描述。

注意：升级到 OWL 的 RDF 用户应注意 OWL Lite 不是 RDF Schema 的一个简单扩展。 OWL Lite 是 OWL DL 的精简版本，它对 RDF 词汇的使用施加了限制 （ 例如 ，类和属性不能相交等）。 OWL Full 是为与 RDF 的最大兼容性而设计的，因此， RDF 用户可以很自然地从 OWL Full 着手。当 RDF 用户在 OWL DL 和 OWL Lite 二者中抉择时，应该考虑 OWL DL/Lite 的优势（ 例如， 对推理的支持）是否胜过对 OWL 和 RDF 结构使用的 DL/Lite 限制。

注意：本文档中 OWL Lite 被定义为对 OWL DL 的许多额外限制。这意味着，除非明确说明，否则 OWL DL 结构也是 OWL Lite 的一部分。 Sec. 8.3 总结了这些附加的 OWL Lite 限制。

1.3 OWL 语法

OWL 本体是一个 RDF 图 [ RDF 概念 ] ，而 RDF 图又是一个 RDF 三元组集合。正如任何 RDF 图， OWL 本体图 可以写成多种不同的 句法格式（如同“ RDF/XML 语法规范”（修订版） [ RDF/XML 语法 ] 中的描述）。当前文档使用了一些特定的 RDF/XML 句法格式表示三元组（指南文档中也是如此）。然而 OWL 本体的意义完全由 RDF 图确定。因此，我们可以使用其他 RDF/XML 句法格式，只要 所代表的 RDF 三元组相同。那么，其他句法格式就可以携带和本文档中所使用的句法格式相同的含义。

作为一个替代句法格式引至相同 RDF 三元组的简单例子 ，我们考虑以下的 RDF/XML 语法：

<owl:Class rdf:ID="Continent"/> 

下面的 RDF/XML 语法：

<rdf:Description rdf:about="#Continent">

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>

</rdf:Description> 

为相同的 RDF 三元组编码，因此传达相同的含义。

1.4 OWL 和 RDF 语义

OWL 是 RDF 的一个词汇扩展 [ RDF 语义 ] ，因此任何 RDF 图 都形成一个 OWL Full 本体。 此外， OWL 所赋予 RDF 图的含义包括了 RDF 所赋予该图的含义。 因此， OWL Full 本体可以包含 RDF 的任意内容，这和 RDF 的处理方式是一致的。 OWL 赋予某些 RDF 三元组一个附加含义。“ OWL 语义和抽象语法”文档 [ OWL S&AS ] 明确列举了哪些三元组被赋予了特定的含义以及这些含义是什么。

注意：正如之前讨论过的， OWL DL 和 OWL Lite 扩展了 RDF 词汇，但也对词汇的使用加以限制。因此，除非专门以 OWL DL 或 Lite 构造，否则 RDF 文档通常都采用 OWL Full 。

1.5 例子的说明

为了便于阅读，假设本文档中的例子对 XML 实体 &rdf; 、 &rdfs; 、 &owl; 以及 &xsd; （ XML Schema 数据类型）的定义和 附录 B 中的相同。 关于相应的命名空间 rdf: 、 rdfs: 、 owl: 和 xsd: 同样的 假设也成立。

本文档中的例子 是为了说明 OWL 语言结构的使用 。它们不形成一个一致的本体。 读者可以参考“指南”文档获取一个扩展的例子 [ OWL Guide ] 。

1.6 数据聚合与隐私

OWL 在表达出现在多个文档中个体的本体信息的能力方面，以一种有原则的方式支持连接来自异源的数据。下层语义为这些数据提供推理支持，这可能产生意外的结果。特别地，采用 owl:sameAs 表达等价的能力，可以被用来表达表面上不同的个体实际上是相同的。同样地， owl:InverseFunctionalProperty 可被用来将个体连接在一起。例如，如果一个属性，比如“ SocialSecurityNumber ”，是一个 owl:InverseFunctionalProperty ，那么两个独立的个体如果具有相同的 SocialSecurityNumber 属性值，则可被推理出是相同的个体。当个体以这种方式被确定为相同时，来自异源的关于这些个体的信息可以被合并。这种 聚合 （ aggretion ）可用来得出未 直接 在单源表达的事实。

语义网的连接来自多源信息的能力是 一个理想的、强大的特性，它可 以 用在许多 应用 ( http://www.w3.org/TR/2004/REC-owl-guide-20040210/#IntegratingApplications ) 中。但是合并来自多源数据的能力，加上 OWL 的推理能力，确实存在被 滥 用的可能。 在出台了数据保护法的国家，特别是欧盟，如果没有一个正当的法律上的原因，创建或者处理这样的连接信息甚至可能是非法的。因此，在使用 OWL 处理可能会连接到其他数据源或者本体的任何个人数据时需要非常谨慎。 具体的安全方案超出了工作组的工作范畴。 目前正在进行的各种不同的安全和偏好方案有望解决这些问题 ，比如 SAML 和 P3P 。

1.7 本文档的附录

本文档有一组包含附加信息的附录。

本文档中附带在语言结构定义上的链接 提供了对“ OWL 语义和抽象语法 ”的访问 [ OWL S&AS ] 。对于每个语言结构对应于指南和 S&AS 文档的相应部分， 附录 A 包含了一组系统的链接。

附录 B 包含一个适用于 OWL 语言结构的 RDF schema 。 这个 schema 提供了关于 OWL 词汇的信息，这可能对本体建造者和工具开发者是一个有用的参考点。 该 schema 提供的关于 OWL 类和属性的限制条件是资料性的，并不完整。 此外，该 schema 不区分 OWL Full 、 OWL DL 和 OWL Lite 。按照惯例，类的第一个字符大写，属性的第一个字符小写。因此， owl:Ontology 表示类， owl:imports 表示属性。

注意： RDF Schema 文件并不被希望明确导入到本体（ 即， owl:imports ） 。 schema 具有资料性状态 ，其目的是以 RDF/XML 语法的方式提供类和属性的使用 。导入此 schema 的人应该期望产生的本体是一个 OWL Full 本体。

附录 C 依据内置的 OWL 类和属性给出了 OWL 词汇表的表格概述 （同时给出了属性的值域和定义域）。

对于熟悉 DAML+OIL 的读者， 附录 D 列举了许多 DAML+OIL 和 OWL 之间的变化。

最后， 附录 E 提供了一套实用指南来具体说明 RDF 格式的 OWL DL 本体 。

2. OWL 文档

OWL 格式的信息被收集进本体，这样可以以文档的形式储存到万维网上。 OWL 的一个方面，本体的导入，依赖于 OWL 本体能够存储在网上的能力。

2.1 内容

一个 OWL 文档由可选的 本体头 （通常至多一个）加上任意数量的 类公理 、 属性公理 和 关于个体的事实 组成。请注意，“公理（ axiom ）”是在 S&AS 文档里使用的正式术语。而在指南和概述这两个文档里，这些公理略显非正式地称为“定义（ definitions ）”。

注意： OWL 不会强制限定 OWL 组件的顺序。人们在写本体时可能用到某种顺序，比如把本体头部放在开头，但不同的顺序不会对本体的意义造成影响。工具不应该假设任何的顺序。

和大多数 RDF 文档一样， OWL 代码应该是一个 rdf:RDF 元素的子元素。 这个封闭的元素通常拥有 XML 命名空间和基（ base ）声明。 并且，一个 OWL 本体文档通常以若干实体声明开始。有关这方面信息的典型例子，请参阅指南文档里讨论的酒和食物的例子 [ OWL 指南 ] 。

2.2 OWL 内置词汇

按照惯例与命名空间名称 owl 相关联 。 除了内置词汇，我们不建议本体使用来自此命名空间的名称。 如果来自此命名空间的其他名称被使用，那么 OWL 工具制造者应该随时标记警告，但是应该以另外的方式继续正常使用。

2.3 MIME 类型

Web 本体工作组并没有要求 OWL 文档有一个单独的 MIME 类型。我们建议使用 RDF 核心工作组要求的 MIME 类型，即 application/rdf+xml [ RDF 概念 ] ，或者 XML MIME 类型 application/xml 代替 。

至于文件扩展，我们建议使用 .rdf 或者 .owl 。

类提供了一种根据相似的特征将资源分类的抽象机制。如同 RDF 类，每一个 OWL 类都与一组被称为 类外延 （ class extension ）的个体相关联。类外延中的个体被称作类的 实例 （ instance ）。一个类有与类外延有关但并不等同的内涵（底层概念）。因此，有相同类外延的两个类仍然可以是不同的类。

在本文档里出现的用词如“一类个体 … ”我们应该解读为“一个有着一个包含个体的类外延的类 … ” 。

注意： 在 OWL Lite 和 OWL DL 里，一个个体不能同时是一个类：类和个体的定义域不相交（属性和数据值也一样） 。而 OWL Full 则对 RDF Schema 没有限制：一个类同时可以充当另外一个（元）类的实例。

OWL 类通过“类运算式”（ class descriptions ）来描述，这一描述可以结合到“类公理”。 我们首先描述类运算式，随后描述类公理。

3.1 类运算式

第一种类型在描述类时使用了 类名 （句法上表示为一个 URI 引用），从这个意义上来讲它是特殊的。其他五种类运算式类型通过 限制类外延 来描述匿名类。

2-6 种类运算式类型分别描述了一种类： 完全包含列举个体的类 （第 2 种类型），满足一个特定属性约束的所有个体的类（第 3 种类型），或者是满足类运算式的布尔组合的类（第 4 、第 5 和第 6 种类型）。交 集 、并集和补集可分别被看作逻辑运算符 AND 、 OR 和 NOT 。后面四种类运算式类型允许类运算式的嵌套，因此，理论上可以形成任意复杂的类运算式。在实践中，通常会限制嵌套的级别。

类型 1 类运算式在句法上被描述成 owl:Class 的一个具名实例， rdfs:Class 的一个子类：

<owl:Class rdf:ID="Human"/>

这声明了一个三元组 “ ex:Human rdf:type owl:Class . ” ， ex: 代表相关本体的命名空间。

注意：在 OWL Lite 和 OWL DL 里，所有的类运算式都要用到 owl:Class （或者 owl:Restriction ， 参见下文 ）。

注意： owl:Class 被定义为 rdfs:Class 的一个子类。拥有一个单独的 OWL 类结构这一基本原理存在于对 OWL DL 以及 OWL Lite 的限制条件中，这意味着不是所有的 RDFS 类都是合法的 OWL DL 类。在 OWL Full 中不存在这些限制条件，因此 owl:Class 和 rdfs:Class 是等价的。

另外五种类运算式形式由 RDF 三元组集合组成，三元组中的空节点代表被描述的类。 此空节点有一个 rdf:type 属性，其属性值是 owl:Class 。

注意：如果有人为枚举、交集、并集或者补集类型的类运算式提供了一个 RDF 标识，那么我们就不认为它是类运算式，而是一种支持完整类的特殊类公理。详情参见 Sec. 3.2.3 。

注意： 为了提高文档的可读性，在文档中使用简约表达“类运算式”来表示“被类运算式所描述的类”。 严格来讲，在 2-6 种类运算式类型的情况下是有区别的：类由相应的空节点表示；类运算式由有着空节点作为主体的三元组表示。

有两个 OWL 类标识是预定义的，即类 owl:Thing 和 owl:Nothing 。 owl:Thing 的 类外延是所有个体的集合。 owl:Nothing 的类外延是空集合。因此，每一个 OWL 类都是 owl:Thing 的子类，而 owl:Nothing 则是每一个类的子类（子类关系的含义，请参阅有关 rdfs:subClassOf 的章节）。

3.1.1 枚举

“枚举”类运算式的定义中有 owl:oneOf 属性。这个内置的 OWL 属性值必须是个体的列表，而这些个体是该类的实例。这就使得一个类能够通过详尽地列举它的实例来描述。 有 owl:oneof 属性的 类运算式的类外延正好包含所列举的个体，不多不少。 个体列表通常借助于 RDF 结构 rdf:parseType="Collection" 来表达，这一结构为书写列表元素集合提供了便利的简约表达。例如，下面的 RDF/XML 语法定义了一个包含所有大陆的类：

<owl:Class>

  <owl:oneOf rdf:parseType="Collection">

    <owl:Thing rdf:about="#Eurasia"/>

    <owl:Thing rdf:about="#Africa"/>

    <owl:Thing rdf:about="#NorthAmerica"/>

    <owl:Thing rdf:about="#SouthAmerica"/>

    <owl:Thing rdf:about="#Australia"/>

    <owl:Thing rdf:about="#Antarctica"/>

  </owl:oneOf>

</owl:Class>

RDF/XML 语法 <owl:Thing rdf:about="..."/> 指的是一些个体（记住：按照定义所有的个体都是 owl:Thing 的实例 ）。

在数据类型章节，我们将会看到 owl:oneof 结构的另外一种用法，即定义一个 数据值的枚举 。

注意：枚举不是 OWL Lite 的一部分。

3.1.2 属性限制

属性限制是一种特殊的类运算式。它描述了一个匿名类，即满足这个限制的所有个体的类。 OWL 对两种属性限制作了区分 ：值约束和基数约束。

值约束 对属性的值域施加了限制， 当应用到这一特殊的类运算式的时候 。例如，我们可能想要参考那些 adjacentTo 属性值是一些 Region 的 个体，然后在类公理中使用这一限制，甚至可能是在一个 Region 类公理本身之内使用。注意到这不同于 rdfs:range ，后者适用于使用此属性的所有情况。

基数限制 对一个属性能够取属性值的数量提出了限制， 在这个特殊类运算式的上下文中 。例如，我们可能会说一个足球队的属性 hasPlayer 有 11 个 值。对于篮球队来说，相同的属性只有 5 个值。

OWL 还支持有限的结构集用以定义全局属性基数，即 owl:FunctionalProperty 和 owl:InverseFunctionalProperty （参见有关属性的章节）。

属性限制的一般形式如下：

<owl:Restriction>

  <owl:onProperty rdf:resource="(some property)" />

  (precisely one value or cardinality constraint, see below)

</owl:Restriction>

类 owl:Restriction 定义为 owl:Class 的子类 。一个限制类应该有且只有一个三元组链接限制到特定的属性上，使用属性 owl:onProperty 。 限制类也应该只有一个三元组表示对所考虑属性的值约束 或（ c.q. ） 基数约束 ， 例如 ，此属性的基数正好是 1 。

属性限制既可以应用于 数据类型属性 （值是一个数据文本的属性），也可以应用于 对象属性 （值是一个个体的属性）。关于这一区别的更多信息，请参阅有关 属性 章节。

3.1.2 .1 值约束

3.1.2 .1.1 owl:allValuesFrom

值约束 owl:allValuesFrom 是内置的 OWL 属性，把一个限制类链接到 类运算式 或者 数据值域 。一个含有 owl:allValuesFrom 约束的限制用来描述一个类，其所有个体所考虑的所有属性值，要么是类运算式的类外延的成员，要么是指定数据值域内的数据值。换句话说，它定义个体 x 的一个类，满足如果（ x,y ）是 P （相关属性）的一个实例，那么 y 应该是类运算式的一个实例或者数据值域中的一个值。

一个简单的例子：

<owl:Restriction>

  <owl:onProperty rdf:resource="#hasParent" />

  <owl:allValuesFrom rdf:resource="#Human"  />

</owl:Restriction>

这个例子描述了一个匿名 OWL 类，其所有个体的 hasParent 属性只有类 Human 的值。注意这一类运算式并非声明这个属性总是有这个类的值；只是对于属于这个匿名限制类的类外延的个体才确实如此。

注意： 在 OWL Lite 中，允许作为 owl:allValuesFrom 的客体的唯一 类运算式类型是一个类名。

owl:allValuesFrom 约束类似于谓词逻辑的全称（所有）量词——对于被描述的类的每个实例，每一个属性 P 的值都必须满足约束 。还要注意 owl:allValuesFrom 与全称量词的对应， 意味着 针对属性 P 的 owl:allValuesFrom 约束 显而易见（ trivially ） 满足根本没有属性 P 的值的个体。 要知道为什么是这样，观察 owl:allValuesFrom 约束要求所有 P 的值应该是类型 T ，如果不存在这样的值，那么这一约束 显然正确 (trivially true) 。

3.1.2 .1.2 owl:someValuesFrom

值约束 owl:someValuesFrom 是 内置 OWL 属性，它把一个限制类链接到 类运算式 或者 数据 值 域 。包含 owl:someValuesFrom 约束 的限制描述了一个类，对于其所有个体，至少一个所考虑属性的值是该类运算式的一个实例或者是数据值域内的一个数据值。换句话说，它定义了个体 x 的一个类，满足至少有一个 y （类运算式的一个实例或者数据值域内的值）构成的实例（ x,y ）是 P 的一个实例。这并不排除当 y' 不属于类运算式或者数据值域，（ x,y' ）也可以是 P 的实例这一情况。

下面的例子定义了一个类，其个体有至少一个父母是医生：

<owl:Restriction>

  <owl:onProperty rdf:resource="#hasParent" />

  <owl:someValuesFrom rdf:resource="#Physician" />

</owl:Restriction>

owl:someValuesFrom 约束 类似于谓词逻辑的存在量词——对于所定义的类的每个实例，至少存在一个 P 的值满足约束。

注意：在 OWL Lite 中，允许作为 owl:someValuesFrom 的客体的唯一 类运算式类型是一个类名。

3.1.2 .1.3 owl:hasValue

owl:hasValue 值约束是内置 OWL 属性，它把一个限制类链接到值 V ， V 可以是 个体 或者 数据值 。一个包含 owl:hasValue 约束的限制描述了一个类，对于其所有个体的所考虑属性，至少有一个值 语义 上等价于 V （也可能有其他值）。

注意：对于数据类型，“语义上等价”的意思是字面值的词汇表达映射到相同的值。对于个体，“语义上等价”的意思是两者要么有相同的 URI 引用要么定义成相同的个体（参见 owl:sameAs ）。

注意： OWL Lite 不包含值约束 owl:hasValue 。

下面的例子描述了有个体的父母名为 Clinton 的类：

<owl:Restriction>

  <owl:onProperty rdf:resource="#hasParent" />

  <owl:hasValue rdf:resource="#Clinton" />

</owl:Restriction>

3.1.2 .2 基数约束

注意： OWL Lite 包括全部三种类型的基数约束的使用，但仅仅是当值是 "0" 或 "1" 时。

3.1.2 .2.1 owl:maxCardinality

基数约束 owl:maxCardinality 是内置的 OWL 属性，它把一个限制类链接到一个属于 XML Schema 数据类型 nonNegativeInteger 值空间的 数据值。包含 owl:maxCardinality 约束的限制描述了一个类，其所有个体对于所考虑的属性至多有 N 个语义上不同的值（个体或数据值），在这里 N 是基数约束的值。 在句法上，基数约束被表示成有相应 rdf:datatype 属性的 RDF 属性元素。

下面的例子描述了一个至多有两个父母的个体的类：

<owl:Restriction>

  <owl:onProperty rdf:resource="#hasParent" />

  <owl:maxCardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:maxCardinality>

</owl:Restriction>

我们将在 Sec. 6 中更详细地讨论 RDF 数据类型。

3.1.2 .2.2 owl:minCardinality

基数约束 owl:minCardinality 是内置的 OWL 属性，它把一个限制类链接到一个属于 XML Schema 数据类型 nonNegativeInteger 值空间的 数据值。 包含 owl:minCardinality 约束的限制描述了一个类，其所有个体对于所考虑的属性至少有 N 个语义上不同的值（个体或数据值），在这里 N 是基数约束的值。在句法上，基数约束被表示为有相应 rdf:datatype 属性的 RDF 属性元素。

下面的例子描述了一个至少有两个父母的个体的类：

<owl:Restriction>

  <owl:onProperty rdf:resource="#hasParent" />

  <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:minCardinality>

</owl:Restriction>

需要注意一个或多个 owl:minCardinality 意味着类的所有实例必须拥有一个此属性的值。

3.1.2 .2.3 owl:cardinality

基数约束 owl:cardinality 是内置的 OWL 属性，它把一个限制类链接到一个属于 XML Schema 数据类型 nonNegativeInteger 范围的 数据值。包含 owl: cardinality 约束的限制描述了一个类，其所有个体对于所考虑的属性恰好有 N 个语义上不同的值（个体或数据值），在这里 N 是基数约束的值。在句法上，基数约束被表示成有相应 rdf:datatype 属性的 RDF 属性元素。

下面的例子描述了一个恰好有两个父母的个体的类：

<owl:Restriction>

  <owl:onProperty rdf:resource="#hasParent" />

  <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:cardinality>

</owl:Restriction>

3.1.3 交集，并集和补集

本节的三种类运算式代表了在描述逻辑中使用的更高级的类构造器。 它们可以被看作是对于类的 AND ， OR 和 NOT 运算符。 我们给出了三种运算符的标准集合运算符名称：交集、并集和补集。 这些语言结构有着共同的特征，它们包含一个（补集）或者多个（并集、交集）嵌套的类运算式。

3.1.3 .1 owl:intersectionOf

属性 owl:intersectionOf 链接一个类到 类运算式 列表。 owl:intersectionOf 声明描述了一个类，其类外延正好包含这样的个体，它们是列表中的所有类运算式的类外延都包含的成员。

例如这样一个例子：

<owl:Class>

</owl:Class>

在上面的例子中， owl:intersectionOf 的值是两个类运算式的列表，即两个枚举，它们都描述了有两个个体的类。最终交集是一个有一个个体 Tosca 的 类， Tosca 是唯一的两个枚举中都有的个体。

注意：假定这三个个体各不相同。事实上在 OWL 中并没有定义成这样。由于 OWL 并没有“唯一名称”这一假定，因此不同的 URI 引用可以指向相同的个体。在 Sec. 5 中， OWL 语言结构对个体的等价性和差异性做了约束。

注意：在这个例子中，我们利用枚举来弄清楚语言结构是什么意思。更多典型的例子，请参阅 OWL 指南 [ OWL Guide ] 。

注意： OWL Lite 使用 owl:intersectionOf 是受限的。 本文档后面对这点做了讨论，参阅 Sec. 3.2.3 。

owl:intersectionOf 可以被看做类似于逻辑与（ logical conjunction ）。

3.1.3 .2 owl:unionOf

属性 owl:unionOf 链接一个类到 类运算式 列表。 owl:unionOf 声明描述了一个匿名类，其类外延包含的个体至少存在于类运算式列表的其中一个类外延中。

例如这样一个例子：

<owl:Class>

  <owl:unionOf rdf:parseType="Collection">

    <owl:Class>

      <owl:oneOf rdf:parseType="Collection">

        <owl:Thing rdf:about="#Tosca" />

        <owl:Thing rdf:about="#Salome" />

      </owl:oneOf>

    </owl:Class>

    <owl:Class>

      <owl:oneOf rdf:parseType="Collection">

        <owl:Thing rdf:about="#Turandot" />

        <owl:Thing rdf:about="#Tosca" />




    

      </owl:oneOf>

    </owl:Class>

  </owl:unionOf>

</owl:Class>

上面的类运算式描述了一个类，它的类外延包含三个个体，即 Tosca ， Salome 和 Turandot （假设它们都不相同） 。

注意： owl:unionOf 不是 OWL Lite 的一部分。

owl:unionOf 类似于逻辑或（ logical disjunction ）。

3.1.3 .3 owl:complementOf

属性 owl:complementOf 链接一个类到 正好一个 类运算式 上。 owl:unionOf 声明描述了一个类，其类外延恰好包含那些 不 属于声明客体类运算式的类外延的个体。 owl:complementOf 类似于逻辑非： 类外延包含那些不是补集类（ complement class ）的类外延成员的个体。

下面是关于补集用法的例子，“ not meat ”表达式可以写成：

<owl:Class>

  <owl:complementOf>

    <owl:Class rdf:about="#Meat"/>

  </owl:complementOf>

</owl:Class>

上面类运算式的外延包含了不属于类 Meat 的 所有个体。

注意： owl:complementOf 不是 OWL Lite 的一部分。

3.2 类公理

类运算式 通过类公理来形成构建块以定义类。 类公理的最简单形式是类型 1 的类运算式，它仅仅使用具有一个类标识符的 owl:Class 声明了类的存在。

例如，下面的类公理声明了 URI 引用 #Human 是一个 OWL 类的名称：

<owl:Class rdf:ID="Human"/>

这是正确的 OWL ，但是它没有告诉我们太多的关于类 Human 的信息。典型地，类公理包含用来声明一个类的必要和 / 或充分特征的附加成分。 OWL 包含了三种语言结构将类运算式结合成类公理：

在句法上，这三种语言结构都是有一个类运算式作为其定义域和值域的属性。我们将会在接下来的子章节中对这些属性做更详细的讨论。

此外，在 OWL 中，允许类公理给枚举或集合运算符类型的类运算式指定一个名称。这些类公理语义上等价于有 owl:equivalentClass 声明的类公理，因此那些类公理将会在后面的小节讨论 （参见 Sec. 3.2.3 “不使用 owl:equivalentClass 的完整类的公理” ） 。

3.2.1 rdfs:subClassOf

AXIOM SCHEMA ： class description rdfs:subClassOf class description

rdfs:subClassOf 结构被定义为 RDF Schema[ RDF Vocabulary ] 的一部分。它 在 OWL 中 的含义完全一样：如果类运算式 C1 定义为类运算式 C2 的子类，那么 C1 的类外延的个体集应该是 C2 的类外延的个体集的子集。从定义上讲，一个类是其自身的子类（因为子集可以是完全集）。

一个例子：

<owl:Class rdf:ID="Opera">

  <rdfs:subClassOf rdf:resource="#MusicalWork" />

</owl:Class>

上面的类公理声明了两个通过名称（ Opera 和 MusicalWork ）描述的 OWL 类之间的子类关系。子类关系为属于一个类提供了必要条件。在这种情况下，是一个歌剧的个体也应该是一个音乐作品的个体。

注意：在 OWL Lite 中，一个 rdfs:subClassOf 声明的主体必须是一个类标识符。客体必须是一个类标识符或者属性限制。

任何类都有可能有任意数量的 subClassOf 公理。例如，我们可以给类 Opera 添加下面的公理：

<owl:Class rdf:about="#Opera">

  <rdfs:subClassOf>

    <owl:Restriction>

      <owl:onProperty rdf:resource="#hasLibrettist" />

      <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>

    </owl:Restriction>

  </rdfs:subClassOf>

</owl:Class>

这个类公理包含一个属性限制。上面给出的例子表明了 Opera 是一个匿名 OWL 类的子类（记住： owl:Restriction 是 owl:Class 的一个子类 ），它的类外延所有个体的集合对于属性 hasLibrettist 至少有一个值。因此，歌剧应该至少有一个剧本作者。

当类运算式嵌套以后，类公理会变得更加复杂。例如，带有 owl:allValuesFrom 或 owl:someValuesFrom 声明的属性限制可以指向任何类运算式。考虑下面的例子：

<owl:Class rdf:ID="TraditionalItalianOpera">

  <rdfs:subClassOf rdf:resource="#Opera"/>

  <rdfs:subClassOf>

    <owl:Restriction>

      <owl:onProperty rdf:resource="#hasOperaType"/>

      <owl:someValuesFrom>

        <owl:Class>

          <owl:oneOf rdf:parseType="Collection">




    

            <owl:Thing rdf:about="#OperaSeria"/>

            <owl:Thing rdf:about="#OperaBuffa"/>

          </owl:oneOf>

        </owl:Class>

      </owl:someValuesFrom>

    </owl:Restriction>

  </rdfs:subClassOf>

</owl:Class>

上面的例子显示了 owl:oneOf 结构的用法。这个类公理将传统的意大利歌剧 定义为歌剧类的一个子类，歌剧类有 opera seria 或者 opera buffa （如果没有附加的基数约束，实际上它可以同时有两个值）作为它的歌剧类型。

在指南文档 [ OWL Guide ] 里可以看到更多的例子。子类公理为我们提供了部分定义：它们代表建立一个个体的类成员的必要但不充分的条件。在接下来的小节我们将会看到 OWL 提供 owl:equivalentClass 结构来定义充分必要条件。作为此类公理的垫脚石，我们来考虑下面的例子：

<owl:Class rdf:ID="Operetta">

  <rdfs:subClassOf rdf:resource="#MusicalWork"/>

  <rdfs:subClassOf>

    <owl:Restriction>

      <owl:onProperty rdf:resource="#hasLibrettist" />

      <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>

    </owl:Restriction>

  </rdfs:subClassOf>

  <rdfs:subClassOf>

    <owl:Class>

      <owl:complementOf rdf:resource="#Opera"/>

    </owl:Class>

  </rdfs:subClassOf> 

</owl:Class>

这个类公理声明了 operetta 是一个音乐作品，它至少有一个剧本作者，并且它不是歌剧。运用子类关系保留了还有其他音乐作品的可能性，这样的音乐作品有一个作者并且不是歌剧。 如果我们想要指明 operetta's 恰好 是那些有一个作者但不是歌剧的音乐作品，我们需要使用 owl:equivalentClass 结构。

3.2.2 owl:equivalentClass

一个类公理可能包含（多个） owl:equivalentClass 声明。 owl:equivalentClass 是一个内置属性，它把一个类运算式连接到另外一个类运算式。这类公理的意义是两个有关的类运算式有相同的类外延（即，两个类运算式含有完全一样的个体集）。

在其最简单的形式里，等价类公理声明了两个具名类的等价关系（根据它们的类外延）。实例如下：

<owl:Class rdf:about="#US_President">

  <equivalentClass rdf:resource="#PrincipalResidentOfWhiteHouse"/>

</owl:Class>

注意：使用 owl:equivalentClass 并不意味着类相等（ class equality ）。类相等意味着类有相同的内涵（ intensional meaning ）（表示相同的概念）。在上面的例子中，“美国总统”的概念与某一地产主要居民的概念有关，但并不等于那个概念。 真正的类相等只能用 owl:sameAs 结构表达。 因为类相等需要把类当做个体，所以只能在 OWL Full 中表达。

通过链接类型 1 类运算式（类标识符）到类型 2 类运算式（枚举），使用 owl:equivalentClass 的类公理也能够用来定义一个枚举类。一个例子：

<owl:Class rdf:ID="DaPonteOperaOfMozart">

  <owl:equivalentClass>

    <owl:Class>

      <owl:oneOf rdf:parseType="Collection">

        <Opera rdf:about="#Nozze_di_Figaro"/>

        <Opera rdf:about="#Don_Giovanni"/>

        <Opera rdf:about="#Cosi_fan_tutte"/>

      </owl:oneOf>

    </owl:Class>

  </owl:equivalentClass>

</owl:Class>

这个类公理定义了共同表示“莫扎特的达蓬特歌剧”（音乐学的热门主题）的歌剧类 。 通过等价类结构的使用，我们能够为类成员声明充分必要条件，在此例中包含三个个体的枚举，不多不少。

注意： OWL DL 没有对可以用来作为 owl:equivalentClass 声明的主体和客体的类运算式类型做任何限制。在 OWL Lite 中，主体必须是类名，客体必须是类名或属性限制。

注意：虽然原则上不同类型的类运算式允许作为等价类声明的主体，实际上主体通常使用类标识符。本节中的例子也是如此。

同一个类可以有多个等价类公理。 但是，这就需要小心。 两个公理必须得出相同的结果，即完全相同的类外延。例如， 另外一个莫扎特的“达蓬特歌剧”等价类公理可以是下面的写法：

<owl:Class rdf:about="#DaPonteOperaOfMozart">

  <owl:equivalentClass>

    <owl:Class>

      <owl:intersectionOf rdf:parseType="Collection">

        <owl:Restriction>

          <owl:onProperty rdf:resource="#hasComposer"/>

          <owl:hasValue rdf:resource="#Wolfgang_Amadeus_Mozart"/>

        </owl:Restriction>

        <owl:Restriction>

          <owl:onProperty rdf:resource="#hasLibrettist"/>

          <owl:hasValue rdf:resource="#Lorenzo_Da_Ponte"/>

        </owl:Restriction>

      </owl:intersectionOf>

    </owl:Class>

  </owl:equivalentClass>

</owl:Class>

上面的例子表明莫扎特的达蓬特歌剧的类外延完全对应于由莫扎特作曲达蓬特写剧本的那些歌剧（注意：交集 = “与”）。上面的公理确实定义了一个和之前的公理有着完全相同实例的类。

注意：如果我们想要把一个“ A subClassOf B ”形式的公理“升级”到“ A equivalentClass B ”（意味着 A 的类外延不只是子集，实际上是和 B 的类外延相同的集合），我们可以添加第二个 subClassOf 公理，形如（ B subClassOf A ），这两个类外延定义上就等价了（从而具有和“ A 类等价于 B ”相同的意义）。 这样的子类关系“循环”是明确允许的。 因为 OWL 可以用在分布式环境中，这个特性非常有用。

3.2.3 不使用 owl:equivalentClass 的完整类的公理

<owl:Class rdf:ID="DaPonteOperaOfMozart">

  <owl:oneOf rdf:parseType="Collection">

    <owl:Thing rdf:about="#Nozze_di_Figaro"/>

    <owl:Thing rdf:about="#Don_Giovanni"/>

    <owl:Thing rdf:about="#Cosi_fan_tutte"/>

  </owl:oneOf>

</owl:Class>

<owl:Class rdf:ID="LivingBeing">

  <owl:unionOf rdf:parseType="Collection">

    <owl:Class rdf:about="#Plant"/>

    <owl:Class rdf:about="#Animal"/>

  </owl:unionOf>

</owl:Class>

3.2.4 owl:disjointWith

一个类公理也许包含（多个） owl:disjointWith 声明。 owl:disjointWith 是一个以类运算式为定义域和值域的内置 OWL 属性。每个 owl:disjointWith 声明断言所涉及的两个类运算式的类外延没有共同的个体。 如同含有 rdfs:subClassOf 的 公理，声明两个类不相交是部分定义：它把一个必要但不充分条件施加于此类。

下面是一个关于不相交类的通俗例子：

<owl:Class rdf:about="#Man">

  <owl:disjointWith rdf:resource="#Woman"/>

</owl:Class>

这个例子正确与否实际上是由生物学家来决定的 。下面的例子给出了在子类等级结构中类不相交性的常见用法：

<owl:Class rdf:about="#MusicDrama">

  <owl:equivalentClass>

    <owl:Class>

      <owl:unionOf rdf:parseType="Collection">

        <owl:Class rdf:about="#Opera"/>

        <owl:Class rdf:about="#Operetta"/>

        <owl:Class rdf:about="#Musical"/>

      </owl:unionOf>

    </owl:Class>

  </owl:equivalentClass>

</owl:Class>

<owl:Class rdf:about="#Opera">

  <rdfs:subClassOf rdf:resource="#MusicDrama"/>

</owl:Class>

<owl:Class rdf:about="#Operetta">

  <rdfs:subClassOf rdf:resource="#MusicDrama"/>

  <owl:disjointWith rdf:resource="#Opera"/>

</owl:Class>

<owl:Class rdf:about="#Musical">

  <rdfs:subClassOf rdf:resource="#MusicDrama"/>

  <owl:disjointWith rdf:resource="#Opera"/>

  <owl:disjointWith rdf:resource="#Operetta"/>

</owl:Class>

在这里，为了定义一个父类的一组互不相交且完整的子类， owl:disjointWith 声明和 owl:unionOf 一起使用。 在自然语言中：每一个 MusicDrama 要么是一个 Opera 要么是一个 Operetta 或者 Musical （子类的划分是完整的），并且个体如果属于其中一个子类，例如 Opera ，就不能属于另外一个子类，比如 Musical （ 不相交或不重叠的子类 ）。这是在许多数据 - 建模符号（ data-modelling notations ）中常用的建模概念。

注意： OWL Lite 中不允许使用 owl:disjointWith 。

4. 属性

注意： OWL 也有注释属性（ owl:AnnotationProperty ）和本体属性（ owl:OntologyProperty ）的概念。在 OWL DL 里因语义原因需要这些属性。参见 Sec. 7 和“ OWL 语义和抽象语法”文档 [ OWL S&AS ] 。

对象属性被定义为内置 OWL 类 owl:ObjectProperty 的一个实例。数据类型属性被定义为内置 OWL 类 owl:DatatypeProperty 的一个实例。 owl:ObjectProperty 和 owl:DatatypeProperty 都是 RDF 类 rdf:Property 的 子类 （参见 附录 B ）。

注意：在 OWL Full 中，对象属性和数据类型属性并不互斥。因为数据值可以被视为个体，数据类型属性是对象属性的有效子类。 OWL Full 中， owl:ObjectProperty 等价于 rdf:Property 。 在实践中，这主要对 owl:InverseFunctionalProperty 的使用产生影响。参见 Sec. 8.1 OWL Full 特性。

属性公理定义一个属性的特征。一个属性公理在其最简单的形式中只定义一个属性的存在。例如：

<owl:ObjectProperty rdf:ID="hasParent"/>

这个例子定义了一个属性，限制条件为其值必须是个体。

属性公理常常会定义附加属性特征。 OWL 支持下面的属性公理结构：

在接下来的小节中，会更加详细地讨论各种类型的属性公理。

注意： 在这一节中我们使用的术语“属性外延”类似于“类外延”。 属性外延 是与该属性相关的实例集合。 属性的实例不是单一元素，而是属性声明的主 - 客体对。在关系数据库术语里，属性实例被称为二元关系（属性）的“元组”（ tuples ）。

4.1 RDF Schema 属性结构

本节中的结构在 RDF Schema 文档 [ RDF Vocabulary ] 中做了更详细的讨论。本节中的描述仅提供这些结构的概要和一些专用于 OWL 的方面及例子。

4.1.1 rdfs:subPropertyOf

rdfs:subPropertyOf 公理定义了一个属性是另一属性的子属性。 这意味着如果 P1 是 P2 的子属性，那么 P1 的属性外延（一个对集合）应该是 P2 的属性外延（也是一个对集合）的子集。

一个例子：

<owl:ObjectProperty rdf:ID="hasMother">

  <rdfs:subPropertyOf rdf:resource="#hasParent"/>

</owl:ObjectProperty>

这表明属性“ hasMother ”属性外延中的所有实例（对）也是属性“ hasParent ”属性外延的成员。

子属性公理可以应用于数据类型属性和对象属性。

注意： OWL DL 中，一个子属性声明的主体和客体必须两者都是数据类型属性或者对象属性。

4.1.2 rdfs:domain （定义域）

对于一个属性可以定义（多个） rdfs:domain 公理。在句法上， rdfs:domain 是内置属性，它链接一个属性（类 rdf:Property 的 某个 实例 ）到 类运算式 。 rdfs:domain 公理 断言 这样的属性声明的主体必须属于指定类运算式的类外延。

多重 rdfs:domain 公理是允许的，并且应该被解释为一个合取： 这限制了该属性的定义域是那些属于类运算式 交集 的个体。 如果想要声明多个类可以充当定义域，那么应该使用一个 owl:unionOf 形式的类运算式。 例如，如果我们想要声明属性 hasBankAccount 的定义域是 Person 或者 Corporation ，我们需要声明类似下面的东西：

<owl:ObjectProperty rdf:ID="hasBankAccount">

  <rdfs:domain>

    <owl:Class>    

      <owl:unionOf rdf:parseType="Collection">

        <owl:Class rdf:about="#Person"/>

        <owl:Class rdf:about="#Corporation"/>

      </owl:unionOf>

    </owl:Class>    

  </rdfs:domain>

</owl:ObjectProperty>

注意： OWL Lite 中， rdfs:domain 的值必须是一个类标识符。

4.1.3 rdfs:range （值域）

对于一个属性可以定义（多个） rdfs:range 公理。在句法上， rdfs:range 是内置的属性，它链接一个属性（类 rdf:Property 的 某个 实例 ）到一个 类运算式 或者 数据值域 。 rdfs:range 公理断言这个属性的值必须属于类运算式的类外延或者指定数据值域内的数据值。

多重值域约束解读为声明属性的值域是所有值域的 交集 （即，类运算式的类外延的交集或数据值域的交集）。类似于 rdfs:domain ，多个供选择的值域可以使用 owl:unionOf 形式的类运算式来指定（参见上一小节）。

需要注意的是，不同于本节中描述的关于类运算式的任何 值约束 ， rdfs:range 限制是全局的。 值约束（比如 owl:allValuesFrom ） 用在一个类运算式中，只有当约束应用到那个类时，才会对该属性起作用。 与此相反， rdfs:range 限制适用于该属性而与它被用于哪个类无关。因此，使用 rdfs:range 的时候要小心。

注意： OWL Lite 中，允许作为 rdfs:range 的客体的唯一 类运算式类型是类名 。

4.2 与其他属性的关系

4.2.1 owl:equivalentProperty

owl:equivalentProperty 结构能够用来声明两个属性有相同的属性外延。在句法上， owl:equivalentProperty 是内置的 OWL 属性，它以 rdf:Property 为定义域和值域。

注意： 属性等价（ property equivalence ）不同于属性相等（ property equality ）。 等价的属性有着相同的“值”（即，相同的属性外延），但可以有不同的内涵（即，表示不同的概念）。属性相等应该用 owl:sameAs 结构来表达。由于这样的公理要求把属性看作个体，因此它只能在 OWL Full 中使用。

4.2.2 owl:inverseOf

属性具有一个从定义域到值域的方向性。在实践中，人们会经常发现在两个方向定义关系很有用：人拥有车，车属于人。 owl:inverseOf 结构可以用来定义属性之间的这种逆关系。

在句法上， owl:inverseOf 是一个内置的 OWL 属性，它以 owl:ObjectProperty 作为定义域和值域。一个 P1 owl:inverseOf P2 形式的公理断言 P1 属性外延中的每一对（ x ， y ），在 P2 属性外延中都有一对（ y,x ）与之对应，反之亦然。因此， owl:inverseOf 是一个对称属性 。

一个例子：

<owl:ObjectProperty rdf:ID="hasChild">

  <owl:inverseOf rdf:resource="#hasParent"/>

</owl:ObjectProperty>

4.3 关于属性的全局基数约束

4.3.1 owl:FunctionalProperty

函数型属性是这样的一个属性，对于每个 x 实例，它只能有一个（唯一）值 y 与之对应，即不存在两个不同的值 y1 和 y2 使得（ x,y1 ）和（ x,y2 ）都是这个属性的实例。对象属性和数据类型属性都可以声明为“函数型”（ functional ）。 为了这一目的， OWL 定义内置类 owl:FunctionalProperty 为 RDF 类 rdf:Property 的一个特殊子类。

下面的公理表明了 husband 属性是函数型的，即一个女人最多有一个丈夫（本体的文化依赖的一个好例子）：

<owl:ObjectProperty rdf:ID="husband">

  <rdf:type rdf:resource="&owl;FunctionalProperty" />

  <rdfs:domain rdf:resource="#Woman" />

  <rdfs:range rdf:resource="#Man" />

</owl:ObjectProperty>

一如往常有不同的句法变种。 上例和下例在语义上等价：

<owl:ObjectProperty rdf:ID="husband">

  <rdfs:domain rdf:resource="#Woman" />

  <rdfs:range  rdf:resource="#Man" />

</owl:ObjectProperty>

<owl:FunctionalProperty rdf:about="#husband" />

4.3.2 owl:InverseFunctionalProperty

在句法上，通过声明一个属性是内置 OWL 类 owl:InverseFunctionalProperty 的一个实例来 指定一个反函数型属性公理，上面所述的内置 OWL 类是 OWL 类 owl:ObjectProperty 的子类 。

注意：因为在 OWL Full 中数据类型属性是对象属性的子类，所以一个反函数型属性可以被定义为数据类型属性。 OWL DL 中，对象属性和数据类型不相交，因此一个反函数型属性不能被定义为数据类型属性。也参见 Sec. 8.1 和 Sec. 8.2 。

一个反函数型属性的典型例子：

<owl:InverseFunctionalProperty rdf:ID="biologicalMotherOf">

  <rdfs:domain rdf:resource="#Woman"/>

  <rdfs:range rdf:resource="#Human"/>

</owl:InverseFunctionalProperty>

这个例子表明对 biologicalMotherOf 声明的 每一个客体（某一人）应该能唯一确定一个主体（某一女性）。反函数型属性类似于数据库中键的概念。

一个与函数型属性不同的方面是，对于反函数型属性，不需要附加的对象属性或数据类型属性公理：反函数型属性在定义上就是对象属性。

我们注意到 owl:FunctionalProperty 和 owl:InverseFunctionalProperty 指定全局基数约束。也就是说，无论这个属性应用到哪个类，这些基数约束都必须遵守。 这不同于 属性限制 中的基数约束。后者是类运算式，当应用于那个类时才会施加在属性上。

4.4 属性的逻辑特征

4.4.1 owl:TransitiveProperty

当一个属性 P 被定义为传递属性时，意味着如果（ x,y ）是 P 的一个实例，（ y,z ）也是 P 的一个实例， 那么我们能推断出（ x,z ）也是 P 的一个实例。

在句法上，通过使其成为内置 OWL 类 owl:TransitiveProperty 的一个实例来 定义一个属性的传递性，这个内置类是 OWL owl:ObjectProperty 的子类。

代表某些部分 - 整体关系的属性是传递属性的典型例子。 例如，我们可能想要说明地区之间的属性 subRegionOf 具有传递性 ：

<owl:TransitiveProperty rdf:ID="subRegionOf">

  <rdfs:domain rdf:resource="#Region"/>

  <rdfs:range  rdf:resource="#Region"/>

</owl:TransitiveProperty>

根据此描述，一个 OWL 推理器应该能够推理出这样的结论：如果 ChiantiClassico 、 Tuscany 和 Italy 是地区，并且 ChiantiClassico 是 Tuscany 的子区域， Tuscany 是 Italy 的子地区，那么 ChiantiClassico 也是 Italy 的子区域。

我们注意到由于 owl:TransitiveProperty 是 owl:ObjectProperty 的子类，因此下面的句法变体与上面的例子等价：

<owl:ObjectProperty rdf:ID="subRegionOf">

  <rdf:type rdf:resource="&owl;TransitiveProperty"/>

  <rdfs:domain rdf:resource="#Region"/>

  <rdfs:range  rdf:resource="#Region"/>

</owl:ObjectProperty>

注意： OWL DL 要求，对于一个传递属性，其本身、其父属性、其本身或其父属性的逆属性都不能声明局部或全局基数约束。

4.4.2 owl: SymmetricProperty

对称属性支持这一事实：如果（ x,y ）是 P 一个实例，那么（ y,x ）也是 P 的一个实例。句法上，通过成为内置 OWL 类 owl:SymmetricProperty 的一个实例来定义一个属性的对称性，这个内置 OWL 类是 owl:ObjectProperty 的子类。

friendOf 关系是对称属性的一个通俗的例子：

<owl:SymmetricProperty rdf:ID="friendOf">

  <rdfs:domain rdf:resource="#Human"/>

  <rdfs:range  rdf:resource="#Human"/>

</owl:SymmetricProperty>

一个对称属性的定义域和值域是相同的。

5. 个体

5.1 类成员和属性值

<Opera rdf:ID="Tosca">

  <hasComposer rdf:resource="#Giacomo_Puccini"/>

  <hasLibrettist rdf:resource="#Victorien_Sardou"/>

  <hasLibrettist rdf:resource="#Giuseppe_Giacosa"/>

  <hasLibrettist rdf:resource="#Luigi_Illica"/>

  <premiereDate rdf:datatype="&xsd;date">1900-01-14</premiereDate>

  <premierePlace rdf:resource="#Roma"/>

  <numberOfActs rdf:datatype="&xsd;positiveInteger">3</numberOfActs> 

</Opera>

这个例子包含了个体 Tosca 的一些事实，个体 Tosca 是类 Opera 的一个实例。 Tosca 由 Giacomo Puccini 作曲。这一歌剧有三个剧本作者。属性 premiereDate 链接歌剧到类型为 XML Schema 数据类型 date 的 文字。关于数据类型的 XML schema 文档 [ XML Schema Datatypes ] 包含这种数据类型的语法和语义的相关信息。

个体公理不一定是关于具名个体：它们也可以涉及匿名个体。例如，我们考虑下面的 RDF/XML 片段。该示例定义了类 Measurement 的一个匿名实例的一些事实，列出了对哪些事实的定量观察，例如所观察的主体，观察到的现象，观察到的值，观察时间：

<Measurement>

  <observedSubject rdf:resource="#JaneDoe"/>

  <observedPhenomenon rdf:resource="#Weight"/>

  <observedValue>

    <Quantity>

      <quantityValue rdf:datatype="&xsd;float">59.5</quantityValue>

      <quantityUnit rdf:resource="#Kilogram"/>

    </Quantity>

  </observedValue>

  <timeStamp rdf:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</timeStamp>

</Measurement>

该个体公理包含两个匿名个体，即某一 Measurement 和某一 Quantity 。 在自然语言中，所测得的主体 Jane Doe 的 现象 Weight 的值是某一数量，其值是以千克为单位的 59.5 。测量时间是 UTC+1 时区（阿姆斯特丹、柏林、巴黎的冬令时）， 2003 年 1 月 24 日，上午 9 点过 8 秒。如前所述， float 和 dateTime 是 XML Schema 数据类型，在相关的 XML Schema 文档 [ XML Schema Datatypes ] 里可以找到其句法和语法细节。

5.2 个体同一性

5.2.1 owl:sameAs

内置 OWL 属性 owl:sameAs 链接 两个个体。 此 owl:sameAs 声明表明两个 URI 引用实际上指向相同的事物：这些个体拥有相同的“身份”。

对于比如“人”这一概念的个体来说相对容易理解。例如，我们可以声明下面两个 URI 引用实际上指向同一个人：

<rdf:Description rdf:about="#William_Jefferson_Clinton">

  <owl:sameAs rdf:resource="#BillClinton"/>

</rdf:Description>

owl:sameAs 声明经常用于定义本体间的映射。 假设每个人都使用相同的名称指向个体是不切实际的。这将需要宏大的设计，有违网络精神。

OWL Full 中，一个类可以被当做（元）类的实例，我们可以使用 owl:sameAs 结构来定义类相等，从而表明这两个概念有相同的内涵。例如：

<owl:Class rdf:ID="FootballTeam">

  <owl:sameAs rdf:resource="http://sports.org/US#SoccerTeam"/>

</owl:Class>

我们可以想象这个公理是欧洲体育本体的一部分。这两个类在这里被当做个体，作为类 owl:Class 的实例。这使得我们可以声明某个欧洲体育本体里的类 FootballTeam 和某个美国体育本体里的类 SoccerTeam 表示相同的概念。 我们注意到这样一个声明的不同：

<footballTeam owl:equivalentClass us:soccerTeam />

它表明这两个类有相同的类外延，但概念不（一定）相同。

注意： URI 引用对照详情请参见 RDF 概念文档 [ RDF Concepts ] 里的 RDF URI 引用相关章节。

5.2.2 owl:differentFrom

内置 OWL owl:differentFrom 属性链接两个个体。 owl:differentFrom 声明表示两个 UR I 引用指向不同的个体。

一个例子：

<Opera rdf:ID="Don_Giovanni"/>

<Opera rdf:ID="Nozze_di_Figaro">

  <owl:differentFrom rdf:resource="#Don_Giovanni"/>

</Opera>

<Opera rdf:ID="Cosi_fan_tutte">

  <owl:differentFrom rdf:resource="#Don_Giovanni"/>

  <owl:differentFrom rdf:resource="#Nozze_di_Figaro"/>

</Opera>

上述例子声明了三个不同的歌剧。

5.2.3 owl:AllDifferent

对于唯一名称假设成立的本体，当所有个体不得不声明两两不相交时，使用 owl:differentFrom 可能导致大量的声明。针对这一情况， OWL 提供了一个 owl:AllDifferent 结构形式的专门术语。 owl:AllDifferent 是一个特殊的内置 OWL 类，此类要定义属性 owl:distinctMembers ，用来链接 owl:AllDifferent 的一个实例到个体列表。这个声明的含义是列表中的所有个体彼此互不相同。

一个例子：

<owl:AllDifferent>

  <owl:distinctMembers rdf:parseType="Collection">

    <Opera rdf:about="#Don_Giovanni"/>

    <Opera rdf:about="#Nozze_di_Figaro"/>

    <Opera rdf:about="#Cosi_fan_tutte"/>

    <Opera rdf:about="#Tosca"/>

    <Opera rdf:about="#Turandot"/>

    <Opera rdf:about="#Salome"/>

  </owl:distinctMembers>

</owl:AllDifferent>

上述例子表明这六个 URI 引用均指向不同的歌剧。

注意： owl:distinctMembers 是一个专门的句法结构，它的增加带来了便利，它应该始终与作为其主体的一个 owl:AllDifferent 个体一起使用。

6. 数据类型

在 Sec. 6.3 里对工具支持数据类型的最低标准做了讨论。

6.1 RDF 数据类型

OWL 使用 RDF 数据类型方案，它提供了一个机制指向 XML Schema 数据类型 [ XML Schema Datatypes ] 。有关的详细描述，读者可参考 RDF 文档，例如 [ RDF Concepts ] 。为方便读者，在这里我们提供了 RDF 数据类型使用的概要。

数据值是 RDF Schema 类 rdfs: Literal 的实例。 文本可以是普通的（没有数据类型）或者类型化的。 数据类型是类 rdfs:Datatype 的实例。在 RDF/XML 中，一个文本的类型由 rdf:datatype 属性指定，建议其值为下面列举之一：

·                                  http://www.w3.org/2001/XMLSchema#NAME

“ NAME ”处应替换为 简单 XML Schema 内置 数据类型的名称，如同 [ XML Schema Datatypes ] 的 Section 3 中定义的那样，带有下面指定的附带条件。

·                                  http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral

有关这个数据类型的详情，请参见“ RDF 概念”文档 [ RDF Concepts ] 。

“ RDF 语义”文档 [ RDF Semantics ， Section 5] 推荐使用下面的简单内置 XML Schema 数据类型。

<owl:DatatypeProperty rdf:about="#timeStamp">

  <rdfs:domain rdf:resource="#Measurement"/>

  <rdf:range rdf:resource="&xsd;dateTime"/>

</owl:DatatypeProperty>

<Measurement>

  <timeStamp rdf:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</timeStamp>  

</Measurement>

<owl:DatatypeProperty rdf:ID="tennisGameScore">

  <rdfs:range>

    <owl:DataRange>

      <owl:oneOf>

        <rdf:List>

           <rdf:first rdf:datatype="&xsd;integer">0</rdf:first>

           <rdf:rest>

             <rdf:List>

               <rdf:first rdf:datatype="&xsd;integer">15</rdf:first>

               <rdf:rest>

                 <rdf:List>

                   <rdf:first rdf:datatype="&xsd;integer">30</rdf:first>

                   <rdf:rest>

                     <rdf:List>

                       <rdf:first rdf:datatype="&xsd;integer">40</rdf:first>

                       <rdf:rest rdf:resource="&rdf;nil" />

                     </rdf:List>

                   </rdf:rest>

                 </rdf:List>

              </rdf:rest>

            </rdf:List>

          </rdf:rest>

        </rdf:List>

      </owl:oneOf>

    </owl:DataRange>

  </rdfs:range>

</owl:DatatypeProperty>

·                              AnnotationPropertyID rdf:type owl:AnnotationProperty .

<owl:AnnotationProperty rdf:about="&dc;creator"/>

<owl:Class rdf:about="#MusicalWork">

  <rdfs:label>Musical work</rdfs:label>

  <dc:creator>N.N.</dc:creator>

</owl:Class>

上述例子假定 &dc; 和 dc: 分别指向 Dublin Core URI 和命名空间。因此，在 OWL DL 中 Dublin Core 属性当做注释属性来使用需要一个显式的定义类型三元组。这确保了注释在语义正确的方式下由 OWL DL 推理器处理（更多详情参见“ OWL 语义和抽象语法”文档 [ OWL S&AS ] ）。

一旦我们将 dc:creator 定义为注释属性， OWL DL 就不允许有比如下面的值域约束这样的属性公理：

<-- 这在OWL DL中是非法的 -->

<owl:AnnotationProperty rdf:about="&dc;creator">

  <rdfs:range rdf:resource="&xsd;string"/>

</owl:AnnotationProperty>

我们注意到仍可以在注释 - 属性声明中指定一个文本类型的值：

<Opera rdf:about="#Tosca">

  <dc:creator rdf:datatype="&xsd;string">Giacomo Puccini</dc:creator>

</Opera>

7.2 本体头

描述一个本体的文档通常包含本体本身的信息。 本体是一种资源，所以可以使用 OWL 的属性和其他命名空间来描述它，例如：

<owl:Ontology rdf:about="">

  <owl:versionInfo> ... </owl:versionInfo>

  <rdfs:comment>...</rdfs:comment>

  <owl:imports rdf:resource="..."/>

</owl:Ontology>

这通常被称为本体头，我们通常可在 RDF/XML 文档头附近看见它。其中这一行

  <owl:Ontology rdf:about="">

表明本模块描述了当前本体。更确切地说，它表明当前基准 URI 标识类 owl:Ontology 的一个实例。 建议在文档的开头使用 <rdf:RDF> 元素中的 xml:base 属性定义基准 URI 。

一个样本本体头看起来是这样的：

<owl:Ontology rdf:about="">

  <owl:versionInfo>v 1.17 2003/02/26 12:56:51 mdean</owl:versionInfo>

  <rdfs:comment>An example ontology</rdfs:comment>

  <owl:imports rdf:resource="http://www.example.org/foo"/>

</owl:Ontology>

下面的章节描述了通常用在头部的各种声明类型。

注意：在 OWL 词汇表中将本体 - 导入结构 owl:imports 和本体版本结构 owl:priorVersion 、 owl:backwardCompatibleWith 及 owl:incompatibleWith 定义为 OWL 内置类 owl:OntologyProperty 的实例。 owl:OntologyProperty 的实例必须要以类 owl:Ontology 作为它们的定义域和值域。允许定义其他 owl:OntologyProperty 的 实例。在 OWL DL 中，对于本体属性的约束和 Sec. 7.1 中为注释属性指定的约束一样。

7.3 导入本体

一个 owl:imports 声明引用另外一个包含定义的 OWL 本体，其含义被认为是该导入本体含义的一部分。 每个引用都包含一个 URI 指明该本体从何处被导入。在句法上， owl:imports 是一个以类 owl:Ontology 为定义域和值域的属性。

owl:imports 声明是传递性的，也就是说，如果本体 A 导入了 B ， B 导入了 C ，那么 A 就导入了 B 和 C 。

一个本体导入自己本身被认为是空动作，因此，如果本体 A 导入 B ， B 也导入 A ，那么就认为 A 和 B 等价。

注意：一个 OWL 工具是否必须加载一个被导入本体取决于工具的目的。 如果该工具是一个完整的推理器（包括完整的一致性检查器），那么它必须加载所有的被导入本体。 其他工具，比如简单的编辑器和不完整的推理器可以选择性地加载一些甚至不加载被导入本体。

虽然 owl:imports 和命名空间声明可能显得多余，实际上它们用于不同的目的。命名空间声明仅仅为引用标识符设立一个简写。它们没有隐含定位于 URI 的文档的含义。另一方面， owl:imports 没有为引用被导入文档的标识符提供任何简写符号。因此，任何被导入的本体都有一个相应的命名空间声明。

注意： owl:imports 是 owl:OntologyProperty 的一个实例。

7.4 版本信息

7.4.1 owl:versionInfo

owl:versionInfo 声明通常都有一个字符串作为其客体提供这一版本的信息 ，例如 RCS/CVS 关键词。除了 RDF(S) 模型理论给定的意义，此声明对本体的逻辑意义没有贡献。

虽然这个属性通常用来进行本体的声明，但它可以应用于任何 OWL 结构。例如，我们可以为一个 OWL 类附加一个 owl:versionInfo 声明。

注意： owl:versionInfo 是 owl:AnnotationProperty 的一个实例。

7.4.2 owl:priorVersion

owl:priorVersion 声明包含一个到另外一个本体的引用。 它标识了指定的本体是包含（ containing ）本体的以前版本 。除了 RDF(S) 模型理论给定的意义，此声明在模型 - 理论语义中没有任何意义。然而，软件可以用它来根据版本组织本体。

owl:priorVersion 是以类 owl:Ontology 作为其定义域和值域的内置 OWL 属性。

注意： owl:priorVersion 是 owl:OntologyProperty 的一个实例。

7.4.3 owl:backwardCompatibleWith

owl:backwardCompatibleWith 声明包含对另外一个本体的引用。它标识了指定的本体是包含本体的以前版本，并进一步表明新版本向后兼容。具体而言，它表明以前版本中的所有标识符在新版本中有相同的预期解释。因此，此声明暗示文档作者可以放心地将他们的文档改为新版本（ 通过简单地更新命名空间声明和 owl:imports 陈述指向新版本的 URL ）。如果没有为两个版本声明 owl:backwardCompatibleWith ，那么就不能假定它们的兼容性。

除了 RDF(S) 模型理论给定的含义， owl:backwardCompatibleWith 在模型 - 理论语义中没有任何意义。

owl:backwardCompatibleWith 是以类 owl:Ontology 作为其定义域和值域的内置 OWL 属性。

注意： owl:backwardCompatibleWith 是 owl:OntologyProperty 的一个实例。

7.4.4 owl:incompatibleWith

owl:incompatibleWith 声明包含对另外一个本体的引用。它表明了包含本体是所引用本体的更高版本，但新版本不向后兼容。 对于那些想要明确说明在没有检查是否需要更改的情况下文档不能升级到新版本的本体作者而言，此声明的使用是必要的。

注意： owl:incompatibleWith 是 owl:OntologyProperty 的一个实例。

7.4.5 owl:DeprecatedClass 和 owl:DeprecatedProperty

一个关于过时的例子：

<owl:Ontology rdf:about="">

  <rdfs:comment>Vehicle Ontology, v. 1.1</rdfs:comment>

  <owl:backwardCompatibleWith

          rdf:resource="http://www.example.org/vehicle-1.0"/>   

  <owl:priorVersion rdf:resource="http://www.example.org/vehicle-1.0"/>

</owl:Ontology>

<owl:DeprecatedClass rdf:ID="Car">

  <rdfs:comment>Automobile is now preferred</rdfs:comment>

  <owl:equivalentClass rdf:resource="#Automobile"/>

  <!-- note that equivalentClass only means that the classes have the same

       extension, so this DOES NOT lead to the entailment that

       Automobile is of type DeprecatedClass too -->        

</owl:DeprecatedClass>

<owl:Class rdf:ID="Automobile" />

<owl:DeprecatedProperty rdf:ID="hasDriver">

  <rdfs:comment>inverse property drives is now preferred</rdfs:comment>

  <owl:inverseOf rdf:resource="#drives" />

</owl:DeprecatedProperty>

<owl:ObjectProperty rdf:ID="drives" />

8. OWL Full ， OWL DL 和 OWL Lite

在引言中，我们简要地讨论了 OWL 的三种子语言。 在本节中，我们将给出 OWL 的三个“种类”之间差别的资料性说明。“语义和抽象”文档 [ OWL S&AS ] 里给出了这些差别的形式化解释。

8.1 OWL Full

OWL Full 实际上不是子语言。 OWL Full 包括所有 OWL 语言结构，并提供 RDF 结构自由的、不受限制的使用。在 OWL Full 中资源 owl:Class 相当于 rdfs:Class 。这一点和 OWL DL 及 OWL Lite 不同，在后两者中 owl:Class 是 rdfs:Class 的真子类（ proper subclass ）（ 这意味着在 OWL DL 和 OWL Lite 中并非所有 RDF 类都是 OWL 类 ）。 OWL Full 还允许类被当做个体。例如，在 OWL Full 中有一个“ Fokker-100 ”标识符同时作为类名（表示一组环球飞行的 Fokker-100 飞机）和个体名（ 例如 ， 类 AirplaneType 的一个实例 ）是完全合法的。

OWL Full 中所有数据值也被认为是个体定义域的一部分。 事实上， OWL Full 中个体的总体由所有资源（ owl:Thing 相当于 rdfs:Resource ）组成。这意味着对象属性和数据类型属性并不互斥。在 OWL Full 中 owl:ObjectProperty 相当于 rdf:Property 。其结果是，数据类型属性实际上是对象属性的子类。（注意： owl:ObjectProperty 和 owl:DatatypeProperty 都是 rdf:Property 的 子类的事实与这点并不矛盾）。

对于想要结合 OWL 的表达性和 RDF 的灵活性以及元建模特性的人， OWL Full 将会很有用。然而， OWL Full 特性的使用意味着会失去 OWL DL 和 OWL Lite 可以提供给推理系统的一些保证（参见 下文 ）。

注意：除非专门以 OWL DL 或 Lite 构造，否则 RDF 文档通常都采用 OWL Full 。

注意：因此， OWL Full 中 owl:Thing 等价于 rdfs:Resource ， owl:Class 等价 于 rdfs:Class ， owl:ObjectProperty 等价于 rdf:Property 。

8.2 OWL DL

永远不能为 数据类型属性 指定。

最后一个约束意味着人们引用的所有类和属性要分别显式地定型为 OWL 类或属性。 例如，如果本体包含下面的成分：

  <owl:Class rdf:ID="C1">

    <rdfs:subClassOf rdf:resource="#C2" />

  </owl:Class>

则该本体（或一个被导入此本体的本体）应该为 C2 包含一个 owl:Class 三元组。

这些 OWL DL 约束可能看起来像一个任意集合，但事实并非如此。 这些约束基于针对描述逻辑的推理器领域的工作，这些工作需要这些限制向本体构建者或用户提供推理支持。 具体而言， OWL DL 限制允许了 OWL Full 的最大子集，在此之上现有研究可以确保一个 OWL 推理器存在一个可判定的推理过程。

注意： 附录 E 为采用 RDF 表示 OWL DL 本体提供了一套实践指南。

8.3 OWL Lite

注意：这是 OWL Lite 中合法使用 owl:intersectionOf 的一个典型例子：

        <owl:Class rdf:ID="Woman">

          <owl:intersectionOf rdf:parseType="Collection">

            <owl:Class rdf:about="#Female"/>

            <owl:Class rdf:about="#Human"/>

          </owl:intersectionOf>

        </owl:Class/>

OWL Lite 表达力限制背后的理念是它们提供语言特性的最小有用子集，使得工具开发者更容易支持。 OWL Lite 语言结构为子类等级结构构造提供了基础： 子类和属性限制。此外， OWL Lite 允许属性是可选的或必备的。 OWL Lite 的限制将其置于复杂度比 OWL DL 低的位置。 这一点可以对针对 OWL Lite 的完整推理器的效率产生积极的影响。

只支持 OWL Lite 词汇，但在其他方面放宽 OWL DL 限制的实现并不能确保一致性和复杂性方面的计算要求。然而，这样的实现可能对提供 OWL 系统与 RDFS 模型、数据库、标记工具或其他非推理工具之间的互操作性有帮助。 Web 本体工作组并没有为这一可能有益的子集提供一个名称。

附录 A. 所有语言元素的索引

注意：本附录只包含 OWL 专用结构。 RDF/RDFS 结构请参见相关 RDF 文档，尤其是 RDF Schema 文档 [ RDF Vocabulary ] 。

本附录目的的描述请参见 Sec. 1.7 。这个附录的 RDF/XML 版本可以在 http://www.w3.org/2002/07/owl 上找到。

<?xml version="1.0"?>

<!DOCTYPE rdf:RDF [

     <!ENTITY rdf  "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >

     <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >

     <!ENTITY xsd  "http://www.w3.org/2001/XMLSchema#" >

     <!ENTITY owl  "http://www.w3.org/2002/07/owl#" >

   ]>

<rdf:RDF

  xmlns     ="&owl;"

  xmlns:owl ="&owl;"

  xml:base  ="http://www.w3.org/2002/07/owl"

  xmlns:rdf ="&rdf;"

  xmlns:rdfs="&rdfs;"

> 

<Ontology rdf:about="">

  <imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>

  <rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/" />

  <rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-test-20040210/" />

  <rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-features-20040210/" />

  <rdfs:comment>This file specifies in RDF Schema format the

    built-in classes and properties that together form the basis of

    the RDF/XML syntax of OWL Full, OWL DL and OWL Lite.

    We do not expect people to import this file

    explicitly into their ontology. People that do import this file

    should expect their ontology to be an OWL Full ontology. 

  </rdfs:comment>

  <versionInfo>10 February 2004</versionInfo>

</Ontology>

<rdfs:Class rdf:ID="Class">

  <rdfs:label>Class</rdfs:label>

  <rdfs:subClassOf rdf:resource="&rdfs;Class"/>

</rdfs:Class>

<Class rdf:ID="Thing">

  <rdfs:label>Thing</rdfs:label>

  <unionOf rdf:parseType="Collection">

    <Class rdf:about="#Nothing"/>

    <Class>

      <complementOf rdf:resource="#Nothing"/>

    </Class>

  </unionOf>

</Class>

<Class rdf:ID="Nothing">

  <rdfs:label>Nothing</rdfs:label>

  <complementOf rdf:resource="#Thing"/>

</Class>

<rdf:Property rdf:ID="equivalentClass">

  <rdfs:label>equivalentClass</rdfs:label>

  <rdfs:subPropertyOf rdf:resource="&rdfs;subClassOf"/>

  <rdfs:domain rdf:resource="#Class"/>

  <rdfs:range rdf:resource="#Class"/>

</rdf:Property>

<rdf:Property rdf:ID="disjointWith">

  <rdfs:label>disjointWith</rdfs:label>

  <rdfs:domain rdf:resource="#Class"/>

  <rdfs:range rdf:resource="#Class"/>

</rdf:Property>

<rdf:Property rdf:ID="equivalentProperty">

  <rdfs:label>equivalentProperty</rdfs:label>

  <rdfs:subPropertyOf rdf:resource="&rdfs;subPropertyOf"/>

</rdf:Property>

<rdf:Property rdf:ID="sameAs"> 

  <rdfs:label>sameAs</rdfs:label>

  <rdfs:domain rdf:resource="#Thing"/>

  <rdfs:range rdf:resource="#Thing"/>

</rdf:Property>




    

<rdf:Property rdf:ID="differentFrom">

  <rdfs:label>differentFrom</rdfs:label>

  <rdfs:domain rdf:resource="#Thing"/>

  <rdfs:range rdf:resource="#Thing"/>

</rdf:Property>

<rdfs:Class rdf:ID="AllDifferent">

  <rdfs:label>AllDifferent</rdfs:label>

</rdfs:Class>

<rdf:Property rdf:ID="distinctMembers">

  <rdfs:label>distinctMembers</rdfs:label>

  <rdfs:domain rdf:resource="#AllDifferent"/>

  <rdfs:range rdf:resource="&rdf;List"/>

</rdf:Property>

<rdf:Property rdf:ID="unionOf">

  <rdfs:label>unionOf</rdfs:label>

  <rdfs:domain rdf:resource="#Class"/>

  <rdfs:range rdf:resource="&rdf;List"/>

</rdf:Property>

<rdf:Property rdf:ID="intersectionOf">

  <rdfs:label>intersectionOf</rdfs:label>

  <rdfs:domain rdf:resource="#Class"/>

  <rdfs:range rdf:resource="&rdf;List"/>

</rdf:Property>

<rdf:Property rdf:ID="complementOf">

  <rdfs:label>complementOf</rdfs:label>

  <rdfs:domain rdf:resource="#Class"/>

  <rdfs:range rdf:resource="#Class"/>

</rdf:Property>

<rdf:Property rdf:ID="oneOf">

  <rdfs:label>oneOf</rdfs:label>

  <rdfs:domain rdf:resource="&rdfs;Class"/>

  <rdfs:range rdf:resource="&rdf;List"/>

</rdf:Property>

<rdfs:Class rdf:ID="Restriction">

  <rdfs:label>Restriction</rdfs:label>

  <rdfs:subClassOf rdf:resource="#Class"/>

</rdfs:Class>

<rdf:Property rdf:ID="onProperty">

  <rdfs:label>onProperty</rdfs:label>

  <rdfs:domain rdf:resource="#Restriction"/>

  <rdfs:range rdf:resource="&rdf;Property"/>

</rdf:Property>

<rdf:Property rdf:ID="allValuesFrom">

  <rdfs:label>allValuesFrom</rdfs:label>

  <rdfs:domain rdf:resource="#Restriction"/>

  <rdfs:range rdf:resource="&rdfs;Class"/>

</rdf:Property>

<rdf:Property rdf:ID="hasValue">

  <rdfs:label>hasValue</rdfs:label>

  <rdfs:domain rdf:resource="#Restriction"/>

</rdf:Property>

<rdf:Property rdf:ID="someValuesFrom">

  <rdfs:label>someValuesFrom</rdfs:label>

  <rdfs:domain rdf:resource="#Restriction"/>

  <rdfs:range rdf:resource="&rdfs;Class"/>

</rdf:Property>

<rdf:Property rdf:ID="minCardinality">

  <rdfs:label>minCardinality</rdfs:label>

  <rdfs:domain rdf:resource="#Restriction"/>

  <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>

</rdf:Property>

<rdf:Property rdf:ID="maxCardinality">

  <rdfs:label>maxCardinality</rdfs:label>

  <rdfs:domain rdf:resource="#Restriction"/>

  <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>

</rdf:Property>

<rdf:Property rdf:ID="cardinality">

  <rdfs:label>cardinality</rdfs:label>

  <rdfs:domain rdf:resource="#Restriction"/>

  <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>

</rdf:Property>

<rdfs:Class rdf:ID="ObjectProperty">

  <rdfs:label>ObjectProperty</rdfs:label>

  <rdfs:subClassOf rdf:resource="&rdf;Property"/>

</rdfs:Class>

<rdfs:Class rdf:ID="DatatypeProperty">

  <rdfs:label>DatatypeProperty</rdfs:label>

  <rdfs:subClassOf rdf:resource="&rdf;Property"/>

</rdfs:Class>

<rdf:Property rdf:ID="inverseOf">

  <rdfs:label>inverseOf</rdfs:label>

  <rdfs:domain rdf:resource="#ObjectProperty"/>

  <rdfs:range rdf:resource="#ObjectProperty"/>

</rdf:Property>

<rdfs:Class rdf:ID="TransitiveProperty">

  <rdfs:label>TransitiveProperty</rdfs:label>

  <rdfs:subClassOf rdf:resource="#ObjectProperty"/>

</rdfs:Class>

<rdfs:Class rdf:ID="SymmetricProperty">

  <rdfs:label>SymmetricProperty</rdfs:label>

  <rdfs:subClassOf rdf:resource="#ObjectProperty"/>

</rdfs:Class>

<rdfs:Class rdf:ID="FunctionalProperty">

  <rdfs:label>FunctionalProperty</rdfs:label>

  <rdfs:subClassOf rdf:resource="&rdf;Property"/>

</rdfs:Class>

<rdfs:Class rdf:ID="InverseFunctionalProperty">

  <rdfs:label>InverseFunctionalProperty</rdfs:label>

  <rdfs:subClassOf rdf:resource="&owl;ObjectProperty"/>

</rdfs:Class>

<rdfs:Class rdf:ID="AnnotationProperty

  <rdfs:subClassOf rdf:resource="&rdf;Property"/>

</rdfs:Class>

<AnnotationProperty rdf:about="&rdfs;label"/>

<AnnotationProperty rdf:about="&rdfs;comment"/>

<AnnotationProperty rdf:about="&rdfs;seeAlso"/>

<AnnotationProperty rdf:about="&rdfs;isDefinedBy"/>

<rdfs:Class rdf:ID="Ontology">

  <rdfs:label>Ontology</rdfs:label>

</rdfs:Class>

<rdfs:Class rdf:ID="OntologyProperty">

  <rdfs:subClassOf rdf:resource="&rdf;Property"/>

</rdfs:Class>

<rdf:Property rdf:ID="imports">

  <rdfs:label>imports</rdfs:label>

  <rdf:type rdf:resource="#OntologyProperty"/>

  <rdfs:domain rdf:resource="#Ontology"/>

  <rdfs:range rdf:resource="#Ontology"/>

</rdf:Property>

<rdf:Property rdf:ID="versionInfo">

  <rdfs:label>versionInfo</rdfs:label>

  <rdf:type rdf:resource="#AnnotationProperty"/>

</rdf:Property>

<rdf:Property rdf:ID="priorVersion">

  <rdfs:label>priorVersion</rdfs:label>

  <rdf:type rdf:resource="#OntologyProperty"/>

  <rdfs:domain rdf:resource="#Ontology"/>

  <rdfs:range rdf:resource="#Ontology"/>

</rdf:Property>

<rdf:Property rdf:ID="backwardCompatibleWith">

  <rdfs:label>backwardCompatibleWitesh</rdfs:label>

  <rdf:type rdf:resource="#OntologyProperty"/>

  <rdfs:domain rdf:resource="#Ontology"/>

  <rdfs:range rdf:resource="#Ontology"/>

</rdf:Property>

<rdf:Property rdf:ID="incompatibleWith">

  <rdfs:label>incompatibleWith</rdfs:label>

  <rdf:type rdf:resource="#OntologyProperty"/>

  <rdfs:domain rdf:resource="#Ontology"/>

  <rdfs:range rdf:resource="#Ontology"/>

</rdf:Property>

<rdfs:Class rdf:ID="DeprecatedClass">

  <rdfs:label>DeprecatedClass</rdfs:label>

  <rdfs:subClassOf rdf:resource="&rdfs;Class"/>

</rdfs:Class>

<rdfs:Class rdf:ID="DeprecatedProperty">

  <rdfs:label>DeprecatedProperty</rdfs:label>

  <rdfs:subClassOf rdf:resource="&rdf;Property"/>

</rdfs:Class>

<rdfs:Class rdf:ID="DataRange">

  <rdfs:label>DataRange</rdfs:label>

</rdfs:Class>

</rdf:RDF>

附录 C. OWL 快速参考

§           <rdfs:Class rdf:ID="OperaList">

§             <rdfs:subClassOf rdf:resource="&rdf;List"/>

§             <rdfs:subClassOf>

§               <owl:Restriction>

§                 <owl:onProperty rdf:resource="&rdf;first"/>

§                 <owl:allValuesFrom rdf:resource="#Opera"/>

§               </owl:Restriction>

§             </rdfs:subClassOf>

§             <rdfs:subClassOf>

§               <owl:Restriction>

§                 <owl:onProperty rdf:resource="&rdf;rest"/>

§                 <owl:allValuesFrom rdf:resource="#OperaList"/>

§               </owl:Restriction>

§             </rdfs:subClassOf>

§           </rdfs:Class>

附录 E. OWL DL 本体的经验法则

“ OWL 语义和抽象语法”文档 [ OWL S&AS ] 从抽象语法以及到 RDF 的映射的角度提供了 OWL 本体的特性描述。

不要搞糟词汇表

提供显式的类型定义（ typing ）

x rdf:type owl:Class

类似地，如果一个属性 p 用在一个希望对象属性出现的地方，那么应该有一个三元组 ²

p rdf:type owl:ObjectProperty

如果一个属性 q 用在一个希望数据类型属性出现的地方，那么应该有一个三元组

q rdf:type owl:DatatypeProperty

如果一个属性 o 用在一个希望本体属性出现的地方，那么它应该要么是内置本体属性之一 ( owl:imports , owl:priorVersion , owl:backwardCompatibleWith , 和 owl:incompatibleWith ) ，要么有一个三元组：

o rdf:type owl:OntologyProperty

如果一个属性 a 用在一个希望注释属性出现的地方，那么它应该要么是内置注释属性之一（ owl:versionInfo , rdfs:label , rdfs:comment , rdfs:seeAlso 和 rdfs:isDefinedBy ）， 要么有一个三元组：

a rdf:type owl:AnnotationProperty

出现在本体中的任何个体都应该至少指定一个类型，即对于一个个体 i ，必须有一个三元组：

i rdf:type c

其中 c 是一个 owl:Class 或 owl:Restriction 。

保持名称的独立

x rdf:type owl:Class

x rdf:type owl:ObjectProperty

x rdf:type owl:Class

y rdf:type owl:Class

x rdf:type y

x rdf:type owl:Class

那么 x 不应该作为任何其他有谓词 rdf:type 的三元组的主体出现。 ³ 如果一个节点 x 有 rdf:type owl:Restriction ， 那么应该如下所示：

x rdfs:subClassOf y

那么该图就必须包含以下之一：

x rdf:type owl:Class

x rdf:type owl:Restriction.

以及以下之一

y rdf:type owl:Class

y rdf:type owl:Restriction.

p owl:equivalentProperty q

那么该图必须包含

p rdf:type owl:ObjectProperty

q rdf:type owl:ObjectProperty.

p rdf:type owl:DatatypeProperty

q rdf:type owl:DatatypeProperty.

布尔类表达式

<owl:Class>

 <owl:intersectionOf rdf:parseType="Collection">

  <owl:Class rdf:about="x"/>

  <owl:Class rdf:about="y"/>

 </owl:intersectionOf>

</owl:Class>

本体和注释属性

x rdf:type owl:Ontology

避免结构共享

x1 rdf:type owl:Class

x1 rdfs:subClassOf _:y

x2 rdf:type owl:Class

x2 rdfs:subClassOf _:y

_:y rdf:type owl:Class

_:y owl:complementOf z

避免孤立的空节点

OWL Lite

<owl:Class rdf:about="#A">

  <rdfs:subClassOf>

    <owl:Thing/>

  </rdfs:subClassOf>

</owl:Class>

<owl:Class rdf:about="#A">

  <rdfs:subClassOf>

    <owl:Class rdf:about="http://www.w3.org/2002/07/owl#Thing"/>

  </rdfs:subClassOf>

</owl:Class>

c rdf:type rdfs:Class

[1] 必须为任何事物进行类型定义的要求，当然不适用于来自 OWL, RDF 或 RDFS 命名空间的事物。

[2] 严格来讲，如果属性定义成一个 owl:TransitiveProperty , owl:SymmetricProperty 或 owl:InverseFunctionalProperty ，这就没有必要。

[3] 在这里一个例外是我们可以有：

x rdf:type rdfs:Class

x rdf:type owl:Class

p rdf:type rdf:Property

p rdf:type owl:ObjectProperty

q rdf:type rdf:Property

q rdf:type owl:DatatypeProperty

另外，对于限制，我们可以有：

x rdf:type owl:Restriction

x rdf:type rdfs:Class

x rdf:type owl:Class

附录 F. 自 PR 之后的变动日志

OWL Web Ontology Language Overview , Deborah L. McGuinness and Frank van Harmelen, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-features-20040210/ . Latest version available at http://www.w3.org/TR/owl-features/ .

[OWL Guide]