本文档《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日
OWL Web本体语言参考
W3C推荐标准 2004年2月10日
当前版本:
http://www.w3.org/TR/2004/REC-owl-ref-20040210/
最新版本:
上一版本:
http://www.w3.org/TR/2003/PR-owl-ref-20031215/
编者:
Mike
Dean, BBN Technologies
Guus Schreiber, Free University Amsterdam
贡献者:
Sean
Bechhofer, University of Manchester
Frank van Harmelen, Free University
Amsterdam
Jim Hendler, University of
Maryland
Ian Horrocks, University of
Manchester
Deborah L. McGuinness,
Stanford University
Peter F. Patel-Schneider,
Bell Labs Research, Lucent Technologies
Lynn Andrea Stein, Franklin W. Olin
College of Engineering
请参考本文的勘误表, 那里会有一些规范性的修正。
也可以查看相关翻译 。.
Copyright © 2004 W3C® （MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
摘要
Web本体语言OWL是一个语义标记语言，用于在万维网上发布和共享本体。OWL以RDF（资源描述框架）词汇扩展的形式开发，它源于DAML+OIL Web本体语言。本文档包含了对整套OWL语言结构的结构化的非形式化描述，目的是为想要构建OWL本体的OWL用户提供一个参考。
本文档的状态
本文档已经由W3C成员及其他兴趣组织审阅, 并已被W3C主管（W3C Director）批准为W3C推荐标准（W3C Recommendation）。W3C在制定推荐标准过程中担任的角色是使规范受到关注，并促使其被广泛应用。这将增强Web的功能性与互操作性。
本文档是W3C关于Web本体语言OWL的推荐标准的六个部分之一。它由Web本体工作小组开发，作为W3C语义Web行动（行动声明，小组章程）的一部分于2004年2月10日发布。
本文档的早期版本中所描述的关于OWL的设计已被广泛校阅，并已满足工作小组的技术需求。工作小组充分考虑了所有收到的意见，并做了必要的修改。本文档自从建议推荐标准版本以来的所有修改都详细列在文后的变动日志中。
欢迎通过public-webont-comments@w3.org（历史存档）提出您的意见，也可以通过www-rdf-logic@w3.org（历史存档）参与相关技术的一般讨论。
可以访问到有关实现的一个列表。
W3C维护着一个与这些工作相关的专利声明的目录。
这节描述了本文档在发布时的状态。其他文档可能替代该文档。当前W3C的最新出版物的目录和这个技术报告的最新版本在W3C技术报告索引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.引言
- 2. OWL文档
- 3. 类
- 4. 属性
- 5. 个体
- 6. 数据类型
- 7. 注释、本体头、导入和版本信息
- 8. OWL Full，OWL DL和OWL Lite
- 附录A：所有语言元素的索引
- 附录B：OWL的RDF Schema
- 附录C：OWL快速参考
- 附录D：相对于DAML+OIL的改变
- 附录E：OWL DL本体的经验法则
- 附录F：自PR之后的变动日志
- 参考文献
1. 引言
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）可用来得出未直接在单源表达的事实。
语义网的连接来自多源信息的能力是一个理想的、强大的特性，它可以用在许多应用中。但是合并来自多源数据的能力，加上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命名空间
http://www.w3.org/2002/07/owl#，
按照惯例与命名空间名称owl相关联。除了内置词汇，我们不建议本体使用来自此命名空间的名称。如果来自此命名空间的其他名称被使用，那么OWL工具制造者应该随时标记警告，但是应该以另外的方式继续正常使用。
2.3 MIME类型
Web本体工作组并没有要求OWL文档有一个单独的MIME类型。我们建议使用RDF核心工作组要求的MIME类型，即application/rdf+xml[RDF概念]，或者XML MIME类型application/xml代替。
至于文件扩展，我们建议使用.rdf或者.owl。
3. 类
类提供了一种根据相似的特征将资源分类的抽象机制。如同RDF类，每一个OWL类都与一组被称为类外延（class extension）的个体相关联。类外延中的个体被称作类的实例（instance）。一个类有与类外延有关但并不等同的内涵（底层概念）。因此，有相同类外延的两个类仍然可以是不同的类。
在本文档里出现的用词如“一类个体…”我们应该解读为“一个有着一个包含个体的类外延的类…”。
注意：在OWL Lite和OWL DL里，一个个体不能同时是一个类：类和个体的定义域不相交（属性和数据值也一样）。而OWL Full则对RDF Schema没有限制：一个类同时可以充当另外一个（元）类的实例。
OWL类通过“类运算式”（class descriptions）来描述，这一描述可以结合到“类公理”。我们首先描述类运算式，随后描述类公理。
3.1 类运算式
本文档（也包括“语义和抽象语法”文档）里使用的类运算式是用来描述类公理（“概述”和“指南”文档里非正式地称为类定义）的基本构建块的术语。一个类运算式这样描述一个OWL类：要么通过一个类名，要么通过指定一个未命名的匿名类的类外延。
OWL对类运算式做了六种类型区分：
第一种类型在描述类时使用了类名（句法上表示为一个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 基数约束
如同RDF，在OWL中，假定一个类的任何实例对于特定属性都可能有一个任意数目（0或多个）的值。基数约束的使用可以达到以下目的：使一个属性成为必备的（至少有一个），使一个属性只能有特定数量的值，或者使得一个属性不出现。OWL提供了三种结构来在类上下文内本地限制属性的基数。
注意：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:intersectionOf rdf:parseType="Collection">
<owl:Class>
<owl:oneOf rdf:parseType="Collection">
<owl:Thing rdf:about="#Tosca" />
<owl:Thing rdf:about="#Salome" />
</owl:oneOf>
</owl:Class>
<owl:Class>
<owl:oneOf rdf:parseType="Collection">
<owl:Thing rdf:about="#Turandot" />
<owl:Thing rdf:about="#Tosca" />
</owl:oneOf>
</owl:Class>
</owl:intersectionOf>
</owl:Class>
在上面的例子中，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包含了三种语言结构将类运算式结合成类公理：
rdfs:subClassOf允许声明一个类运算式的类外延是另一类运算式的类外延的子集。owl:equivalentClass允许声明一个类运算式有着和另外一个类运算式完全相同的类外延。owl:disjointWith允许声明一个类运算式的类外延和另一个类运算式的类外延没有共同成员。
在句法上，这三种语言结构都是有一个类运算式作为其定义域和值域的属性。我们将会在接下来的子章节中对这些属性做更详细的讨论。
此外，在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
AXIOM SCHEMA: class description owl:equivalentClass class description
一个类公理可能包含（多个）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的完整类的公理
AXIOM SCHEMA: named class description of type
2 (with owl:oneOf) or type 4-6
(with owl:intersectionOf, owl:unionOf or owl:complementOf
OWL允许用户通过指定枚举或集合运算符类型的类运算式名称来定义类公理。这种类公理为建立类成员定义了充分必要条件。一个例子：
<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> 这个公理的解释如下：类DaPonteOperaOfMozart的类外延完全由枚举定义。
这个类公理语义上等价于上一节中的包含了附加owl:equivalentClass声明的第一个歌剧例子。这一类型的公理也可以用owl:intersectionOf、owl:unionOf和owl:complementOf构造。一个使用并集的例子如下：
<owl:Class rdf:ID="LivingBeing"> <owl:unionOf rdf:parseType="Collection"> <owl:Class rdf:about="#Plant"/> <owl:Class rdf:about="#Animal"/> </owl:unionOf></owl:Class> 这个类公理声明了LivingBeing的类外延完全对应于Plant和Animal类外延的并集。
注意：OWL Lite只包括用owl:intersectionOf属性构造的这类公理。intersectionOf列表的值必须是类标识符和/或属性限制。因此，使用枚举、补集和并集的“完整类”公理不能在OWL Lite中使用。
3.2.4 owl:disjointWith
AXIOM SCHEMA: class description owl:disjointWith class description
一个类公理也许包含（多个）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对本体建造者可能想要定义的属性进行两大主要类别的区分：
- 对象属性（Object properties）链接个体到个体。
- 数据类型属性（Datatype properties）链接个体到数据值。
注意：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.1OWL Full特性。
属性公理定义一个属性的特征。一个属性公理在其最简单的形式中只定义一个属性的存在。例如：
<owl:ObjectProperty rdf:ID="hasParent"/>
这个例子定义了一个属性，限制条件为其值必须是个体。
属性公理常常会定义附加属性特征。OWL支持下面的属性公理结构：
- RDF
Schema结构：
rdfs:subPropertyOf，rdfs:domain和rdfs:range - 其他属性关系：
owl:equivalentProperty和owl:inverseOf - 全局基数约束：
owl:FunctionalProperty和owl:InverseFunctionalProperty - 逻辑属性特征：
owl:SymmetricProperty和owl:TransitiveProperty
在接下来的小节中，会更加详细地讨论各种类型的属性公理。
注意：在这一节中我们使用的术语“属性外延”类似于“类外延”。属性外延是与该属性相关的实例集合。属性的实例不是单一元素，而是属性声明的主-客体对。在关系数据库术语里，属性实例被称为二元关系（属性）的“元组”（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
如果一个属性声明为反函数型（inverse-functional），那么属性声明的客体唯一确定主体（某一个体）。更形式化地表述，如果我们声明P是一个owl:InverseFunctionalProperty，那么就可断言，值y只能是P的对于单个实例x的值，即不存在两个不同的实例x1和x2使得（x1,y）和（x2,y）都是P的实例。
在句法上，通过声明一个属性是内置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的一个实例来定义一个属性的传递性，这个内置类是OWLowl: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. 个体
个体都定义为个体公理（也称作“事实”（facts））。我们讨论两种类型的事实：
- 关于类成员和个体属性值的事实
- 关于个体同一性的事实
5.1 类成员和属性值
许多事实通常是表示个体类成员和个体属性值的声明。例如，我们考虑下面关于类Opera实例的一组声明：
<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 个体同一性
许多语言都有一个所谓的“唯一名称”假设：不同的名称指向世界上不同的事物。但在网络上，这一假设是不可能的。例如，同一个人可以通过多种不同方式提及（即有不同的URI引用）。为此，OWL没有作出这一假设。除非明确地声明两个URI引用指向相同或者不同个体，否则OWL工具应该原则上假定两种情况都有可能。
OWL提供了三个结构来表达个体同一性的事实：
owl:sameAs用来表达两个URI引用指向相同的个体。owl:differentFrom用来表达两个URI引用指向不同的个体。owl:AllDifferent提供一个术语来表达列表中的个体都不相同。
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声明表示两个URI引用指向不同的个体。
一个例子：
<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. 数据类型
我们在本文档的许多地方已经看到过数据值域的概念，用以指定一个数据值的范围。OWL允许三种类型的数据值域规范：
- RDF数据类型规范。
- RDFS类rdfs:Literal。
- 枚举数据类型，使用
owl:oneof结构。
在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属性指定，建议其值为下面列举之一：
- 对XML Schema数据类型的一个规范的URI引用：
· http://www.w3.org/2001/XMLSchema#NAME
“NAME”处应替换为简单XML Schema内置数据类型的名称，如同[XML Schema Datatypes]的Section 3中定义的那样，带有下面指定的附带条件。
- 数据类型
rdf:XMLLiteral的URI引用。这一数据类型用来把XML内容包含到一个RDF/OWL文档中。这一数据类型的URI引用是：
· http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral
有关这个数据类型的详情，请参见“RDF概念”文档[RDF Concepts]。
“RDF语义”文档[RDF Semantics，Section 5]推荐使用下面的简单内置XML Schema数据类型。
- 原始数据类型
xsd:string，再加上从xsd:string派生的下列数据类型：xsd:normalizedString、xsd:token、xsd:language、xsd:NMTOKEN、xsd:Name和xsd:NCName。 - 原始数据类型
xsd:boolean。 - 原始数值数据类型
xsd:decimal、xsd:float和xsd:double，再加上从xsd:decimal派生的所有类型（xsd:integer、xsd:positiveInteger、xsd:nonPositiveInteger、xsd:negativeInteger、xsd:nonNegativeInteger、xsd:long、xsd:int、xsd:short、xsd:byte、xsd:unsignedLong、xsd:unsignedInt、xsd:unsignedShort、xsd:unsignedByte）。 - 原始的与时间有关的数据类型：
xsd:dateTime、xsd:time、xsd:date、xsd:gYearMonth、xsd:gYear、xsd:gMonthDay、xsd:gDay和xsd:gMonth。 - 原始数据类型
xsd:hexBinary、xsd:base64Binary和xsd:anyURI。
注意：虽然我们不建议这么做，但应用程序通过定义rdfs:Datatype的一个实例来定义它们自己的数据类型并不非法。这样的数据类型是“未识别的数据类型”，但会以类似“不支持的数据类型”的方式来处理。（OWL工具应如何处理的更多细节参见Sec. 6.3）。
请注意，当使用数据类型时，即使一个属性定义为有某一数据类型值域，RDF/XML仍然要求每次使用该属性都要指定数据类型。我们在前面使用过的Measurement例子中的属性声明可以作为这里的一个示例：
<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>
6.2 枚举数据类型
除了RDF数据类型之外，OWL还提供了另外一个结构来定义数据值的范围，即枚举数据类型。此数据类型格式使用了owl:oneof结构，这个结构也可用来描述一个枚举类。在枚举数据类型的情况下，owl:oneof的主体是owl:DataRange类的一个空节点，客体是一个文本列表。可惜的是，我们不能使用术语rdf:parseType="Collection"来指定文本列表，因为RDF要求这个集合（collection）是一个RDF节点元素列表。因此，我们不得不使用基本列表结构rdf:first、rdf:rest和rdf:nil指定数据值列表。
注意：枚举数据类型不是OWL Lite的一部分。
下面的例子指定了属性tennisGameScore的范围是整数值列表{0, 15, 30, 40}：
<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>
6.3 对数据类型推理的支持
工具可能在对数据类型推理的支持方面有所不同。作为最低要求，工具必须支持对XML Schema数据类型xsd:string和xsd:integer的数据类型推理。OWL Full工具还必须要支持rdf:XMLLiteral。对于不支持的数据类型，词法相同的文本应该被视为相等，而词法不同的文本既不被视为相等也不被视为不等。无法识别数据类型的处理方式应该和不支持数据类型的处理方式一样。
7. 注释、本体头、导入和版本信息
7.1 注释
OWL Full没有对一个本体中的注释做任何约束。OWL DL允许注释类、属性、个体和本体头，但仅在下列情况下：
- 对象属性、数据类型属性、注释属性和本体属性集合必须互不相交。因此，在OWL DL中
dc:creator不能既是一个数据类型属性同时又是一个注释属性。 - 注释属性必须有一个显式的定义类型的三元组形式：
· AnnotationPropertyID rdf:type owl:AnnotationProperty .
- 注释属性一定不能用在属性公理中。因此，在OWL DL中我们不能为注释属性定义子属性或定义域/值域约束。
- 一个注释属性的客体必须是数据文本、URI引用或个体。
OWL预定义了五种注释属性，即：
owl:versionInfordfs:labelrdfs:commentrdfs:seeAlsordfs:isDefinedBy
OWL DL中注释属性合法使用的例子如下：
<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声明包含对另外一个本体的引用。它表明了包含本体是所引用本体的更高版本，但新版本不向后兼容。对于那些想要明确说明在没有检查是否需要更改的情况下文档不能升级到新版本的本体作者而言，此声明的使用是必要的。
除了RDF(S)模型理论给定的含义，owl:incompatibleWith在模型-理论语义中没有任何意义。
owl:incompatibleWith是以类owl:Ontology作为其定义域和值域的内置OWL属性。
注意：owl:incompatibleWith是owl:OntologyProperty的一个实例。
7.4.5 owl:DeprecatedClass和owl:DeprecatedProperty
过时是版本控制软件中常用的特性（例如，参见Java编程语言），它表示保留一个特定功能以便向后兼容的目的，但将来可能会逐步淘汰。在这里，一个特定标识符的类型可以是owl:DeprecatedClass或owl:DeprecatedProperty，其中owl:DeprecatedClass是rdfs:Class的子类，owl:DeprecatedProperty是rdf:Property的子类。让一个术语过时，意味着提交给本体的新文档里不应该使用该术语。这使得一个本体可以保持向后兼容性，同时逐步淘汰旧词汇（因此，过时与向后兼容性结合使用才有意义）。其结果是旧数据和应用程序更容易移植到新版本，因此可以提高新版本的采用程度。除了RDF(S)模型理论给定的含义，这在模型-理论语义中没有任何意义。然而，当检查OWL标记时程序编写工具可以用来向用户发出警告。
一个关于过时的例子：
<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 DL是OWL的子语言，它对OWL语言结构的使用做了许多限制。简要来讲，这些约束如下：
- OWL DL要求类、数据类型、数据类型属性、对象属性、注释属性、本体属性（即，导入和版本控制属性）、个体、数据值和内置词汇之间两两分离。这意味着，例如，一个类不能同时是一个个体。
- OWL DL中对象属性和数据类型属性集不相交。这意味着下面四个属性特征：
永远不能为数据类型属性指定。
- OWL DL要求不能对传递属性或它们的逆，或其父属性及父属性的逆进行基数约束（局部或全局）。
- 只允许在一定的条件下注释。详情参见Sec. 7.1。
- 大多数RDF(S)词汇不能在OWL DL中使用。更多详情参见“OWL语义和抽象语法”文档[OWL S&AS]。
- 所有公理必须格式良好，没有丢失或存在多余的成分，而且必须形成树状结构。
最后一个约束意味着人们引用的所有类和属性要分别显式地定型为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 DL针对OWL语言结构的使用而制定的限制。此外，OWL Lite将禁止使用：
OWL Lite还要求：
owl:equivalentClass三元组的主体是类名，owl:equivalentClass三元组的客体是类名或者限制；rdfs:subClassOf三元组的主体是类名，rdfs:subClassOf三元组的客体是类名或者限制；owl:intersectionOf只能用于长度大于1且只包含类名和限制的列表。
注意：这是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:allValuesFrom和owl:someValuesFrom三元组的客体是类名或者数据类型名；rdf:type三元组的客体是类名或者限制；rdfs:domain三元组的客体是类名；rdfs:range三元组的客体是是类名或者数据类型名。
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]。
|
[OWL
Reference] |
[OWL
Semantics] |
[OWL
Guide] |
|
|
||
|
|
||
|
|
||
附录B. OWL的RDF Schema
本附录目的的描述请参见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快速参考
OWL词汇表中的类:
|
rdfs:Class |
OWL词汇表中的属性:
|
rdf:Property |
rdfs:domain |
rdfs:range |
|
rdfs:Class |
||
|
xsd:nonNegativeInteger |
||
|
rdf:List |
||
|
rdf:Property |
rdf:Property |
|
|
rdf:List |
||
|
xsd:nonNegativeInteger |
||
|
xsd:nonNegativeInteger |
||
|
rdf:List |
||
|
rdf:Property |
||
|
rdfs:Class |
||
|
rdf:List |
||
附录D. 相对于DAML+OIL的改变
本节总结了从DAML+OIL [DAML+OIL] 到OWL的变化。
- 语义有重大改变。对于三个子语言而言，DAML+OIL的语义最接近OWL DL的语义。
- 命名空间改为 http://www.w3.org/2002/07/owl。
- 从 RDF Core Working Group 以来对RDF和RDF Schema的不同更新都被合并进来，包括
-
- 允许循环子类
- 多重
rdfs:domain和rdfs:range属性作为交集处理 - RDF语义 [RDF Semantics]
- 数据类型
-
- RDF和OWL使用XML Schema命名空间 http://www.w3.org/2001/XMLSchema 而不是 http://www.w3.org/2000/10/XMLSchema。
- OWL不支持将数据类型作为类型（types）使用，例如
§ <size>
§ <xsd:integer rdf:value="10"/>
§ </size>
而采用
<sizerdf:datatype="http://www.w3.org/2001/XMLSchema#integer">10</size>
-
- 用来表示闭集（closed collections）的
daml:List结构大部分并入RDF -
- rdf:parseType="Collection"
代替
rdf:parseType="daml:collection" rdf:List,rdf:first,rdf:rest和rdf:nil代替daml:List,daml:first,daml:rest和daml:nil- 不支持
daml:item。因为这个特性主要用来创建类型化列表，我们在这里包含了一个不使用daml:item创建这样一个列表的例子：
- rdf:parseType="Collection"
代替
- 用来表示闭集（closed collections）的
§ <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>
这个例子定义了一个列表，其元素大部分是歌剧。这通过两个限制来实现，一个针对rdf:first值（表示列表元素的类型），另一个针对rdf:rest值（它应该是被定义列表的名称）。
- 受限限制（qualified restrictions）被从该语言中删除, 导致以下属性的删除：
-
daml:cardinalityQdaml:hasClassQdaml:maxCardinalityQdaml:minCardinalityQ
- 许多属性和类被重命名，如下表所示：
|
DAML+OIL |
OWL |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
- 增加
owl:SymmetricProperty。 - 增加
owl:AnnotationProperty,owl:OntologyProperty和owl:DataRange。 - 在OWL
Full中一个
owl:DatatypeProperty可以是一个owl:InverseFunctionalProperty。 - RDF和RDF Schema的类和属性的同义词被从该语言中删除，导致以下删除：
-
daml:commentdaml:domaindaml:labeldaml:isDefinedBydaml:Literaldaml:Propertydaml:rangedaml:seeAlsodaml:subClassOfdaml:subPropertyOfdaml:typedaml:value
daml:disjointUnionOf被从该语言中删除，因为它可以使用owl:unionOf或rdfs:subClassOf和owl:disjointWith实现。daml:equivalentTo被重命名为owl:sameAs，并且不再是owl:equivalentClass和owl:equivalentProperty的父属性。- 加入以下属性和类以支持版本管理：
- 增加owl:AllDifferent 和owl:distinctMembers 处理唯一命名假设（Unique Names Assumption）。
附录E. OWL DL本体的经验法则
“OWL语义和抽象语法”文档 [OWL S&AS] 从抽象语法以及到RDF的映射的角度提供了OWL本体的特性描述。
以下规则给出了一个RDF图是一个DL本体的条件的非形式化特性描述。这并不是想要代替S&AS中给出的特性描述，而是想提供一些大体上的建议——想法就是如果你遵守这些法则，你就更容易创建一个OWL DL本体。给出这些规则也不是想告诉你如何把三元组表示转换成更接近于抽象语法的某种东西。
不要搞糟词汇表
内置的属性和类不应该重新定义。通常这意味着在OWL，RDF和RDFS命名空间中的东西不应该作为三元组的主体出现。
提供显式的类型定义（typing）
任何事物都应该有一个类型1。如果任一URI引用用在一个希望类出现的地方，那么该图应该包含一个三元组声明
x rdf:type owl:Class
类似地，如果一个属性p 用在一个希望对象属性出现的地方，那么应该有一个三元组2
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。
保持名称的独立
类、属性（对象，数据类型，本体和注释）以及个体的URI引用都应该是互斥的。因此我们不能有下面这样的东西：
x rdf:type owl:Classx rdf:type owl:ObjectProperty
特别地，这意味着我们不能把类用作实例，即
x rdf:type owl:Classy rdf:type owl:Classx rdf:type y
在OWL DL中是无效的。在这里一般规则是，如果在该图中存在一个节点x有三元组：
x rdf:type owl:Class
那么x不应该作为任何其他有谓词rdf:type的三元组的主体出现。3
限制
如果一个节点x有rdf:type owl:Restriction，那么应该如下所示：
- 它是一个空节点（即不具名）。
- 它不是任何其他谓词是
rdf:type的三元组的主体3。 - 它是仅仅一个谓词是
owl:onProperty的三元组的主体，该三元组的客体是一个owl:ObjectProperty或owl:DatatypeProperty。 - 它是仅仅一个以下三元组的主体：
-
- 有谓词
owl:someValuesFrom的三元组。在这种情况下，owl:onProperty三元组的客体的属性类型应该是适当的。这意味着如果这个三元组的客体是一个数据类型，这个属性就应该是一个owl:DatatypeProperty。如果这个客体是一个类运算式，该属性就应该是一个owl:ObjectProperty。这种类型定义信息应该展现出来（由于以上列出的限制）。 有谓词owl:allValuesFrom的三元组。类似的限制对owl:someValuesFrom也成立。- 有谓词
owl:hasValue的三元组。如果包含在owl:onProperty三元组中的属性的类型是owl:ObjectProperty，那么这个三元组的客体就应该是一个个体。如果包含在owl:onProperty三元组中的属性的类型是owl:DatatypeProperty，那么这个三元组的客体就应该是数据文本。 有谓词owl:minCardinality的三元组。这个三元组的客体应该是一个数据文本，表示一个非负整数。有谓词owl:maxCardinality的三元组。限制同owl:minCardinality。有谓词owl:cardinality的三元组。限制同owl:minCardinality。
- 有谓词
- 任何其他
x是其主体的三元组都应该有谓词owl:equivalentClass或owl:disjointWith。
类公理
对于任何有谓词rdfs:subClassOf或owl:equivalentClass或owl:disjointWith的三元组，其主体和客体都应该是一个owl:Class或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.
属性公理
对于任何有谓词rdfs:subPropertyOf或owl:equivalentProperty的三元组, 其主体和客体应该有同样的类型（owl:ObjectProperty或owl:DatatypeProperty之一）。即，如果有
p owl:equivalentProperty q
那么该图必须包含
p rdf:type owl:ObjectPropertyq rdf:type owl:ObjectProperty.
或
p rdf:type owl:DatatypePropertyq rdf:type owl:DatatypeProperty.
有谓词rdfs:domain的三元组应该有一个owl:ObjectProperty或owl:DatatypeProperty作为其主体，有一个owl:Class或owl:Restriction作为其客体。
有谓词rdfs:range的三元组应该有一个owl:ObjectProperty或owl:DatatypeProperty作为其主体。对于前者，其客体应该是一个owl:Class或owl:Restriction。对于后者，其客体应该是一个XML Schema类型，rdfs:Literal，或一个owl:oneof，指定类型为owl:DataRange的数据值域。
一个owl:inverseOf三元组的主体和客体都必须有类型owl:ObjectProperty。
个体公理
对于任何有谓词owl:sameAs或owl:differentFrom的三元组，其主体和客体都必须是个体。
注意：用owl:sameAs关联两个类与用owl:equivalentClass关联两个类是很不相同的事情。前者意味着这两个对象事实上是相同的，实际上是类作为实例的一个例子，从而将该本体推出OWL DL之外。 后者是一个断言：这两个类的外延（例如成员集合）是等同的。
类似地，用owl:differentFrom关联类与用owl:disjointWith关联类（又是一个OWL Full结构的例子）也不是一回事。两个类可以是不同的对象，但仍然共享相同的外延。
如果一个节点x有rdf:type owl:AllDifferent，那么应该如下所述：
- 它是一个空节点（即未具名）。
- 它是一个谓词是
owl:distinctMembers的三元组的主体，其客体应该是（良好构造的）rdf:List，其所有元素都是个体。 - 它不是任何其他三元组的主体（或客体）。
布尔类表达式
布尔运算符 (and, or, not) 在OWL中用owl:intersectionOf，owl:unionOf 和owl:complementOf来表示。
一个owl:complementOf三元组的主体必须是一个owl:Class，客体必须是一个owl:Class或owl:Restriction。
一个owl:unionOf或owl:intersectionOf三元组的主体必须是一个owl:Class，客体必须是一个（良好构造的）rdf:List，其所有元素都必须是 owl:Class或owl:Restriction。这可以显式地用扩展的rdf:Lists来表示，或者如果采用的是RDF-XML，则用一个rdf:parseType="Collection" 属性来表示。
<owl:Class> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="x"/> <owl:Class rdf:about="y"/> </owl:intersectionOf></owl:Class>
如果owl:Class是一个空节点（即这个类未具名），那么它可以只是最多一个有谓词owl:intersectionOf，owl:unionOf或owl:complementOf的三元组的主体。如果这个类是具名的，任意数量的这种三元组都是允许的。
枚举
有谓词owl:oneOf的任一三元组的主体都必须是一个owl:Class或owl:DataRange。对于前者，客体必须是一个（良好构造的）rdf:List，其所有元素都是个体。对于后者，客体必须是一个（良好构造的）rdf:List，其所有元素都是数据文本。当存在布尔运算符时，还是可以使用rdf:parseType="Collection"。
本体和注释属性
有一个本体谓词的任一三元组，其主体和客体都应该是一个本体，例如节点x 存在一个三元组：
x rdf:type owl:Ontology
有一个注释谓词的任一三元组，其主体应该是一个具名（即非空节点）类，一个属性，一个个体或一个本体。有一个注释谓词的三元组的客体应该是一个个体，一个数据文本或一个任意的URI引用。
作为OWL，RDF和RDFS词汇表中谓词的例外，注释属性是仅有的应该出现在有一个类或属性作为其主体的三元组中的谓词。
注释属性和本体属性本身应该是类型化的, 并且不应该作为三元组的主体或客体出现，除非是作为一个有谓词rdf:type或一个注释属性的三元组的主体出现。
避免结构共享
通常OWL的S&AS描述不允许RDF表示中存在结构共享（structure sharing）。这实际上意味着RDF图中表示一个特定描述的一个匿名节点应该只出现一次（作为一个三元组的客体）。因此，像：
x1 rdf:type owl:Classx1 rdfs:subClassOf _:yx2 rdf:type owl:Classx2 rdfs:subClassOf _:y_:y rdf:type owl:Class_:y owl:complementOf z
这样的东西应该避免。在一些棘手的角落情况下这是允许的。但是一般情况下，无论何时一个类运算式被用在多个地方，RDF图都应该使用不同的空节点。
避免孤立的空节点
通常情况下空节点出现在图中，要么表示未具名个体，要么应该是下述情况中的一种：
- 一个
rdfs:subClassOf,owl:equivalentClass,owl:disjointWith,owl:someValuesFrom,owl:allValuesFrom或rdf:type三元组的客体。 - 一个
rdf:type三元组的主体，客体是owl:AllDifferent。 - 一个
rdf:List中的一个元素。
孤立空节点（orphan blank nodes），即不是一个三元组的客体的空节点，通常是不允许的（除非是在上面描述的owl:AllDifferent情况下）。
基本事实
本体可以包含基本事实（ground facts）的断言（例如断言个体的属性的三元组）。用于这些断言的属性必须是一个owl:ObjectProperty或owl:DatatypeProperty。任何这种三元组的主体都必须是一个个体（应该是类型化的）。客体可以是对一个个体的引用（如果该属性是owl:ObjectProperty）或数据文本（如果该属性是owl:DatatypeProperty）。
OWL Lite
OWL Lite文档应该遵循与OWL DL文档相同的规则，另外还有许多额外限制，主要涉及允许使用的词汇。OWL Lite文档不应该使用以下任何一个词汇：
owl:unionOfowl:complementOfowl:oneOfowl:hasValueowl:disjointWith
有谓词owl:equivalentClass的三元组，作为其客体或主体的任何对象都不应该是空节点。
有谓词owl:minCardinality, owl:maxCardinality或owl:cardinality 的任何三元组的客体，都应该是一个数据文本，表示整数0或1。
在OWL Lite中涉及owl:intersectionOf 使用的情况稍微复杂些。这个谓词不应该用来构成任意的表达式，但是在表示完整类定义时是需要的。上述限制告诉我们，任何有谓词owl:intersectionOf的三元组的主体都应该是一个owl:Class。在OWL Lite中有更进一步的限制，这个类应该是具名的，即主体不能是空节点。
其他
要小心使用owl:Thing。例如，下面的OWL-RDF片断：
<owl:Class rdf:about="#A"> <rdfs:subClassOf> <owl:Thing/> </rdfs:subClassOf></owl:Class>
并没有描述类A是owl:Thing的子类，实际上描述了类A 是owl:Thing的某个匿名实例的子类。因此这是在把类用作实例，已超出了OWL DL的范围。所需的owl:Thing子类的效果可以通过：
<owl:Class rdf:about="#A"> <rdfs:subClassOf> <owl:Class rdf:about="http://www.w3.org/2002/07/owl#Thing"/> </rdfs:subClassOf></owl:Class>
来获得。要小心不要混淆owl:Class和rdfs:Class。由于没有给c一个合适的类型，下面这个不属于OWL DL。
c rdf:type rdfs:Class
注释
[1] 必须为任何事物进行类型定义的要求，当然不适用于来自OWL, RDF或RDFS命名空间的事物。
[2] 严格来讲，如果属性定义成一个owl:TransitiveProperty, owl:SymmetricProperty或owl:InverseFunctionalProperty，这就没有必要。
[3] 在这里一个例外是我们可以有：
x rdf:type rdfs:Classx rdf:type owl:Classp rdf:type rdf:Propertyp rdf:type owl:ObjectProperty
或
q rdf:type rdf:Propertyq rdf:type owl:DatatypeProperty
另外，对于限制，我们可以有：
x rdf:type owl:Restrictionx rdf:type rdfs:Classx rdf:type owl:Class
附录F. 自PR之后的变动日志
- 删除附录E中的似是而非的尾注[4]。
- 在Jacco van Ossenbruggen评注之后，在附录B(RDF Schema of OWL) 中给AnnotationProperty和OntologyProperty增加了rdfs:label元素。
- 修复断开的章节参考以及更正章节参考格式。
- 标准化参考文献章节。
- 在Minsu Jang评注之后，对rdf:RDF元素的需求描述进行了编辑修改。
- 针对Lacy所作的评论作了若干编辑修改。
- 在一些公开评注之后（例如，见Benjamin Nowack的评注），对Sec. 7.1中关于OWL DL对注释属性的使用的约束增加了解释性文字。也在Sec. 7.2 中增加了一个句子，指出同样的约束对本体属性也有效。
- 在编辑最后通读之后进行了若干小的编辑性更正。
参考文献
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 Web Ontology Language Guide, Michael K. Smith, Chris Welty, and Deborah L. McGuinness, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-guide-20040210/ . Latest version available at http://www.w3.org/TR/owl-guide/ .
[OWL Semantics and Abstract Syntax]
OWL Web Ontology Language Semantics and Abstract Syntax, Peter F. Patel-Schneider, Patrick Hayes, and Ian Horrocks, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-semantics-20040210/ . Latest version available at http://www.w3.org/TR/owl-semantics/ .
OWL Web Ontology Language Test Cases, Jeremy J. Carroll and Jos De Roo, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-test-20040210/ . Latest version available at http://www.w3.org/TR/owl-test/ .
OWL Web Ontology Language Use Cases and Requirements, Jeff Heflin, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-webont-req-20040210/ . Latest version available at http://www.w3.org/TR/webont-req/ .
Resource Description Framework (RDF): Concepts and Abstract Syntax, Graham Klyne and Jeremy J. Carroll, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/ . Latest version available at http://www.w3.org/TR/rdf-concepts/ .
RDF/XML Syntax Specification (Revised), Dave Beckett, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/ . Latest version available at http://www.w3.org/TR/rdf-syntax-grammar/ .
RDF Semantics, Pat Hayes, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/ . Latest version available at http://www.w3.org/TR/rdf-mt/ .
RDF Vocabulary Description Language 1.0: RDF Schema, Dan Brickley and R. V. Guha, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-schema-20040210/ . Latest version available at http://www.w3.org/TR/rdf-schema/ .
[DAML+OIL]
DAML+OIL (March 2001) Reference
Description. Dan Connolly, Frank van Harmelen, Ian Horrocks, Deborah L.
McGuinness, Peter F. Patel-Schneider, and Lynn Andrea Stein. W3C Note 18
December 2001. Latest version
is available at http://www.w3.org/TR/daml+oil-reference.
XML Schema Part 2: Datatypes - W3C Recommendation, World Wide Web Consortium, 2 May 2001.