W3C公司

OWL 2 Web本体语言
底漆（第二版）

W3C建议2012年12月11日

此版本：
http://www.w3.org/TR/2012/REC-owl2-primer-20121211/
最新版本（系列2）：
http://www.w3.org/TR/oll2-primer网站/
最新建议：
http://www.w3.org/TR/owl-primer网站
以前的版本：
http://www.w3.org/TR/2012/PER-owl2-primer-20121018/
编辑：
帕斯卡·希茨勒，莱特州立大学
马库斯·克罗奇，牛津大学
比扬·帕西娅曼彻斯特大学
Peter F.Patel-Schneider，Nuance Communications公司
塞巴斯蒂安·鲁道夫，FZI信息技术研究中心

请参阅勘误表对于本文件，可能包括一些规范性更正。

一个本文档的彩色编码版本，显示自上一版本以来所做的更改也可以使用。

本文件也有以下非标准格式：PDF版本.

另请参见翻译.

版权© 2012W3C公司®(麻省理工学院,ERCIM公司,庆应义塾)，保留所有权利。W3C公司责任,商标和文件使用规则适用。

摘要

OWL2 Web本体语言，非正式地称为OWL2，是一种具有正式定义含义的语义Web本体语言。OWL2本体提供类、属性、个体和数据值，并存储为语义Web文档。OWL2本体可以与用RDF编写的信息一起使用，OWL2实体本身主要作为RDF文档交换。OWL 2文档概述描述了OWL 2的总体状态，应在阅读其他OWL 2中的文档之前阅读。

这本初级读物为OWL 2提供了一个平易近人的介绍，包括来自其他学科的方向，一个运行示例，展示了如何使用OWL 2中首先表示简单信息，然后表示更复杂的信息，OWL-2如何管理本体，最后是OWL的不同子语言之间的区别。

本文件的状态

可能被取代

本节描述了本文档发布时的状态。其他文件可能取代本文件。当前W3C出版物列表和本技术报告的最新版本可在W3C技术报告索引在http://www.w3.org/TR/。

变更摘要

一直没有实质性的自早期版本有关次要更改的详细信息，请参阅更改日志和颜色编码差异.

请发送评论

请将任何意见发送至public-owl-comments@w3.org(公众的档案文件). 虽然本文档由OWL工作组已完成，可以在勘误表或在将来的修订中。欢迎开发人员在public-owl-dev@w3.org(公共档案馆).

W3C认可

本文档已由W3C成员、软件开发人员、其他W3C团体和相关方进行了审查，并由董事批准为W3C推荐标准。这是一份稳定的文件，可以用作参考材料或从其他文件中引用。W3C在制定建议中的作用是提请人们注意该规范并促进其广泛部署。这增强了Web的功能和互操作性。

专利

本文件由一个在2004年2月5日W3C专利政策。本文件仅供参考。W3C维护了一个任何专利披露的公开列表与集团的可交付成果相关；该页还包括披露专利的说明。

目录



1引言

W3C OWL 2 Web本体语言（OWL）是一种语义Web语言，旨在表示关于事物、事物组和事物之间关系的丰富而复杂的知识。OWL是一种基于计算逻辑的语言，计算机程序可以对OWL中表示的知识进行推理，以验证该知识的一致性或使隐含知识显式。OWL文档，称为本体，可以在万维网上发布，并且可以引用或引用其他OWL本体。OWL是W3C的一部分语义Web技术堆栈，包括RDF[RDF概念]和SPARQL[SPARQL公司].

初级读物的主要目标是帮助深入了解OWL及其优势和劣势。初级读本的核心是通过一个运行示例介绍OWL的大多数语言特性。初级读物中的大多数示例都取自一个示例本体（在附录). 这个示例本体旨在以一种可理解的方式触及OWL的关键语言特性，而不是作为一个好的本体的例子。

1.1本文件指南

本文档旨在提供对OWL2的初步了解。特别是，对于不熟悉这个主题的人来说，它应该是可以访问的。因此，我们首先在第2节之前第3节提供了知识表示中的一些非常基本的概念，并解释了它们如何与OWL 2中使用的术语相关。熟悉知识表示和推理的读者可能只需浏览本节内容，以熟悉OWL 2术语。

第4-8节描述了OWL提供的大多数语言功能，从非常基本的功能开始，一直到更复杂的功能。第4节介绍并讨论了OWL 2在第5节引入了复杂类。第6节介绍属性的高级建模功能。第7节重点关注与数据类型相关的高级建模。第8节最后介绍了主要用于本体管理目的的非逻辑特性。

在第9节我们讨论了OWL的两个语义视图OWL 2 DL和OWL 2Full之间的差异，而在第10节我们描述了OWL2的三种易处理的子语言，称为profiles。OWL 2的工具支持在第11节和中第12节在非正式介绍OWL 2之后，我们给出了继续阅读的方向。

最后，第13节列出了本文档中使用的完整本体示例。

有关OWL 2语言功能的全面列表，请参阅《OWL 2中快速参考指南》[OWL 2快速指南]它提供了指向相应文档中有关语法和示例的相应部分的链接。

面向已经熟悉OWL 1、OWL 2新功能和基本原理的读者[OWL 2新功能和原理]全面概述了OWL 2中发生的变化。

1.2 OWL语法

OWL是一种用于语义Web的语言，因此OWL中的名称是国际资源标识符（IRI）[副本请求3987]. 由于IRI很长，我们经常使用缩写机制在OWL中编写它们。此类缩写的工作方式特定于可用于编码OWL本体的每种语法格式，但本文档中的示例通常可以在不了解这些细节的情况下理解。命名空间和相关机制的适当声明在下文中进一步给出第8.2条。

OWL有多种语法，可用于各种目的。Functional-Style语法[OWL 2规范]旨在更容易实现规范目的，并为OWL 2工具（如API和推理器）的实现提供基础。OWL的RDF/XML语法只是RDF/XML，对OWL结构有一个特殊的翻译[OWL 2 RDF映射]. 这是所有OWL 2工具必须支持的唯一语法。曼彻斯特语法[OWL 2曼彻斯特语法]是一种OWL语法，旨在让非逻辑学家更容易阅读。OWL XML语法是由XML模式定义的OWL的XML语法[OWL 2 XML].有一些工具可以在OWL的不同语法之间进行转换。在许多语法形式中，OWL语言结构也由IRI表示，如示例所示，使用缩写形式可能需要一些声明。有关必要的详细信息，请参阅第8.2条。

附录中的示例和示例本体可以看作是四种不同语法中的任意一种，我们同时提供RDF/XML[RDF语法]和海龟[乌龟]基于RDF的语法的序列化。您可以使用下面的按钮控制文档中显示的语法。

下面的按钮可用于显示或隐藏可用的语法。

2什么是OWL 2？

OWL 2是一种表达本体.术语本体论计算机科学内外都有着复杂的历史，但我们用它来表示某种计算工件，即类似于程序、XML模式或网页的东西，通常以文档的形式呈现。本体是关于世界某一部分的一组精确的描述性陈述（通常称为感兴趣的领域或主题本体论）。精确的描述满足了几个目的：最显著的是，它们防止了人类交流中的误解，并确保软件以统一、可预测的方式运行，并与其他软件一起良好工作。

为了准确描述感兴趣的领域，提出一组中心术语（通常称为词汇）并确定其含义是很有帮助的。除了简明的自然语言定义外，一个术语的含义还可以通过说明这个术语与其他术语的相互关系来表征。一个术语，提供词汇表以及此类相互关系信息是典型OWL 2文档的重要组成部分。除了术语知识之外，本体还可能包含所谓的断言知识，用于处理所考虑领域的具体对象，而不是一般概念。

OWL2不是一种编程语言：OWL2是声明的也就是说，它以一种合乎逻辑的方式描述了一种事态。然后，可以使用适当的工具（所谓的推理器）来推断有关该事态的进一步信息。如何在算法上实现这些推论不是OWL文档的一部分，而是取决于具体的实现。然而，任何此类问题的正确答案都是由形式语义预先决定的（形式语义有两种版本：直接语义学[OWL 2直接语义]和基于RDF的语义[基于OWL 2 RDF的语义])。只有符合这些语义的实现才会被视为符合OWL 2（参见[OWL 2合规性])。通过其声明性质，创建OWL2文档的活动在概念上不同于编程。尽管如此，由于在这两种情况下都创建了复杂的正式文档，软件工程中的某些概念可以转移到本体工程中，例如方法和协作方面、模块化、模式等。

OWL 2不是用于语法一致性的模式语言。与XML不同，OWL 2没有提供详细的方法来规定文档的语法结构。特别是，没有办法强制要求某条信息（如个人的社会保险号）必须在语法上存在。应该记住这一点，因为OWL有一些用户可能会误解的功能。

OWL2不是一个数据库框架。诚然，OWL2文档存储信息，数据库也是如此。此外，可以在断言信息和数据库内容以及术语信息和数据库图式之间进行某种类比。然而，通常在基本假设（技术上：使用的语义）中存在关键差异。如果数据库中不存在某些事实，则通常认为它是错误的（所谓的封闭世界假设)而在OWL 2文档的情况下，它可能只是丢失了（但可能是真的）开放世界假设此外，数据库模式通常带有上述规定的约束语义。然而，从技术上讲，数据库在许多面向本体的系统中提供了一个可行的主干。

3建模知识：基本概念

OWL 2是一种知识表示语言，旨在制定、交换和推理有关感兴趣领域的知识。应该首先解释一些基本概念，以理解OWL 2中知识是如何表示的。这些基本概念是：

虽然OWL 2旨在获取知识，但OWL所代表的那种“知识”当然并不反映人类知识的所有方面。OWL可以被认为是一种强大的通用建模语言，用于人类知识的某些部分。建模过程的结果称为本体–这一术语也有助于避免混淆，因为“模型”一词在知识表示中的使用意义往往截然不同。

现在，为了明确地表述知识，假设它由通常被称为声明或命题“下雨了”或“每个人都会死”之类的语句是这些基本命题的典型例子。事实上，每一个OWL2本体本质上都只是这些基本“知识片段”的集合公理在OWL 2中，本体论断言其公理是正确的。一般来说，考虑到某种情况，OWL声明可能是对的，也可能是错的。这使他们区别于实体和表达如下所述。

当人类思考时，他们从知识中得出结果。OWL的一个重要特征是，它以其能够表示的知识形式捕捉人类智能的这一方面。但一般来说，一个陈述是其他陈述的结果，这意味着什么呢？从本质上讲，这意味着无论其他语句是什么，此语句都是正确的。在OWL术语中：我们说，一组语句一个 需要一个声明一如果在任何情况下一个也是真的一是真的。此外，一组语句可能是一致的（即，存在一种可能的情况，在这种情况下，集合中的所有陈述都是正确的）或不一致的（没有这种情况）。OWL的形式语义从本质上规定了一组特定的OWL语句对哪些可能的“事件状态”是正确的。

有OWL工具——推理器——可以自动计算结果。本体论公理相互作用的方式可能非常微妙，人们很难理解。这是OWL 2的优点和缺点。这是一个优势，因为OWL2工具可以发现人们不会发现的信息。这使知识工程师能够更直接地建模，并使系统能够对建模提供有用的反馈和评论。这是一个弱点，因为人类很难立即预见各种结构在各种组合中的实际效果。工具支持可以改善这种情况，但成功的知识工程通常仍需要一些培训和经验。

仔细看一下OWL中的语句，我们发现它们很少是“整体的”，但更常见的是具有一些可以显式表示的内部结构。他们通常指的是世界上的物体，并对其进行描述，例如将其分类（如“玛丽是女性”）或谈论他们的关系（“约翰和玛丽结婚了”）。语句的所有原子成分，无论是对象（约翰、玛丽）、类别（女性）还是关系（已婚）都被称为实体在OWL 2中，我们将对象表示为个人，分类为类和关系属性。OWL 2中的属性被进一步细分。对象属性将对象与对象相关联（例如一个人与其配偶），而数据类型属性给对象分配数据值（比如给人分配年龄）。批注属性用于编码本体本身（部分）的信息（如公理的作者和创建日期），而不是感兴趣的领域。

作为OWL的一个中心功能，实体的名称可以组合为表达使用所谓的施工人员作为一个基本的例子，原子类“female”和“professor”可以结合起来描述女教授的班级。后者将由OWL类表达式描述，可以在语句或其他表达式中使用。从这个意义上说，表达式可以看作是由其结构定义的新实体。在OWL中，每种实体的构造函数差别很大。类的表达式语言非常丰富和复杂，而属性的表达式语言则少得多。这些差异既有历史原因，也有技术原因。

4类、属性和个人–及其基本建模

在这些一般考虑之后，我们现在讨论OWL2建模的细节。在接下来的部分中，我们介绍了OWL2提供的基本建模功能，提供了示例，并对如何使用这些功能给出了一些一般性评论。我们从任何建模语言中基本可用的基本特性开始，到更高级的构造。

因此，我们将提供有关特定家庭的信息。请注意，我们没有希望此示例能够代表OWL应该使用的域类型或作为OWL良好建模或正确表示的典型示例家庭领域相当复杂、多变、文化依赖。相反，我们打算将其作为OWL各种特性的一个相当简单的展示。

4.1类和实例

我们首先介绍我们正在谈论的人。可按以下方式进行：

功能-样式语法
ClassAssertion（：人员：Mary）
RDF/XML语法
<人物rdf:about=“Mary”/>
Turtle语法
：Mary rdf：类型：个人。
曼彻斯特语法
个人：Mary类型：人
OWL/XML语法
<类断言><Class IRI=“个人”/><Named个人IRI=“玛丽”/></ClassAssertion>


这句话谈到一个叫玛丽的人，并说这个人是一个人。从技术上讲，作为一个人通过陈述Mary属于班所有人。通常，类用于将具有共同点的个人分组，以便引用他们。因此，类本质上代表个体的集合。在建模中，类通常用于表示由人类思维概念组成的对象集，如概念人或概念女人.因此，我们可以用同样的说法来表明玛丽是一个女人，表示她是一个女性的例子：

功能-样式语法
课堂断言（：女人：玛丽）
RDF/XML语法
<女人rdf:about=“玛丽”/>
Turtle语法
：Mary rdf：类型：女人。
曼彻斯特语法
个人：Mary类型：女性
OWL/XML语法
<类断言><IRI级=“女性”/><Named个人IRI=“玛丽”/></ClassAssertion>

由此也可以清楚地看到，阶级成员身份并不是唯一的：因为对群体个人来说可能有不同的标准（如性别、年龄、鞋码等），一个人很可能同时属于几个类别。

4.2等级结构

在上一节中，我们讨论了两个类：所有人的类和所有女性的类。对人类读者来说，很明显这两类人处于一种特殊的关系中：人比女人更普遍，也就是说，只要我们知道某个人是女人，那个人就一定是人。然而，这种对应关系不能从“人”和“女人”的标签中派生出来，而是关于世界和我们对这些术语的使用的人类背景知识的一部分。因此，为了使系统能够得出所需的结论，必须将此对应关系告知系统。 在OWL 2中，这是通过所谓的子类公理实现的：

功能-样式语法
SubClassOf（：女人：人）
RDF/XML语法
<owl:Class rdf:about=“Woman”><rdfs:subClassOf rdf:resource=“Person”/></owl:Class>
Turtle语法
：Woman rdfs:subClassOf:Person。
曼彻斯特语法
班级：女性SubClassOf:个人
OWL/XML语法
<子类><IRI级=“女性”/><Class IRI=“个人”/></SubClassOf>

这个公理在本体论中的存在使推理者能够为每个被指定为“女人”类实例的个体推断，它也是“人”类的实例。根据经验法则，如果短语“每个a都是B”有意义且正确，则可以指定两个类a和B之间的子类关系。

在本体建模中，使用子类语句不仅偶尔声明这种相互依赖性，而且对整体建模是很常见的类层次通过指定所有类的泛化关系在感兴趣的领域。假设我们还想声明所有母亲都是女性：

功能-样式语法
SubClassOf（：母亲：女人）
RDF/XML语法
＜owl:Class rdf:about=“母亲”＞<rdfs:subClassOf rdf:resource=“Woman”/></owl:Class>
Turtle语法
：母亲rdfs:subClassOf：女人。
曼彻斯特语法
班级：母亲SubClassOf:女性
OWL/XML语法
<子类><IRI类=“母亲”/><IRI级=“女性”/></SubClassOf>

然后，推理者不仅可以为每一个被归类为母亲的个体推导出它也是一个女人（因此也是一个人），而且母亲必须是人的一个子类——这与我们的直觉一致。从技术上讲，这意味着类之间的子类关系是传递的。除此之外反射的，这意味着每个类都是它自己的子类-这也是直观的，因为很明显，每个人都是一个人等等。

我们词汇表中的类可能有效地引用相同的集合，并且OWL提供了一种机制，通过该机制可以将它们视为语义上等价。例如，我们使用术语“人”和“人”可以互换，这意味着类Person的每个实例类Human的实例，反之亦然。如果两个类包含完全相同的个体，则认为它们是等价的。下面的示例说明类Person等同于类Human。

功能-样式语法
等价类（：人：人）
RDF/XML语法
＜owl:Class rdf:about=“Person”＞<owl:equivalentClass rdf:resource=“Human”/></owl:Class>
Turtle语法
：个人猫头鹰：等价类：人类。
曼彻斯特语法
班级：人等效于：人类
OWL/XML语法
<等价类><Class IRI=“个人”/><IRI=“人类”/>类</等价类>

指出Person和Human是等价的，这与说明Person是Human的子类，Human是Person的子类完全相同。

4.3课堂脱节

在第4.1节中，我们说明了个人可以是多个类的实例。然而，在某些情况下，属于一个类明确排除在另一个组织中的成员资格。例如，如果我们考虑“男人”和“女人”这两个类，我们知道没有一个人可以同时属于这两个类别（为了这个例子，我们忽略了生物学上的边界案例）。类之间的这种“不兼容关系”被称为（阶级）分离。同样，两个类不相交的信息是我们背景知识的一部分，必须明确说明，以便推理系统使用它。如下所示：

功能-样式语法
脱课（女：男）
RDF/XML语法
<owl:AllDisjointClasss><owl:members rdf:parseType=“Collection”><owl:Class rdf:about=“Woman”/><owl:Class rdf:about=“Man”/></owl:成员></owl:AllDisjointClasss>
Turtle语法
[]rdf：类型owl:AllDisjointClasss；猫头鹰：成员（：女人：男人）。
曼彻斯特语法
DisjointClasses：女性、男性
OWL/XML语法
<分离类><IRI级=“女性”/><IRI=“Man”类/></DisjointClasss>

实际上，不相交语句常常被遗忘或忽略。有争议的原因可能是，直觉上，类被认为是不相交的，除非有其他证据。通过省略不相交语句，可能会丢失许多潜在的有用结果。注意，在我们的例子中，需要不相交公理来推断玛丽不是男人。此外，根据上述公理，推理机可以推断出类Mother和man的不相交。

4.4对象属性

在前面的部分中，我们关注的是描述单个个体、它们的类成员身份，以及类如何基于它们的实例相互关联。但通常情况下，本体也意味着指定个体与其他个体之间的关系。在描述家庭时，这些关系至关重要。 我们首先指出玛丽是约翰的妻子。

功能-样式语法
ObjectPropertyAssertion（：has妻子：约翰：玛丽）
RDF/XML语法
<rdf:描述rdf:about=“John”><hasWife rdf:resource=“玛丽”/></rdf:描述>
Turtle语法
：约翰：有妻子：玛丽。
曼彻斯特语法
个人：John事实：有妻子玛丽
OWL/XML语法
<对象属性断言><ObjectProperty IRI=“hasWife”/><NamedIndividual IRI=“约翰”/><Named个人IRI=“玛丽”/></ObjectPropertyAssertion>

因此，描述个体之间关系的实体，如我们案例中的妻子，被称为属性。

请注意，个人的书写顺序很重要。虽然“玛丽是约翰的妻子”可能是真的，但“约翰是玛丽的妻子”肯定不是。事实上，这是建模错误的常见来源，可以通过使用只允许一种独特的直观阅读的属性名称来避免。对于名词（如“妻子”），这种明确的名称可能是带有“of”或“has”（wifeOf或hasWife）的结构。对于动词（如“to-love”），屈折形式（loves）或带有“by”（lovedBy）的被动形式会阻止无意中的阅读。

我们还可以说，两个人不通过属性连接。例如，以下声明玛丽不是比尔的妻子。

功能-样式语法
否定对象属性断言（：hasWife：Bill：Mary）
RDF/XML语法
<owl:NegativePropertyAssertion><owl:sourceIndividual rdf:resource=“Bill”/><owl:assertionProperty rdf:resource=“hasWife”/><owl:target个人rdf:resource=“Mary”/></owl:NegativePropertyAssertion>
Turtle语法
[]rdf：类型owl:NegativePropertyAssertion；owl:source个人：比尔；owl:assertionProperty:hasWife；猫头鹰：目标个人：玛丽。
曼彻斯特语法
个人：账单事实：玛丽太太没有
OWL/XML语法
<否定对象属性断言><ObjectProperty IRI=“hasWife”/><Named个人IRI=“账单”/><Named个人IRI=“玛丽”/></NegativeObjectPropertyAssertion>

否定的财产主张提供了一个独特的机会我们知道一些不真实的事情的陈述。这种类型的在默认立场为任何事情都有可能，除非你另有说法。

4.5财产等级

在第4.2节中，我们认为指定一个类成员意味着另一个类是有用的。从本质上讲，同样的情况也可能发生在房产上：只要知道B是A的妻子，就知道它也是A的配偶（请注意，反之亦然）。OWL允许如下指定此语句：

功能-样式语法
子对象属性（：hasWife:hasSpouse）
RDF/XML语法
<owl:ObjectProperty rdf:about=“hasWife”><rdfs:subPropertyOf rdf:resource=“hasSpouse”/></owl:ObjectProperty>
Turtle语法
：hasWife rdfs：subPropertyOf：hasSpouse。
曼彻斯特语法
对象属性：hasWife子财产：hasSpouse
OWL/XML语法
<子对象属性><ObjectProperty IRI=“hasWife”/><ObjectProperty IRI=“hasSpouse”/></SubObjectPropertyOf>

属性等价还有一个语法捷径，类似于类等价。

4.6领域和范围限制

通常情况下，两个人通过某种属性相互关联的信息可以得出关于个人本身的进一步结论。特别是，可以推断出类成员身份。例如，B是A的妻子的说法显然意味着B是女人，而A是男人。因此，在某种程度上，两个人通过某种财产有联系的说法隐含着关于这些人的额外信息。在我们的示例中，这个附加信息可以通过类成员关系来表示。OWL提供了一种说明此通信的方法：

功能-样式语法
ObjectPropertyDomain（：hasWife:男子）ObjectPropertyRange（：有妻子：女人）
RDF/XML语法
<owl:ObjectProperty rdf:about=“hasWife”><rdfs:domain rdf:resource=“Man”/><rdfs:range rdf:resource=“Woman”/></owl:ObjectProperty>
Turtle语法
：hasWife rdfs：域：男子；rdfs:range：女人。
曼彻斯特语法
对象属性：hasWife领域：Man范围：女性
OWL/XML语法
<对象属性域><ObjectProperty IRI=“hasWife”/><IRI=“Man”类/></ObjectPropertyDomain><对象属性范围><ObjectProperty IRI=“hasWife”/><IRI级=“女性”/></ObjectPropertyRange>

有了这两个公理，并且给出了萨莎通过财产hasWife与希拉里相关的信息，推理者就可以推断萨莎是一个男人，希拉里是一个女人。

4.7个人的平等和不平等

请注意，从目前所提供的信息可以推断出，约翰和玛丽不是同一个人，因为他们分别是不相交的类“男人”和“女人”的实例。然而，如果我们添加关于另一个家庭成员的信息，比如说比尔，并表明他是一个男人，那么到目前为止还没有任何消息表明约翰和比尔不一样。OWL并没有假设不同的名字代表不同的个人。（这种缺乏必要的“唯一名称假设”的情况特别适合于语义Web应用程序，在这些应用程序中，不同的组织可能会在不同的时间无意中创造名称来指代同一个人。） 因此，如果我们想排除约翰和比尔是同一个人的选择，必须明确规定如下：

功能-样式语法
不同的个人（：约翰：比尔）
RDF/XML语法
<rdf:描述rdf:about=“John”><owl:differentFrom-rdf:resource=“Bill”/></rdf:描述>
Turtle语法
：John owl：不同于：Bill。
曼彻斯特语法
个人：John不同于：比尔
OWL/XML语法
<不同的个人><NamedIndividual IRI=“约翰”/><Named个人IRI=“账单”/></不同的个人>

也可以说，两个名字是指（表示）同一个人。例如，我们可以说詹姆斯和吉姆是同一个人。

功能-样式语法
同一个人（：詹姆斯：吉姆）
RDF/XML语法
<rdf:描述rdf:about=“James”><owl:sameAs-rdf:resource=“Jim”/></rdf:描述>
Turtle语法
詹姆斯·奥勒：相同As：吉姆。
曼彻斯特语法
个人：JamesSameAs:吉姆
OWL/XML语法
<同一个人><Named个人IRI=“James”/><Named个人IRI=“Jim”/></同一个人>

这将使推理者能够推断出，关于詹姆斯个人的任何信息也适用于吉姆个人。

4.8数据类型

到目前为止，我们已经看到了如何通过类成员身份和他们与其他个人的关系来描述个人。然而，在许多情况下，个人需要用数据值来描述。想想一个人的出生日期、年龄、电子邮件地址等。为此，OWL提供了另一种属性，即数据类型属性。这些属性将个人与数据值（而不是其他个人）以及许多XML架构数据类型相关联[XML架构数据类型]可以使用。 下面是使用数据类型属性的示例。它说约翰的年龄是51岁。

功能-样式语法
DataPropertyAssertion（：hasAge:John“51”^^xsd:integer）
RDF/XML语法
<人物rdf:about=“John”><hasAge rdf:数据类型=“http://www.w3.org/2001/XMLSchema#integer“>51</hasAge></人>
Turtle语法
：约翰：五十一岁。
曼彻斯特语法
个人：John事实：hasAge“51”^^xsd:integer
OWL/XML语法
<数据属性断言><DataProperty IRI=“hasAge”/><NamedIndividual IRI=“约翰”/><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer“>51</文字></DataPropertyAssertion>

同样，我们可以说杰克的年龄是不53

功能-样式语法
否定数据属性断言（：hasAge:Jack“53”^^xsd:integer）
RDF/XML语法
<owl:NegativePropertyAssertion><owl:sourceIndividual rdf:resource=“Jack”/><owl:assertionProperty rdf:resource=“hasAge”/><owl:targetValue rdf:datatype=“http://www.w3.org/2001/XMLSchema#integer">53</owl:targetValue></owl:NegativePropertyAssertion>
Turtle语法
[]rdf：类型owl:NegativePropertyAssertion；owl：源个人：Jack；owl:assertionProperty:hasAge；owl:targetValue 53。
曼彻斯特语法
个人：Jack事实：not hasAge“53”^^xsd:integer
OWL/XML语法
<否定数据属性断言><DataProperty IRI=“hasAge”/><Named个人IRI=“杰克”/><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer“>53</文字></NegativeDataPropertyAssertion>

也可以为数据类型属性声明域和范围，就像对对象属性那样。然而，在这种情况下，范围将是数据类型而不是类。以下说明hasAge属性仅用于将人员与非负整数关联。

功能-样式语法
DataPropertyDomain（：hasAge:个人）DataPropertyRange（：hasAge xsd:nonNegativeInteger）
RDF/XML语法
<owl:DatatypeProperty rdf:about=“hasAge”><rdfs:domain rdf:resource=“Person”/><rdfs:range rdf:resource=“http://www.w3.org/2001/XMLSchema#nonNegativeInteger"/></owl:DatatypeProperty>
Turtle语法
：hasAge rdfs:domain:Person；rdfs:range xsd:nonNegativeInteger。
曼彻斯特语法
数据属性：hasAge域：个人范围：xsd:nonNegativeInteger
OWL/XML语法
<数据属性域><DataProperty IRI=“hasAge”/><Class IRI=“个人”/></DataPropertyDomain><数据属性范围><DataProperty IRI=“hasAge”/><数据类型IRI=“http://www.w3.org/2001/XMLSchema#nonNegativeInteger"/></DataPropertyRange>

在这个阶段，我们想指出一个在使用属性域和范围时容易发生的常见错误。在刚刚给出的示例中，hasAge属性仅用于将人与非负整数联系起来，假设我们还指定了Felix在Cat类中以及Felix hasAge9的信息。根据综合信息，可以推断Felix也在Person类中，这可能不是有意的。这是一个常见的建模错误：请注意，域（或范围）语句不是对知识的约束，而是允许推理者推断进一步的知识。如果我们声明——就像我们的例子一样——一个年龄只给人，那么我们给的所有年龄都会自动成为一个人。

5高级班级关系

在前面的小节中，我们已经将类处理为带有名称的“不透明”类。我们使用它们来描述个体，并通过子类或不相交语句将它们与其他类关联。

现在，我们将演示如何将命名的类、属性和个人用作定义新类的构建块。

5.1复杂类别

通过迄今为止描述的语言元素，可以对简单的本体进行建模。为了表达更复杂的知识，OWL提供了逻辑类构造函数。特别是，OWL为逻辑和、或和not提供了语言元素。相应的OWL术语借用了集合论：（类）交叉口,联盟和补充。这些构造函数将原子类（即具有名称的类）与复杂类相结合。

这个交叉两个类中的个体正好是这两个类的实例。以下示例表明，类Mother正好由那些既是Woman又是Parent的实例的对象组成：

功能-样式语法
等价类(：母亲ObjectIntersectionOf（：女性：父母）)
RDF/XML语法
＜owl:Class rdf:about=“母亲”＞<owl:equivalentClass><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Woman”/><owl:Class rdf:about=“Parent”/></owl:intersectionOf></owl:Class></owl:equivalentClass></owl:Class>
Turtle语法
：母猫头鹰：equivalentClass[rdf:type owl:Class；owl:intersectionOf（：女人：父母）] .
曼彻斯特语法
班级：母亲等价物：女性和家长
OWL/XML语法
<等价类><IRI类=“母亲”/><对象交集><IRI级=“女性”/><IRI=“父级”/></ObjectIntersectionOf></等价类>

从中可以得出的一个推论示例是，类Mother的所有实例也都在类Parent中。

这个联盟两个类中包含至少一个类中所包含的每个个体。因此，我们可以将所有父母的阶级描述为母亲和父亲阶级的结合：

功能-样式语法
等价类(：父级ObjectUnionOf（：母亲：父亲）)
RDF/XML语法
<owl:Class rdf:about=“Parent”><owl:equivalentClass><owl:Class><owl:unionOf rdf:parseType=“Collection”><owl:Class rdf:about=“母亲”/><owl:Class rdf:about=“父亲”/></owl:unionOf></owl:Class></owl:equivalentClass></owl:Class>
Turtle语法
：父猫头鹰：equivalentClass[rdf:type owl:Class；owl:unionOf（：母亲：父亲）] .
曼彻斯特语法
类别：父级等同于：母亲或父亲
OWL/XML语法
<等价类><IRI=“父级”/><对象联合><IRI类=“母亲”/><Class IRI=“父亲”/></ObjectUnionOf></等价类>

这个补充类的属性对应于逻辑否定：它完全由那些不是类本身成员的对象组成。以下对无子人员的定义使用了类补码，并证明了类构造函数可以嵌套：

功能-样式语法
等价类(：无子女人士对象交集(：个人ObjectComplementOf（：父级）))
RDF/XML语法
<owl:Class rdf:about=“无子女人士”><owl:equivalentClass><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Person”/><owl:Class><owl:complementOf rdf:resource=“Parent”/></owl:Class></owl:intersectionOf></owl:Class></owl:equivalentClass></owl:Class>
Turtle语法
：ChildlessPerson owl:equivalentClass[rdf:type owl:Class；owl:intersectionOf（：个人[rdf:type owl:Class；owl:complementOf:Parent]）] .
曼彻斯特语法
班级：无子女人士等价于：个人而非家长
OWL/XML语法
<等价类><Class IRI=“无子女人士”/><对象交集><Class IRI=“个人”/><对象补充><IRI=“父级”/></ObjectComplementOf></ObjectIntersectionOf></等价类>

以上所有示例都演示了类构造函数的用法，以便定义新类作为其他类的组合。当然，也可以将类构造函数与子类语句一起使用，以指示类的必要条件（但不是充分条件）。以下陈述表明，每一位祖父都是一个男人和一个父母（反之亦然）：

功能-样式语法
SubClassOf（子类：祖父ObjectIntersectionOf（：男：父）)
RDF/XML语法
<owl:Class rdf:about=“祖父”><rdfs:subClassOf><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Man”/><owl:Class rdf:about=“Parent”/></owl:intersectionOf></owl:Class></rdfs:subClassOf></owl:Class>
Turtle语法
：祖父rdfs:subClassOf[rdf:type owl:Class；owl:intersectionOf（：男：父）] .
曼彻斯特语法
班级：爷爷子类别：男性和父母
OWL/XML语法
<子类><Class IRI=“祖父”/><对象交集><IRI=“Man”类/><IRI=“父级”/></ObjectIntersectionOf></SubClassOf>

一般来说，复杂类可以在出现命名类的每个地方使用，因此也可以在类断言中使用。下面的例子证明了这一点，即Jack是一个人，但不是父母。

功能-样式语法
类断言(对象交集(：个人ObjectComplementOf（：父级）) ：杰克)
RDF/XML语法
<rdf:描述rdf:about=“Jack”><rdf:type><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Person”/><owl:Class><owl:complementOf rdf:resource=“Parent”/></owl:Class></owl:intersectionOf></owl:Class></rdf:type></rdf:描述>
Turtle语法
：Jack rdf：类型[rdf:type owl:Class；owl:intersectionOf（：个人[rdf:type owl:Class；owl:complementOf:父级])] .
曼彻斯特语法
个人：Jack类型：个人而非家长
OWL/XML语法
<类断言><对象交集><Class IRI=“个人”/><对象补充><IRI=“父级”/></ObjectComplementOf></ObjectIntersectionOf><Named个人IRI=“杰克”/></ClassAssertion>

5.2财产限制

属性限制为复杂类提供了另一种基于逻辑的构造函数。顾名思义，属性限制使用涉及属性的构造函数。

调用了一个属性限制存在量词将类定义为通过特定属性连接到作为某个类实例的另一个个体的所有个体的集合。这最好用一个例子来解释，比如下面的例子，它将父母的类别定义为通过hasChild属性链接到一个人的个人类别。

功能-样式语法
等价类(：父级ObjectSomeValuesFrom（：hasChild:人）)
RDF/XML语法
<owl:Class rdf:about=“Parent”><owl:equivalentClass><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:someValuesFrom rdf:resource=“Person”/></owl:限制></owl:equivalentClass></owl:Class>
Turtle语法
：父猫头鹰：equivalentClass[rdf：type owl：限制；owl:onProperty:hasChild；owl:someValuesFrom:Person] .
曼彻斯特语法
类别：父级等价物to：hasChild some人
OWL/XML语法
<等价类><IRI=“父级”/><对象SomeValuesFrom><ObjectProperty IRI=“hasChild”/><Class IRI=“个人”/></ObjectSomeValuesFrom></等价类>

这意味着，对于父级，至少存在一个子级，并且该子级是的成员Person类。这对于捕获不完整的知识例如，Sally告诉我们Bob是一位家长，因此，即使我们不知道，我们也可以推断他至少有一个孩子他们的名字。存在量化用法的自然语言指示符是“some”或“one”等词

另一个属性限制称为通用量化用于描述一类个体，其所有相关个体都必须是给定类的实例。我们可以用下面的语句来表示，如果一个人的所有孩子都是快乐的人，那么他就是快乐的人。

功能-样式语法
等价类(：快乐人士ObjectAllValuesFrom（：hasChild:HappyPerson）)
RDF/XML语法
<owl:Class><owl:Class rdf:about=“HappyPerson”/><owl:equivalentClass><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:allValuesFrom rdf:resource=“HappyPerson”/></owl:限制></owl:equivalentClass></owl:Class>
Turtle语法
：HappyPerson rdf：类型owl:Class；owl：等价类[rdf：type owl：限制；owl:onProperty:hasChild；owl:allValuesFrom:快乐] .
曼彻斯特语法
班级：HappyPerson等价物：has only Child Happy Person
OWL/XML语法
<等价类><Class IRI=“快乐人士”/><对象所有值自><ObjectProperty IRI=“hasChild”/><Class IRI=“快乐”/></ObjectAllValuesFrom></等价类>

这个例子还表明，OWL语句可以以某种方式自引用；HappyPerson类用于等价语句的两侧。

属性限制的使用可能会给“建模初学者”带来一些概念上的混乱将自然语言语句转换为逻辑公理，存在量化的发生频率要高得多。通用量化用法的自然语言指示符是“仅”、“仅”或“仅”等词

关于普遍的角色限制，有一个特别的误解。举个例子，考虑一下上面的幸福公理。直观的阅读表明，为了快乐，一个人必须至少有一个快乐的孩子。然而，情况并非如此：任何不是hasChild属性“起点”的个人都是由hasChilld的通用量化定义的任何类的类成员。因此，根据我们的上述声明，每个没有孩子的人都有资格幸福。为了使上述预期阅读正式化，声明必须如下：

功能-样式语法
等价类(：快乐人士对象交集(ObjectAllValuesFrom（：hasChild:HappyPerson）ObjectSomeValuesFrom（：hasChild:HappyPerson）))
RDF/XML语法
<owl:Class><owl:Class rdf:about=“HappyPerson”/><owl:equivalentClass><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:allValuesFrom rdf:resource=“HappyPerson”/></owl:限制><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:someValuesFrom rdf:resource=“HappyPerson”/></owl:限制></owl:intersectionOf></owl:Class></owl:equivalentClass></owl:Class>
Turtle语法
：HappyPerson rdf：类型owl:Class；owl：等价类[rdf:type owl:Class；owl:intersectionOf（[rdf:type owl:Restriction；owl:onProperty:hasChild；owl:allValuesFrom:Happy][rdf:type owl:限制；owl:onProperty:hasChild；owl:someValuesFrom:Happy])] .
曼彻斯特语法
班级：HappyPerson等价于：hasChild only HappyPerson和hasChilld some HappyPerson
OWL/XML语法
<等价类><Class IRI=“快乐人士”/><对象交集><对象所有值自><ObjectProperty IRI=“hasChild”/><Class IRI=“快乐人士”/></ObjectAllValuesFrom><对象SomeValuesFrom><ObjectProperty IRI=“hasChild”/><Class IRI=“快乐人士”/></ObjectSomeValuesFrom></ObjectIntersectionOf></等价类>

此示例还说明了如何将属性限制嵌套在复杂类中。

财产限制也可用于描述与特定个人相关的个人类别。例如，我们可以定义约翰的孩子的类别：

功能-样式语法
等价类（：Johns儿童ObjectHasValue（：hasParent:John）)
RDF/XML语法
<owl:Class rdf:about=“JohnsChildren”><owl:equivalentClass><owl:限制><owl:onProperty rdf:resource=“hasParent”/><owl:hasValue rdf:resource=“John”/></owl:限制></owl:equivalentClass></owl:Class>
Turtle语法
：约翰儿童猫头鹰：等价类[rdf:type owl:限制；owl:onProperty:hasParent；owl:hasValue:约翰] .
曼彻斯特语法
班级：约翰儿童等价于：hasParent值John
OWL/XML语法
<等价类><Class IRI=“约翰儿童”/><对象哈斯值><ObjectProperty IRI=“hasParent”/><NamedIndividual IRI=“约翰”/></ObjectHasValue></等价类>

作为一种特殊情况，个人通过财产相互联系，个人可能与自身相联系。下面的例子展示了如何表达所有自恋者都爱自己的想法。

功能-样式语法
等价类(：缉毒人员对象有自己（：loves）)
RDF/XML语法
<owl:Class rdf:about=“NarcisticPerson”><owl:equivalentClass><owl:限制><owl:onProperty rdf:resource=“loves”/><owl:hasSelf rdf:datatype=“http://www.w3.org/2001/XMLSchema#boolean">真的</owl:hasSelf></owl:限制></owl:equivalentClass></owl:Class>
Turtle语法
：NarcisticPerson猫头鹰：等价类[rdf:type owl:限制；owl:onProperty:爱；owl:hasSelf“true”^^xsd:boolean。] .
曼彻斯特语法
类别：缉毒人员等价物：爱自己
OWL/XML语法
<等价类><IRI=“缉毒人员”/><对象具有自身><ObjectProperty IRI=“loves”/></对象具有自身></等价类>

5.3财产基数限制

使用通用量化，我们可以谈论某人的所有孩子，而存在量化允许我们提及（至少）其中一个孩子。然而，我们可能需要指定参与限制的人数。事实上，我们可以根据孩子的数量来建造班级。 以下示例表明，John最多有四个孩子，他们自己也是父母：

功能-样式语法
类断言(对象最大基数（4:hasChild：父对象）：约翰)
RDF/XML语法
<rdf:描述rdf:about=“John”><rdf:type><owl:限制><owl:maxQualifiedCardinality rdf:datatype=“http://www.w3.org/2001/XMLSchema#nonNegativeInteger">4</owl:maxQualifiedCardinality><owl:onProperty rdf:resource=“hasChild”/><owl:onClass rdf:resource=“Parent”/></owl:限制></rdf:type></rdf:描述>
Turtle语法
：John rdf：类型[rdf：type owl：限制；owl:maxQualifiedCardinality“4”^^xsd:nonNegativeInteger；owl:onProperty:hasChild；owl:onClass:父级] .
曼彻斯特语法
个人：John类型：hasChild max 4 Parent
OWL/XML语法
<类断言><ObjectMaxCardinality基数=“4”><ObjectProperty IRI=“hasChild”/><IRI=“父级”/></ObjectMaxCardinality><NamedIndividual IRI=“约翰”/></ClassAssertion>

请注意，这句话允许约翰任意多生几个不是父母的孩子。

同样，也可以通过说John是一个至少有两个孩子的人的例子来宣布最小数量：

功能-样式语法
类断言(ObjectMinCardinality（2:hasChild：父对象）：约翰)
RDF/XML语法
<rdf:描述rdf:about=“John”><rdf:type><owl:限制><owl:minQualifiedCardinality rdf:datatype=“http://www.w3.org/2001/XMLSchema#nonNegativeInteger">2</owl:minQualifiedCardinality><owl:onProperty rdf:resource=“hasChild”/><owl:onClass rdf:resource=“Parent”/></owl:限制></rdf:type></rdf:描述>
Turtle语法
：John rdf：类型[rdf：type owl：限制；owl:minQualifiedCardinality“2”^^xsd:nonNegativeInteger；owl:onProperty:hasChild；owl:onClass:父级] .
曼彻斯特语法
个人：John类型：hasChild min 2 Parent
OWL/XML语法
<类断言><ObjectMinCardinality基数=“2”><ObjectProperty IRI=“hasChild”/><IRI=“父级”/></ObjectMinCardinality><NamedIndividual IRI=“约翰”/></ClassAssertion>

如果我们碰巧知道约翰的父母子女的确切人数，具体如下：

功能-样式语法
类断言（对象精确基数（3:hasChild：父对象）：约翰)
RDF/XML语法
<rdf:描述rdf:about=“John”><rdf:type><owl:限制><owl:qualifiedCardinality rdf:datatype=“http://www.w3.org/2001/XMLSchema#nonNegativeInteger">三</owl:合格基数><owl:onProperty rdf:resource=“hasChild”/><owl:onClass rdf:resource=“Parent”/></owl:限制></rdf:type></rdf:描述>
Turtle语法
：John rdf：类型[rdf：type owl：限制；owl:qualifiedCardinality“3”^^xsd:nonNegativeInteger；owl:onProperty:hasChild；owl:onClass:父级] .
曼彻斯特语法
个人：John类型：hasChild正好3个Parent
OWL/XML语法
<类断言><ObjectExactCardinality基数=“3”><ObjectProperty IRI=“hasChild”/><IRI=“父级”/></ObjectExactCardinality><NamedIndividual IRI=“约翰”/></ClassAssertion>

在基数限制中，提供类是可选的；如果我们只想谈谈约翰所有孩子的人数，我们可以写下：

功能-样式语法
类断言(对象精确基数（5:hasChild）：约翰)
RDF/XML语法
<rdf:描述rdf:about=“John”><rdf:type><owl:限制><owl:cardinality rdf:datatype=“http://www.w3.org/2001/XMLSchema#nonNegativeInteger">5</owl:基数><owl:onProperty rdf:resource=“hasChild”/></owl:限制></rdf:type></rdf:描述>
Turtle语法
：John rdf：类型[rdf：type owl：限制；owl:基数“5”^^xsd:nonNegativeInteger；owl:onProperty:hasChild] .
曼彻斯特语法
个人：John类型：hasChild正好5个
OWL/XML语法
<类断言><ObjectExactCardinality基数=“5”><ObjectProperty IRI=“hasChild”/></ObjectExactCardinality><NamedIndividual IRI=“约翰”/></ClassAssertion>

5.4个人计数

描述类的一种非常简单的方法就是枚举它的所有实例。OWL提供了这种可能性，例如，我们可以创建一类生日客人：

功能-样式语法
等价类(：我的生日客人对象一（：比尔：约翰：玛丽）)
RDF/XML语法
＜owl:Class rdf:about=“MyBirthdayGuests”＞<owl:equivalentClass><owl:Class><owl:oneOf rdf:parseType=“Collection”><rdf:描述rdf:about=“Bill”/><rdf:描述rdf:about=“John”/><rdf:描述rdf:about=“Mary”/></owl:oneOf></owl:Class></owl:equivalentClass></owl:Class>
Turtle语法
：MyBirthdayGuests owl:equivalentClass[rdf:type owl:Class；猫头鹰：oneOf（：比尔：约翰：玛丽）] .
曼彻斯特语法
班级：MyBirthdayGuests等价于：{比尔、约翰、玛丽}
OWL/XML语法
<等价类><Class IRI=“MyBirthdayGuests”/>＜ObjectOneOf＞<Named个人IRI=“账单”/><NamedIndividual IRI=“约翰”/><Named个人IRI=“玛丽”/></ObjectOneOf></等价类>

注意，这个公理提供了比简单地断言Bill、John和Mary的类成员身份更多的信息，如4.1节所述。除此之外，它还规定比尔、约翰和玛丽是只有MyBirthdayGuests的成员。因此，以这种方式定义的类有时被称为封闭类或枚举集。如果我们现在断言Jeff是MyBirthdayGuests的一个实例，那么结果是Jeff必须等于上述三个人之一。

6属性的高级使用

到目前为止，我们关注的是仅用作类表达式构建块的类和属性。在下面，我们将看到OWL 2属性提供的其他建模功能。

6.1特性

有时，可以通过获取另一个属性并更改其方向，即反转它来获得一个属性。例如，属性hasParent可以定义为hasChild的反转属性：

功能-样式语法
反向对象属性（：hasParent:hasChild）
RDF/XML语法
<owl:ObjectProperty rdf:about=“hasParent”><owl:inverseOf rdf:resource=“hasChild”/></owl:ObjectProperty>
Turtle语法
：hasParent owl：inverseOf：hasChild。
曼彻斯特语法
对象属性：hasParent反转：hasChild
OWL/XML语法
<反向对象属性><ObjectProperty IRI=“hasParent”/><ObjectProperty IRI=“hasChild”/></Inverse对象属性>

例如，这将允许推导任意个体A和B，其中A通过hasChild属性与B链接，B和A也通过hasParent属性互连。 然而，如果我们只想在类表达式中使用它，我们不需要显式地将名称赋给属性的逆函数。我们可以直接将其称为hasChild-inverse，而不是使用新的hasParent属性来定义Orphan类：

功能-样式语法
等价类(：孤儿对象所有值来自(对象反转（：hasChild）：已死亡))
RDF/XML语法
<owl:Class rdf:about=“孤儿”><owl:equivalentClass><owl:限制><owl:onProperty><owl:ObjectProperty><owl:inverseOf rdf:resource=“hasChild”/></owl:ObjectProperty></owl:onProperty><owl:allValuesFrom rdf:resource=“死”/></owl:限制></owl:equivalentClass></owl:Class>
Turtle语法
：孤儿猫头鹰：等价类[rdf：type owl：限制；owl:onProperty[owl:inverseOf:hasChild]；owl:allValuesFrom:死] .
曼彻斯特语法
班级：孤儿等价于：inverse has only Dead
OWL/XML语法
<等价类><IRI=“孤儿”类/><对象所有值自><对象反转><ObjectProperty IRI=“hasChild”/></对象反转><Class IRI=“死亡”/></ObjectAllValuesFrom></等价类>

在某些情况下，属性与其逆属性重合，换句话说，属性的方向无关紧要。例如，如果属性hasSpouse将B与A联系起来，那么它将A与B联系起来。显然，具有此特征的属性称为对称的，可以指定如下

功能-样式语法
对称对象属性（：hasSpouse）
RDF/XML语法
<owl:SymmetricProperty rdf:about=“hasSpouse”/>
Turtle语法
：hasSpouse rdf：键入owl:SymmetricProperty。
曼彻斯特语法
对象属性：hasSpouse特点：对称
OWL/XML语法
<对称对象属性><ObjectProperty IRI=“hasSpouse”/></SymmetricObjectProperty>

另一方面，属性也可以是不对称也就是说，如果它将A与B连接起来，它就永远不会将B与A连接起来。显然（不包括时间旅行导致的矛盾场景），hasChild属性就是这样的情况，其表达方式如下：

功能-样式语法
不对称对象属性（：hasChild）
RDF/XML语法
＜owl:AsymmetricProperty rdf:about=“hasChild”/>
Turtle语法
：hasChild rdf:type owl:AsymmetricProperty。
曼彻斯特语法
ObjectProperty:hasChild特点：不对称
OWL/XML语法
<不对称对象属性><ObjectProperty IRI=“hasChild”/></不对称对象属性>

注意，非对称性比非对称性的概念要强烈得多。同样，对称性比非对称性更具说服力。

以前，我们考虑子属性时与子类类似。事实证明，将类不相交的概念转换为属性也是有意义的：如果没有两个由这两个属性链接的个体，那么两个属性就是不相交的。根据普通法，我们可以规定亲子婚姻不能发生：

功能-样式语法
DisjointObjectProperties（：hasParent:hasSpouse）
RDF/XML语法
<rdf:描述rdf:about=“hasParent”><owl:propertyDisjointWith rdf:resource=“hasSpouse”/></rdf:描述>
Turtle语法
：hasParent owl:propertyDisjointWith:hasSpouse。
曼彻斯特语法
分离属性：hasParent、hasSpouse
OWL/XML语法
<分离对象属性><ObjectProperty IRI=“hasParent”/><ObjectProperty IRI=“hasSpouse”/></DisjointObjectProperties>

属性也可以是反射的：这样的属性将一切与自身相关联。对于下面的示例，请注意每个人都有自己的亲属身份。

功能-样式语法
ReflexiveObjectProperty（：hasRelative）
RDF/XML语法
<owl:ReflexiveProperty rdf:about=“hasRelative”/>
Turtle语法
：hasRelative rdf：类型owl:ReflexiveProperty。
曼彻斯特语法
对象属性：hasRelative特征：反射
OWL/XML语法
<反射对象属性><ObjectProperty IRI=“hasRelative”/></ReflexiveObjectProperty>

注意，这并不一定意味着每两个由自反性质相关的个体都是相同的。

属性还可以是不灵活的也就是说，任何人都不能通过这样的角色与自己联系起来。下面是一个典型的例子，简单地说，没有人可以成为自己的父母。

功能-样式语法
无反射对象属性（：parentOf）
RDF/XML语法
<owl:IrreflectiveProperty rdf:about=“parentOf”/>
Turtle语法
：parentOf rdf：键入owl:IrreflectiveProperty。
曼彻斯特语法
ObjectProperty:parentOf特点：不灵活
OWL/XML语法
<无反射对象属性><ObjectProperty IRI=“parentOf”/></UnreflexiveObjectProperty>

接下来，考虑丈夫的财产。由于每个人只能有一个丈夫（为了这个例子，我们认为这是理所当然的），每个人最多可以通过hasHusband财产与另一个人联系起来。 这种属性称为功能性的如下所述：

功能-样式语法
功能对象属性（：hasband）
RDF/XML语法
<owl:FunctionalProperty rdf:about=“hasHusband”/>功能属性
Turtle语法
：hasband rdf：键入owl:FunctionalProperty。
曼彻斯特语法
标的财产：丈夫特点：功能
OWL/XML语法
＜函数对象属性＞<ObjectProperty IRI=“hasband”/></FunctionalObjectProperty>

请注意，这句话并没有要求每个人都有丈夫，它只是说不可能有一个以上的丈夫。此外，如果我们另外声明玛丽的丈夫是詹姆斯，另一个声明玛丽的先生是吉姆，那么可以推断出吉姆和詹姆斯一定是指同一个人。

也可以表示给定属性的逆函数是函数性的：

功能-样式语法
反函数对象属性（：hasband）
RDF/XML语法
<owl:Inverse FunctionalProperty rdf:about=“hasHusband”/>反向功能属性
Turtle语法
：hasband rdf：类型owl:InverseFunctionalProperty。
曼彻斯特语法
标的财产：丈夫特征：逆函数
OWL/XML语法
<反向函数对象属性><ObjectProperty IRI=“hasband”/></InverseFunctionalObjectProperty>

这表明一个人最多可以成为另一个人的丈夫。这个例子还指出了功能性和逆功能性之间的区别，因为在一夫多妻制的情况下，前者的公理是有效的，而后者则不然。

现在来看一个属性hasAncestor，它意味着当a是B的直系后代时，将个人a和B链接起来。显然，属性hasParent是hasAnsector的“特例”，可以定义为其子属性。不过，“自动”包括父母的父母（以及父母的父母的父母）还是不错的。这可以通过将hasAncestor定义为传递的财产。当一个可传递属性将A和B链接在一起时，它将两个个体A和C链接在一起，而对于某个个体B，它将B和C链接到一起。

功能-样式语法
TransitiveObjectProperty（：hasAncestor）
RDF/XML语法
<owl:TransitiveProperty rdf:about=“hasAncestor”/>
Turtle语法
：hasAncestor rdf：类型owl:TransitiveProperty。
曼彻斯特语法
对象属性：hasAncestor特征：可传递
OWL/XML语法
＜传递对象属性＞<ObjectProperty IRI=“hasAncestor”/></TranitiveObjectProperty>

6.2财产链

虽然上一节中的最后一个示例暗示，只要存在hasParent属性链，就会出现hasAncestor属性，但我们可能需要更具体一些，比如定义hasGrandparent属性。从技术上讲，这意味着我们希望hasGrandparent连接所有由两个hasParent属性链链接的个人。与前面的hasAncestor示例相反，我们不希望hasParent是hasGrandparent的特例，也不希望has Grandparenter引用greatgrandparents等。我们可以表示，每个这样的链都必须由hasGrandaparent属性跨越，如下所示：

功能-样式语法
子对象属性（ObjectPropertyChain（：hasParent:hasParent）：有祖父母)
RDF/XML语法
<rdf:描述rdf:about=“hasGrandparent”><owl:propertyChainAxiom rdf:parseType=“Collection”>＜owl:ObjectProperty rdf:about=“hasParent”/>＜owl:ObjectProperty rdf:about=“hasParent”/></owl:propertyChainAxiom></rdf:描述>
Turtle语法
：hasGrandparent owl:propertyChainAxiom（：hasParent:hasParent）。
曼彻斯特语法
对象属性：hasGrandparent子属性链：hasParento hasParent
OWL/XML语法
<子对象属性><对象属性链><ObjectProperty IRI=“hasParent”/><ObjectProperty IRI=“hasParent”/></ObjectPropertyChain><ObjectProperty IRI=“hasGrandparent”/></SubObjectPropertyOf>

6.3钥匙

在OWL 2中，可以将（数据或对象）属性的集合指定为类表达式的键。这意味着类表达式的每个命名实例都由这些属性相对于实例获得的值集唯一标识。

这方面的一个简单例子是通过一个人的社会保险号码来识别他的身份。

功能-样式语法
HasKey（：个人（）（：hasSSN））
RDF/XML语法
＜owl:Class rdf:about=“Person”＞<owl:hasKey rdf:parseType=“Collection”><owl:DataProperty rdf:about=“hasSSN”/></owl:hasKey></owl:Class>
Turtle语法
：个人owl:hasKey（：hasSSN）。
曼彻斯特语法
班级：人HasKey：hasSSN
OWL/XML语法
<哈斯键><Class IRI=“个人”/><DataProperty IRI=“hasSSN”/></HasKey>

7数据类型的高级使用

在第4.8节中，我们了解到可以为个人赋予数字信息，基本上是通过数据类型属性将他们连接到数据值，就像对象属性链接到其他域个人一样。事实上，这些相似之处扩展到了数据类型使用的更高级功能。

首先，数据值被分组为数据类型，我们在第4.8节中看到了如何使用数据类型属性的范围限制来指示该属性可以链接到的值的类型。此外，还可以通过约束或组合现有的数据类型来表示和定义新的数据类型。 数据类型可以通过所谓的刻面，从XML架构数据类型借用[XML架构数据类型]. 在下面的示例中，我们通过将数据类型整数限制为介于0和150之间（包括0和150）的值，为一个人的年龄定义了一个新的数据类型。

功能-样式语法
数据类型定义(：personAge数据类型限制（xsd:integerxsd:minInclusive“0”^^xsd:integerxsd:maxInclusive“150”^^xsd:integer))
RDF/XML语法
<rdf:描述rdf:about=“personAge”><owl:equivalentClass><rdfs:数据类型><owl:onDatatype rdf:resource=“http://www.w3.org/2001/XMLSchema#integer"/><owl:withRestrictions rdf:parseType=“Collection”><rdf:说明><xsd:minInclusive rdf:datatype=“http://www.w3.org/2001/XMLSchema#integer“>0</xsd:minInclusive></rdf:描述><rdf:说明><xsd:maxInclusive rdf:datatype=“http://www.w3.org/2001/XMLSchema#integer“>150</xsd:maxInclusive></rdf:说明></owl:有限制></rdfs:数据类型></owl:equivalentClass></rdf:描述>
Turtle语法
：person猫头鹰年龄：相等类别[rdf:type rdfs:数据类型；owl:onDatatype xsd:integer；owl:带限制([xsd:minInclusive“0”^^xsd:integer][xsd:maxInclusive“150”^^xsd:integer])] .
曼彻斯特语法
数据类型：personAge等价于：整数[<=0，>=150]
OWL/XML语法
<数据类型定义><数据类型IRI=“personAge”/><数据类型限制><数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer"/><FacetRestriction facet=“http://www.w3.org/2001/XMLSchema#minInclusive"><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer“>0</文字></FacetRestriction><FacetRestriction facet=“http://www.w3.org/2001/XMLSchema#maxInclusive"><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer“>150</文字></FacetRestriction></DatatypeRestriction></DatatypeDefinition>

同样，数据类型可以像类一样通过补码、交集和并集进行组合。因此，假设我们已经定义了数据类型minorAge，我们可以通过从personAge中排除minorAge:

功能-样式语法
数据类型定义(：专业年龄数据交叉点(：personAge数据补充（：minorAge）) )
RDF/XML语法
<rdf:描述rdf:about=“majorAge”><owl:equivalentClass><rdfs:数据类型><owl:intersectionOf rdf:parseType=“Collection”><rdf:描述rdf:about=“personAge”/><rdfs:数据类型><owl:datatypeComplementOf rdf:resource=“minorAge”/></rdfs:数据类型></owl:intersectionOf></rdfs:数据类型></owl:equivalentClass></rdf:描述>
Turtle语法
：majorAge猫头鹰：等效类[rdf:type rdfs:数据类型；owl:交集Of(：personAge[rdf:type rdfs:数据类型；owl:datatypeComplementOf:minorAge])] .
曼彻斯特语法
数据类型：majorAge等价于：personAge而非minorAge
OWL/XML语法
<数据类型定义><数据类型IRI=“majorAge”/><数据交叉点><数据类型IRI=“personAge”/><数据补充><数据类型IRI=“minorAge”/></DataComplementOf></DataIntersectionOf></DatatypeDefinition>

此外，只需枚举它包含的数据值，就可以生成新的数据类型。

功能-样式语法
数据类型定义(：幼儿年龄DataOneOf（“1”^^xsd:integer“2”^^xsd:integer）)
RDF/XML语法
<rdf:描述rdf:about=“幼儿年龄”><owl:equivalentClass><rdfs:数据类型><owl:oneOf><rdf:说明><rdf:first rdf:datatype=“http://www.w3.org/2001/XMLSchema#integer“>1</rdf:first><rdf:rest><rdf:说明><rdf:first rdf:datatype=“http://www.w3.org/2001/XMLSchema#integer“>2</rdf:first><rdf:rest rdf:resource=“http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/></rdf:描述></rdf:rest></rdf:描述></owl:oneOf></rdfs:数据类型></owl:equivalentClass></rdf:描述>
Turtle语法
：幼儿猫头鹰：等价类[rdf:type rdfs:数据类型；owl:oneOf（“1”^^xsd:integer“2”^^xsd:integer）] .
曼彻斯特语法
数据类型：幼儿年龄等价于：{1，2}
OWL/XML语法
<数据类型定义><Datatype IRI=“幼儿年龄”/><数据之一><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer“>1</文字><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer“>2</文字></DataOneOf></DatatypeDefinition>

在第6.1节中，我们看到了描述对象属性的方法。其中一些也可用于数据类型属性。例如，我们可以通过将hasAge数据类型属性描述为functional来表示每个人只有一个年龄：

功能-样式语法
函数数据属性（：hasAge）
RDF/XML语法
<owl:FunctionalProperty rdf:about=“hasAge”/>
Turtle语法
：hasAge rdf：键入owl:FunctionalProperty。
曼彻斯特语法
数据属性：hasAge特点：功能
OWL/XML语法
<函数数据属性><DataProperty IRI=“hasAge”/></FunctionalDataProperty>

可以通过对数据类型属性的限制来定义新类。以下示例将班级青少年定义为年龄在13至19岁之间的所有个人。

功能-样式语法
子类别(：青少年数据房屋值来自（：hasAge数据类型限制（xsd:integerxsd:minExclusive“12”^^xsd:integerxsd:maxInclusive“19”^^xsd:integer)))
RDF/XML语法
<owl:Class rdf:about=“青少年”><rdfs:subClassOf><owl:限制><owl:onProperty rdf:resource=“hasAge”/><owl:someValuesFrom><rdfs:数据类型><owl:onDatatype rdf:resource=“http://www.w3.org/2001/XMLSchema#integer"/><owl:withRestrictions rdf:parseType=“Collection”><rdf:说明><xsd:minExclusive rdf:datatype=“http://www.w3.org/2001/XMLSchema#integer“>12</xsd:minExclusive></rdf:描述><rdf:说明><xsd:maxInclusive rdf:datatype=“http://www.w3.org/2001/XMLSchema#integer“>19</xsd:maxInclusive></rdf:描述></owl:有限制></rdfs:数据类型></owl:someValuesFrom></owl:限制></rdfs:subClassOf></owl:Class>
Turtle语法
：青少年rdfs:subClassOf[rdf:type owl:限制；owl:onProperty:hasAge；owl:someValuesFrom[rdf:type rdfs:数据类型；owl:onDatatype xsd:integer；owl:带限制（[xsd:minExclusive“12”^^xsd:integer][xsd:maxInclusive“19”^^xsd:integer])]] .
曼彻斯特语法
班级：青少年SubClassOf:hasAge某个整数[<12，>=19]
OWL/XML语法
<子类><IRI=“青少年”/><DataSomeValuesFrom><DataProperty IRI=“hasAge”/><数据类型限制><数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer"/><FacetRestriction facet=“http://www.w3.org/2001/XMLSchema#minExclusive"><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer“>12</文字></FacetRestriction><FacetRestriction facet=“http://www.w3.org/2001/XMLSchema#maxInclusive"><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#integer“>19</文字></FacetRestriction></DatatypeRestriction></DataSomeValuesFrom></SubClassOf>

8文件信息和注释

在下文中，我们描述了OWL 2的特性，这些特性实际上并没有对本体中指定的“逻辑”知识做出贡献。相反，这些用于提供关于本体本身、公理甚至单个实体的附加信息。

8.1公理和实体注释

在许多情况下，我们希望为OWL本体的某些部分提供信息，这些信息实际上并不描述域本身，而是讨论域的描述。OWL提供注释为此目的。OWL注释只是将属性值对与本体的部分或整个本体本身相关联。甚至注释本身也可以进行注释。注释信息实际上并不是本体逻辑意义的一部分。

例如，我们可以将信息添加到我们的本体论的一个类中，用自然语言描述其含义。

功能-样式语法
AnnotationAssertion（rdfs:comment:Person“表示所有人的集合。”）
RDF/XML语法
＜owl:Class rdf:about=“Person”＞<rdfs:comment>表示所有人的集合</rdfs:注释></owl:Class>
Turtle语法
：Person rdfs:comment“代表所有人的集合。”^^xsd:string。
曼彻斯特语法
班级：人注释：rdfs:comment“表示所有人的集合。”
OWL/XML语法
＜注解断言＞<AnnotationProperty IRI=“&rdfs；注释”/>个人代表所有人的集合</文字></AnnotationAssertion>

以下是带有注释的公理示例。

功能-样式语法
SubClassOf（子类注释（rdfs:comment“声明每个人都是一个人”）：男：个人)
RDF/XML语法
<owl:Class rdf:about=“Man”><rdfs:subClassOf rdf:resource=“Person”/></owl:Class><owl:公理><owl:annotatedSource rdf:resource=“Man”/><owl:annotatedProperty rdf:resource=“&rdfs；subClassOf”/><owl:annotatedTarget rdf:resource=“Person”/><rdfs:comment>指出每个人都是一个人</rdfs:注释></owl:Axiom>
Turtle语法
：Man rdfs:subClassOf:Person。[]rdf：类型owl：Axiom；owl:annotatedSource:Man；owl:annotatedProperty rdfs:subClassOf；owl:annotatedTarget:Person；rdfs:comment“声明每个人都是一个人。”^^xsd:string。
曼彻斯特语法
班级：男子SubClassOf:Annotations:rdfs:comment“陈述每个人都是一个人。”
OWL/XML语法
<子类><注释><AnnotationProperty IRI=“&rdfs；注释”/><文字数据类型IRI=“http://www.w3.org/2001/XMLSchema#string“>”表示每个人都是一个人。“</文字></注释><IRI=“Man”类/><Class IRI=“个人”/></SubClassOf>

这些注释通常用于工具中，以提供对帮助界面中显示的自然语言文本的访问。

8.2本体管理

在OWL中，关于主题的一般信息几乎总是收集到本体论然后由各种应用程序使用。我们还可以提供OWL本体的名称，通常是本体文档在web中的位置。如果一个主题被不同的应用程序使用，那么它的特定信息也可以放在本体中。

功能-样式语法
本体论(<http://example.com/owl/families>...)
RDF/XML语法
<rdf:rdf…><owl:Ontology rdf:about=“http://example.com/owl/families"/>...</rdf:rdf>
Turtle语法
<http://example.com/owl/families>rdf：类型owl:Ontology。
曼彻斯特语法
本体：<http://example.com/owl/families>
OWL/XML语法
<本体。。。本体论IRI=“http://example.com/owl/families">...</本体>

我们将OWL本体放在OWL文档中，然后将其放在本地文件系统或万维网上。除了包含OWL本体之外，OWL文档还包含关于将OWL本体中通常使用的短名称（例如Person）转换为IRI的信息，通过为前缀提供扩展IRI则是前缀扩展和引用的级联。

在我们的示例中，我们迄今为止使用了许多前缀，包括xsd格式和空前缀。前一个前缀已用于XML模式数据类型的紧凑名称中，其IRI由XML模式建议修复。因此，我们必须使用标准扩展xsd格式，这是http://www.w3.org/2001/XMLSchema#。我们为其他前缀选择的扩展将影响本体中类、属性和个人的名称，以及本体本身的名称。如果我们要把本体放在网络上，我们应该选择一个我们控制的网络部分的扩展，这样我们就不会偶然使用别人的名字。（这里我们使用了一个无人控制的虚构位置。）这两个基于XML的语法需要名称空间作为内置名称，也可以使用XML实体引用作为名称空间。一般来说，应该注意的是，在OWL的每个序列化中，可用的缩写机制及其特定语法都是不同的，即使在使用类似关键字的情况下也是如此。

功能-样式语法
前缀（：=<http://example.com/owl/families/>)前缀（otherOnt:=<http://example.org/otherOntologies/families网站/>)前缀（xsd:=<http://www.w3.org/2001/XMLSchema#>)前缀（owl：=<http://www.w3.org/2002/07/owl#>)本体论(<http://example.com/owl/families>...)
RDF/XML语法
<!DOCTYPE rdf:rdf[<!实体猫头鹰“http://www.w3.org/2002/07/owl#" ><!实体xsd“http://www.w3.org/2001/XMLSchema#" ><!实体rdfs“http://www.w3.org/2000/01/rdf-schema#" ><!其他实体”http://example.org/otherOntologies/families网站/" >]><rdf:rdf xml:base=“http://example.com/owl/families/"xmlns=“http://example.com/owl/families/"xmlns:otherOnt=“http://example.org/otherOntologies/families网站/"xmlns:owl=“http://www.w3.org/2002/07/owl#"xmlns:rdfs=“http://www.w3.org/2000/01/rdf-schema#"xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#"xmlns:xml=“http://www.w3.org/2001/XMLSchema#"><owl:Ontology rdf:about=“http://example.com/owl/families"/>...
Turtle语法
@前缀：<http://example.com/owl/families/> .@前缀otherOnt:<http://example.org/otherOntologies/families网站/> .@前缀owl:<http://www.w3.org/2002/07/owl#> .@前缀rdfs：<http://www.w3.org/2000/01/rdf-schema#> .@前缀rdf：<http://www.w3.org/1999/02/22-rdf-syntax-ns#> .@前缀xsd:<http://www.w3.org/2001/XMLSchema#> .
曼彻斯特语法
前缀：：<http://example.com/owl/families/>前缀：xsd:<http://www.w3.org/2001/XMLSchema#>前缀：owl：<http://www.w3.org/2002/07/owl#>前缀：otherOnt:<http://example.org/otherOntologies/families网站/>
OWL/XML语法
<!DOCTYPE本体[<!实体xsd“http://www.w3.org/2001/XMLSchema#" >]><本体论xml:base=“http://example.com/owl/families/"本体论IRI=“http://example.com/owl/families"xmlns=“http://www.w3.org/2002/07/owl#"><前缀name=“owl”IRI=“http://www.w3.org/2002/07/owl#"/>...</本体>

在OWL中，重用存储在其他本体中一个本体中的通用信息也是很常见的。OWL不需要复制此信息，而是允许使用导入语句在其他本体中导入整个本体的内容，如下所示：

功能-样式语法
导入（<http://example.org/otherOntologies/families.owl> )
RDF/XML语法
<owl:Ontology rdf:about=“http://example.com/owl/families"><owl:imports rdf:resource=“http://example.org/otherOntologies/families.owl" /></owl:本体>
Turtle语法
<http://example.com/owl/families>owl:导入<http://example.org/otherOntologies/families.owl> .
曼彻斯特语法
导入：<http://example.org/otherOntologies/families.owl>
OWL/XML语法
<前缀name=“otherOnt”IRI=“http://example.org/otherOntologies/families网站/"/><导入>http://example.org/otherOntologies/families.owl</导入>


随着语义网和本体构建的分布式，本体对相同的概念、属性或个体使用不同的名称是很常见的。正如我们所看到的，OWL中的几个构造可以用来声明不同的名称引用相同的名称班,财产，或个人例如，我们可以将本体中使用的名称与导入的本体中所使用的名称联系起来，而不是冗长地重命名实体，如下所示：

功能-样式语法
同一个人（：John otherOnt:John Brown）同一个人（：Mary otherOnt:Mary Brown）等价类（：成人其他Ont:成人）等价对象属性（：hasChild otherOnt:child）等价数据属性（：hasAge otherOnt:age）
RDF/XML语法
<rdf:描述rdf:about=“John”><owl:sameAs-rdf:resource=“&otherOnt；JohnBrown”/></rdf:描述><rdf:描述rdf:about=“Mary”><owl:sameAs-rdf:resource=“&otherOnt；MaryBrown”/></rdf:描述><owl:Class rdf:about=“成人”><owl:equivalentClass rdf:resource=“&otherOnt；成长”/></owl:Class><owl:ObjectProperty rdf:about=“hasChild”><owl:equivalentProperty rdf:resource=“&otherOnt；child”/></owl:ObjectProperty><owl:DatatypeProperty rdf:about=“hasAge”><owl:equivalentProperty rdf:resource=“&otherOnt；age”/></owl:DatatypeProperty>
Turtle语法
：玛丽猫头鹰：和别人一样Ont:玛丽·布朗。：John owl：与他人相同Ont：约翰布朗。：成年猫头鹰：等价类otherOnt：成年。：hasChild owl:equivalentProperty otherOnt:child。：hasAge owl:equivalentProperty otherOnt:age。
曼彻斯特语法
同一个人：约翰，其他人Ont:约翰布朗同一个人：玛丽，其他人Ont:玛丽·布朗等价类：成人，其他Ont：成人等效属性：hasChild，otherOnt:child等效属性：hasAge，otherOnt:age
OWL/XML语法
<同一个人><NamedIndividual IRI=“约翰”/><Named个人缩写IRI=“otherOnt:JohnBrown”/></同一个人><同一个人><Named个人IRI=“玛丽”/><NamedIndividual缩写dIRI=“otherOnt:MaryBrown”/></同一个人><等价类><IRI=“成人”/><班级缩写IRI=“otherOnt:成人”/></等价类><等效对象属性><ObjectProperty IRI=“hasChild”/><ObjectProperty缩写IRI=“otherOnt:child”/></EquivalentObjectProperties><等效数据属性><DataProperty IRI=“hasAge”/><DataProperty缩写IRI=“otherOnt:age”/></等效数据属性>

8.3实体声明

为了帮助管理本体，OWL有声明的概念。基本思想是每个类、属性或个体都应该在本体中声明，然后可以在该本体和导入该本体的本体中使用。

在曼彻斯特语法中，声明是隐式的。如果需要，提供类、属性或个体信息的构造函数将隐式声明该类、属性或者个体。其他语法有显式声明。

功能-样式语法
声明（具名个人（：John））申报（类别（：人））声明（ObjectProperty（：hasWife））声明（DataProperty（：hasAge））
RDF/XML语法
<owl:Named个人rdf:about=“John”/><owl:Class rdf:about=“Person”/><owl:ObjectProperty rdf:about=“hasWife”/><owl:DatatypeProperty rdf:about=“hasAge”/>
Turtle语法
：John rdf：键入owl:NamedIndividual。：Person rdf:type owl:Class。：hasWife rdf：键入owl:ObjectProperty。：hasAge rdf:type owl:DatatypeProperty。
曼彻斯特语法
个人：John班级：人对象属性：hasWife数据属性：hasAge
OWL/XML语法
<声明><NamedIndividual IRI=“约翰”/></声明><声明><Class IRI=“个人”/></声明><声明><ObjectProperty IRI=“hasWife”/></声明><声明><DataProperty IRI=“hasAge”/></声明>

然而，IRI可以同时表示不同的实体类型（例如，个人和类）。这种被称为“双关”的可能性被引入，以允许一定数量的元建模；我们在中给出了一个例子第9节尽管如此，OWL 2在使用和重用名称方面确实需要一些规则。为了实现更易读的语法，并且出于其他技术原因，OWL 2 DL要求名称不能用于多个属性类型（对象、数据类型或注释属性），IRI也不能同时表示类和数据类型。此外，“内置”名称（例如RDF和RDFS使用的名称以及OWL的各种语法）不能在OWL中自由使用。

9 OWL 2 DL和OWL 2中满

在OWL 2中，有两种为本体赋予意义的替代方法，称为直接语义[OWL 2直接语义]和基于RDF的语义[基于OWL 2 RDF的语义]. 直接语义可以应用于OWL2的OWL2 DL子集中的本体，OWL2是在OWL2功能样式语法文档中定义的[OWL 2规范]. OWL 2 DL中没有的本体论通常被认为属于OWL 2已满、和只能在基于RDF-Based Semantics下解释。非正式地，术语OWL 2下载通常用于引用使用直接语义解释的OWL2本体，但也可以在基于RDF-Based Semantics下解释OWL2 DL本体。

直接语义学[OWL 2直接语义]在描述逻辑中提供了OWL 2的含义[描述逻辑]风格。基于RDF的语义[基于OWL 2 RDF的语义]是RDFS语义的扩展[RDF语义]并且基于将OWL2本体视为RDF图。

当考虑本体时，这两种语义之间的差异通常很小。事实上，考虑到OWL 2 DL本体，使用直接语义得出的许多推论在基于RDF的语义下仍然是有效的推论-参见第7.2节基于RDF的语义文档的[基于OWL 2 RDF的语义]. 两个主要区别是，在直接语义下，注释没有形式意义，而在基于RDF的语义下，存在一些来自RDF宇宙视图的额外推断。

从概念上讲，我们可以从两个方面考虑OWL 2 DL（在直接语义下）和OWL 2Full（在基于RDF的语义下）之间的差异：

当然，这两种语义是一起设计的，因此相互影响。例如，OWL 2的一个设计目标是使OWL 2DL在语法上更接近OWL 2-Full（也就是说，允许更多RDF图/OWL 2 Full本体成为合法的OWL 2DL本体）。这导致了所谓的 双关语例如，使用相同的IRI作为类和个人的名称。下面是这种用法的一个例子，它表明约翰是一个父亲，父亲是一个社会角色。

功能-样式语法
ClassAssertion（：父亲：约翰）ClassAssertion（：社交角色：父亲）
RDF/XML语法
<神父rdf:about=“约翰”/><SocialRole rdf:about=“父亲”/>
Turtle语法
：John rdf：类型：父亲。：父亲rdf：类型：SocialRole。
曼彻斯特语法
个人：John类型：父亲个人：父亲类型：社交角色
OWL/XML语法
<类断言><Class IRI=“父亲”/><NamedIndividual IRI=“约翰”/></ClassAssertion><类断言><Class IRI=“社会角色”/><NamedIndividual IRI=“父亲”/></ClassAssertion>

注意，在第一条语句中，父亲被用作类，而在第二条语句中它被用作个体。在这个意义上，SocialRole充当了类父亲的元类。

在OWL1中，包含这两条语句的文档将是OWL1完整文档，而不是OWL1 DL文档。然而，在OWL 2 DL中，这是允许的。然而，必须注意的是，OWL 2 DL的直接语义通过将类父亲和个体父亲理解为同一IRI上的两个不同观点来适应这一点，即，它们在语义上被解释为它们是不同的。特别是，如果两个个体相等，那么它们所表示的类在基于RDF-Based Semantics下是等价的，而在直接语义下，类之间没有这种关系。这可能是两种语义之间在实践中最相关的一个区别。

10 OWL 2配置文件

除了OWL2 DL和OWL 2 Full之外，OWL2还指定了三个配置文件。一般来说，OWL 2是一种非常有表现力的语言（包括计算语言和用户语言），因此很难很好地实现和使用。这些附加配置文件是OWL 2的可接近子集，足以满足各种应用。与OWL 2 DL一样，计算方面的考虑是这些配置文件的主要要求（考虑到现有技术的强大可伸缩性，这些配置文件更容易实现），但OWL 2中有许多子集具有良好的计算特性。选定的OWL 2配置文件已被确定为具有大量用户社区，尽管还没有包括其他几个配置文件，人们应该期待会出现更多的用户社区[OWL 2配置文件]文档为指定其他配置文件提供了一个清晰的模板。

为了保证可伸缩的推理，现有的配置文件在表达方面有一些限制。一般来说，它们不允许否定和析取，因为这些构造了复杂的推理，并且证明建模很少需要。例如，在所有的个人资料中，都不可能指定每个人都是男性或女性。外形的进一步具体建模限制将在各个外形的章节中讨论。

我们讨论了每个概要文件及其设计原理，并为用户选择使用哪个概要文件提供了一些指导。请注意，此讨论并不全面，也不可能全面。任何决策的一部分都必须基于可用的工具以及该工具如何与系统或工作流的其余部分相匹配。在文献中可以找到对这些概况的更广泛的讨论和比较[OWL 2配置文件简介].

总的来说，不同的配置文件可以在语法上区分，一些配置文件包含其他配置文件。例如，OWL 2 DL可以被视为OWL 2Full的语法片段，而OWL 2-QL是OWL 2DL（因此也是OWL 2.Full的）的语法片段。下面的这些配置文件都不是另一个配置文件的子集。理想情况下，可以使用推理器（或其他工具），该推理器符合子文件上的超配置文件，而不会更改导出的结果。特别地，每个符合OWL 2 DL推理器也是OWL 2 EL、OWL 2 RL和OWL 2 QL的符合推理器（但由于OWL 2 DL推理器针对更一般的一组情况进行了调整，因此性能可能不同）。OWL 2的两个语义中的每一个（请参见第9节)可以用于任何配置文件，但最常见的是对OWL 2 EL和OWL 2QL使用直接语义，对OWL2 RL使用基于RDF的语义。

10.1猫头鹰2 EL

使用OWL2EL与使用OWL2DL非常相似：可以在subClassOf语句的两侧使用类表达式，甚至可以推断出这种关系。对于许多面向类表达式的大型本体，只需稍微简化即可获得OWL2EL本体，并保留原始本体的大部分含义。

OWL 2 EL的设计考虑了大型生物健康本体，如SNOMED-CT、NCI同义词库和Galen。这些本体论的共同特征包括复杂的结构描述（例如，根据某些身体部位所包含和包含的部分，或沿着部分-子部分关系传播疾病来定义它们）、大量的类、大量使用分类来管理术语、，以及由此产生的术语在大量数据中的应用。因此，OWL 2 EL有一种比较有表现力的类表达式语言，它对如何在公理中使用它们没有任何限制。它还具有相当有表现力的属性表达式，包括属性链，但不包括逆属性。

OWL 2 EL的合理使用显然不限于生物健康领域：与其他配置文件一样，OWL 2EL是领域独立的。然而，当您的域和应用程序需要识别结构复杂的对象时，OWL2EL会大放异彩。这些领域包括系统配置、产品清单和许多科学领域。

除了否定和析取之外，OWL 2 EL还不允许对属性进行通用量化。因此，诸如“富人的所有孩子都富有”之类的命题无法表述。此外，由于无法使用各种角色反转，因此无法指定parentOf和childOf是彼此的反转。

EL首字母缩写反映了轮廓在所谓的EL描述逻辑家族中的基础[EL公司++]; 它们是主要提供变量存在量化的语言。

以下是使用OWL 2 EL中可用的一些典型建模功能的示例。

功能-样式语法
子类别(：父亲ObjectIntersectionOf（：男：父）)等价类(：父级对象SomeValuesFrom(：hasChild：个人))等价类（：缉毒人员对象有自己（：loves）)分离类（：母亲：父亲：YoungChild)子对象属性（ObjectPropertyChain（：hasFather:hasBrother）：有叔叔)否定对象属性断言（：hasDaughter（有女儿）：比尔：苏珊)
RDF/XML语法
<owl:Class rdf:about=“父亲”><rdfs:subClassOf><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Man”/><owl:Class rdf:about=“Parent”/></owl:intersectionOf></owl:Class></rdfs:subClassOf></owl:Class><owl:Class rdf:about=“Parent”><owl:equivalentClass><owl:限制><owl:onProperty rdf:about=“hasChild”/><owl:someValuesFrom rdf:resource=“Person”/></owl:限制></owl:equivalentClass></owl:Class><owl:Class rdf:about=“NarcisticPerson”><owl:equivalentClass><owl:限制><owl:onProperty rdf:resource=“loves”/><owl:hasSelf rdf:datatype=“http://www.w3.org/2001/XMLSchema#boolean">真的</owl:hasSelf></owl:限制></owl:equivalentClass></owl:Class><owl:AllDisjointClasss><owl:members rdf:parseType=“Collection”><owl:Class rdf:about=“母亲”/><owl:Class rdf:about=“父亲”/><owl:Class rdf:about=“YoungChild”/></owl:成员></owl:AllDisjointClasss><rdf:描述rdf:about=“hasUncle”><owl:propertyChainAxiom rdf:parseType=“Collection”><owl:ObjectProperty rdf:about=“hasFather”/><owl:ObjectProperty rdf:about=“hasBrother”/></owl:propertyChainAxiom></rdf:描述><owl:NegativePropertyAssertion><owl:sourceIndividual rdf:resource=“Bill”/><owl:assertionProperty rdf:resource=“hasDaughter”/><owl:target个人rdf:resource=“Susan”/></owl:NegativePropertyAssertion>
Turtle语法
：父rdfs:subClassOf[rdf:type owl:Class；owl:intersectionOf（：男：父）] .：父猫头鹰：equivalentClass[rdf：type owl：限制；owl:onProperty:hasChild；owl:someValuesFrom:Person] .：NarcisticPerson猫头鹰：等价类[rdf:type owl:限制；owl:onProperty:爱；猫头鹰：hasSelf-ttrue] .[]rdf：类型owl:AllDisjointClasss；猫头鹰：成员（：母亲：父亲：幼儿）。：has猫头鹰叔叔：propertyChainAxiom（：hasFather:hasBrother）。[]rdf：类型owl:NegativePropertyAssertion；owl:source个人：比尔；owl:assertionProperty:hasDaughter；猫头鹰：目标个人：苏珊。
曼彻斯特语法
班级：父亲子类别：男性和父母类别：父级等价物to：hasChild some人类别：缉毒人员等价物：爱自己退学类别：母亲、父亲、幼儿对象属性：hasUncle子财产链：hasFather o hasBrother个人：账单事实：没有女儿苏珊
OWL/XML语法
<子类><Class IRI=“父亲”/><对象交集><IRI=“Man”类/><IRI=“父级”/></ObjectIntersectionOf></SubClassOf><等价类><IRI=“父级”/><对象SomeValuesFrom><ObjectProperty IRI=“hasChild”/><Class IRI=“个人”/></ObjectSomeValuesFrom></等价类><等价类><IRI=“缉毒人员”/><对象具有自身><ObjectProperty IRI=“loves”/></对象具有自身></等价类><分离类><Class IRI=“父亲”/><IRI类=“母亲”/><Class IRI=“YoungChild”/></DisjointClasss><子对象属性><对象属性链><ObjectProperty IRI=“hasFather”/><ObjectProperty IRI=“hasBrother”/></ObjectPropertyChain><ObjectProperty IRI=“hasUncle”/></SubObjectPropertyOf><否定对象属性断言><ObjectProperty IRI=“hasDaughter”/><Named个人IRI=“账单”/><Named个人IRI=“Susan”/></NegativeObjectPropertyAssertion>

10.2 OWL 2 QL

OWL 2 QL可以使用标准关系数据库技术（例如SQL）实现，只需根据类公理扩展查询即可。这意味着它可以与RDBMS紧密集成，并从其强大的实现和多用户功能中受益。此外，它可以在不必“接触数据”的情况下实现，实际上是一个转换/预处理层。从表达上来说，它可以表示实体关系图和UML图（至少是那些有功能限制的图）的关键特性。因此，它既适用于表示数据库模式，也适用于通过查询重写集成它们。因此，它也可以直接用作高级数据库模式语言，尽管用户可能更喜欢基于图的语法。

OWL 2 QL还捕获了RDFS中的许多常用功能及其小扩展，例如反向属性和子属性层次结构。OWL 2 QL非对称地限制类公理，也就是说，可以将构造用作不能用作超类的子类。

在其他构造中，OWL 2 QL不允许对类表达式进行角色的存在量化，例如，可以声明每个人都有一个父对象，但不是每个人都具有一个母对象。此外，不支持属性链公理和等式。

QL首字母缩写反映了这样一个事实，即可以通过将查询重写为标准关系查询语言来实现此概要文件中的查询应答[DL-Lite（DL-Lite）].

下面是一个使用OWL 2 QL中可用的一些典型建模功能的示例。第一条公理指出，每个没有孩子的人都是一个不存在第一个作为父母的人的人。

功能-样式语法
SubClassOf（子类：无子女人士对象交集(：个人对象补足(对象SomeValuesFrom(对象反转（：hasParent）猫头鹰：东西)))) 分离类（：母亲：父亲：YoungChild)DisjointObject属性（：hasSon：hasDaughter（有女儿）)子对象属性（：hasFather（父亲）：hasParent)
RDF/XML语法
<owl:Class rdf:about=“无子女人士”><rdfs:subClassOf><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Person”/><owl:Class><owl:complementOf><owl:限制><owl:onProperty><owl:ObjectProperty><owl:inverseOf rdf:resource=“hasParent”/></owl:ObjectProperty></owl:onProperty><owl:someValuesFrom rdf:resource=“Person”/></owl:限制></owl:complementOf></owl:Class></owl:intersectionOf></owl:Class></rdfs:subClassOf></owl:Class><owl:AllDisjointClasss><owl:members rdf:parseType=“Collection”><owl:Class rdf:about=“母亲”/><owl:Class rdf:about=“父亲”/><owl:Class rdf:about=“YoungChild”/></owl:成员></owl:AllDisjointClasss><owl:ObjectProperty rdf:about=“hasSon”><owl:propertyDisjointWith rdf:resource=“hasDaughter”/></owl:ObjectProperty><owl:ObjectProperty rdf:about=“hasFather”><rdfs:subPropertyOf rdf:resource=“hasParent”/></owl:ObjectProperty>
Turtle语法
：ChildlessPerson owl:subClassOf[rdf:type owl:Class；owl:intersectionOf（：个人[owl:补语Of[rdf：type owl：限制；owl:onProperty[owl:inverseOf:hasParent]；猫头鹰：一些价值来自猫头鹰]])] .[]rdf：类型owl:AllDisjointClasss；猫头鹰：成员（：母亲：父亲：幼儿）。：hasSon-owl:propertyDisjointWith：hasDaughter。：hasFather rdfs:subPropertyOf:hasParent。
曼彻斯特语法
班级：无子女人士SubClassOf：人与非（逆hasParent some owl:Thing）退学类别：母亲、父亲、幼儿分离属性：hasSon，hasDaughter对象属性：hasFather子属性：hasParent
OWL/XML语法
<子类><Class IRI=“无子女人士”/><对象交集><Class IRI=“个人”/><对象补充><对象SomeValuesFrom><对象反转><ObjectProperty IRI=“hasParent”/></对象反转><类缩写IRI=“owl:Thing”/></ObjectSomeValuesFrom></ObjectComplementOf></ObjectIntersectionOf></SubClassOf><分离类><Class IRI=“父亲”/><IRI类=“母亲”/><Class IRI=“YoungChild”/></DisjointClasss><分离对象属性><ObjectProperty IRI=“hasSon”/><ObjectProperty IRI=“hasDaughter”/></DisjointObjectProperties><子对象属性><ObjectProperty IRI=“hasFather”/><ObjectProperty IRI=“hasParent”/></SubObjectPropertyOf>

10.3 OWL 2 RL（降液阀2 RL）

OWL 2 RL配置文件的目标是需要可扩展推理而不牺牲太多表达能力的应用程序。它的设计目的是适应OWL 2应用程序，这些应用程序可以用语言的完整表达能力换取效率，也可以适应RDF（S）应用程序，它们需要从OWL 2中增加一些表达能力。这是通过定义OWL 2的语法子集来实现的，该子集适用于使用基于规则的技术实现，并以一阶含义的形式呈现OWL 2中语义的部分公理化，可以用作实现的基础。

基于RDF-based Semantics的OWL 2 RL的合适的基于规则的实现可以用于任意RDF图。因此，OWL2RL非常适合于丰富RDF数据，尤其是当数据必须由其他规则进行信息传递时。然而，从建模的角度来看，这使我们远离了使用类表达式：OWL 2 RL确保了我们不能（轻松地）谈论超类表达式中的未知个体（这种限制来自于规则的本质）。与OWL2QL相比，当您已经将数据转换为RDF并将其作为RDF使用时，OWL2RL工作得更好。

在其他构造中，OWL 2 RL不允许个人的存在强制另一个人的存在的语句：例如，“每个人都有父母”的语句在OWL RL中是不可表达的。

OWL 2 RL不对称地限制类公理，也就是说，您可以将构造用作不能用作超类的子类。

RL首字母缩略词反映了这样一个事实，即可以使用标准规则语言实现此概要文件中的推理[DLP公司].

下面是一个使用OWL 2 RL中可用的一些典型建模功能的示例。第一个公理（有点做作）指出，对于玛丽、比尔和梅格中的每一位女性来说，下面的说法是：她是至多有一个孩子的父母，她所有的孩子（如果她有孩子的话）都是女性。

功能-样式语法
子类别(对象交集(对象之一（：玛丽：比尔：梅格）：女性)对象交集(：父级对象最大基数（1:hasChild）ObjectAllValuesFrom（：hasChild：女性）))分离类（：母亲：父亲：YoungChild)子对象属性（ObjectPropertyChain（：hasFather:hasBrother）：有叔叔)
RDF/XML语法
<owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class><owl:oneOf rdf:parseType=“Collection”><rdf:描述rdf:about=“Mary”/><rdf:描述rdf:about=“Bill”/><rdf:描述rdf:about=“Meg”/></owl:oneOf></owl:Class><owl:Class rdf:about=“Female”/></owl:intersectionOf><rdfs:subClassOf><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Parent”/><owl:限制><owl:maxCardinality rdf:datatype=“http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:maxCardinality><owl:onProperty rdf:resource=“hasChild”/></owl:限制><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:allValuesFrom rdf:resource=“Female”/></owl:限制></owl:intersectionOf></owl:Class></rdfs:subClassOf></owl:Class><owl:AllDisjointClasss><owl:members rdf:parseType=“Collection”><owl:Class rdf:about=“母亲”/><owl:Class rdf:about=“父亲”/><owl:Class rdf:about=“YoungChild”/></owl:成员></owl:AllDisjointClasss><rdf:描述rdf:about=“hasUncle”><owl:propertyChainAxiom rdf:parseType=“Collection”><owl:ObjectProperty rdf:about=“hasFather”/><owl:ObjectProperty rdf:about=“hasBrother”/></owl:propertyChainAxiom></rdf:描述>
Turtle语法
[]rdf：类型owl：类；owl:intersectionOf（[rdf:type owl:Class；猫头鹰：oneOf（：玛丽：比尔：梅格）]：女性) ;rdfs:subClassOf[rdf:type owl:Class；owl:intersectionOf（：父对象[rdf:type owl:限制；owl:maxCardinality“1”^^xsd:nonNegativeInteger；owl:onProperty:hasChild][rdf:type owl:限制；owl:onProperty:hasChild；owl:allValuesFrom:Female])] .[]rdf：类型owl:AllDisjointClasss；猫头鹰：成员（：母亲：父亲：幼儿）。：has猫头鹰叔叔：propertyChainAxiom（：hasFather:hasBrother）。
曼彻斯特语法
类别：XSubClassOf：父级和hasChild最多1个，仅限hasChilld女性类别：X等同于：{玛丽、比尔、梅格}和女性退学类别：母亲、父亲、幼儿对象属性：hasUncle子财产链：hasFather o hasBrother
OWL/XML语法
<子类><对象交集>＜ObjectOneOf＞<Named个人IRI=“玛丽”/><Named个人IRI=“账单”/><Named个人IRI=“Meg”/></ObjectOneOf><IRI级=“女性”/></ObjectIntersectionOf><对象交集><IRI=“父级”/><ObjectMaxCardinality基数=“1”><ObjectProperty IRI=“hasChild”/></ObjectMaxCardinality><对象所有值自><ObjectProperty IRI=“hasChild”/><IRI级=“女性”/></ObjectAllValuesFrom></ObjectIntersectionOf></SubClassOf><分离类><Class IRI=“父亲”/><IRI类=“母亲”/><Class IRI=“YoungChild”/></DisjointClasss><子对象属性><对象属性链><ObjectProperty IRI=“hasFather”/><ObjectProperty IRI=“hasBrother”/></ObjectPropertyChain><ObjectProperty IRI=“hasUncle”/></SubObjectPropertyOf>

11 OWL工具

为了使用OWL本体，工具支持至关重要。基本上，有两种类型的工具用于解决本体生命周期的两个主要阶段：本体编辑器用于创建和编辑本体，而推理者用于查询本体以获取隐含知识，即，它们确定所讨论的语句是否是本体的逻辑结果。

目前使用最广泛的OWL编辑器是普罗泰格，一个由斯坦福大学开发的免费开源编辑框架。凭借其开放式插件结构，它允许轻松集成特殊用途的本体编辑组件。其他编辑包括TopQuadrant的广告TopBraid编写器以及开源系统俯冲和NeOn-Toolkit公司.

OWL DL有几个推理器，它们在支持的推理功能的覆盖范围方面有所不同。对于其中的一些，OWL 2一致性目前正在规划中，相应的实现正在进行中。这个测试套件状态文档列出了下面提到的一些推理在何种程度上符合测试用例。

对于OWL DL中的推理，最突出的系统是事实++曼彻斯特大学，隐士牛津大学计算实验室，弹丸由Clark&Parsia，LLC和RacerPro赛车由Racer Systems提供。

除了那些旨在支持所有OWL DL的通用推理机之外，还有一些为OWL的可处理轮廓量身定制的推理系统。CEL公司德累斯顿理工大学支持OWL EL。昆托罗马大学支持OWL QL。甲骨文11克支持OWL RL。

开源OWL API作为目前围绕OWL最重要的开发工具，它发挥着相当突出的作用。

必须提到的是，在创建本文档时，几个OWL工具正在开发中，因此当前的概述应视为此开发的快照，而不是最新的概述。OWL工具的大量列表可以在semanticweb.org网站和在ESW-维基.

12下一步阅读内容

这种短底漆只能刮伤OWL的表面。有很多关于OWL和如何使用的更长、更复杂的教程可以通过在Web上搜索找到的OWL工具。阅读其中一个文档并使用工具构建OWL本体可能是获得OWL工作知识的最佳方式。为了学习关于OWL的基础，我们建议首先查阅教科书[FOST公司]然后是其中引用的原始文章。OWL 2配置文件的扩展介绍可以在中找到[OWL 2配置文件简介],也可以在Web上找到。

这个简短的引物也不是OWL的标准定义。OWL语法的规范定义以及信息每个OWL构造的含义的描述可以在OWL 2结构规范和功能语法文件[OWL 2规范].

OWL 2快速参考指南[OWL 2快速指南]在查找有关特定语言功能的信息时，可以方便地作为参考。

对于那些对更正式的文件感兴趣的人，OWL2的形式意义可以在OWL2语义文档中找到[OWL 2直接语义] [基于OWL 2 RDF的语义].

OWL语法和RDF三元组之间的映射可以在中找到OWL 2映射到RDF图文档[OWL 2 RDF映射].

13附录：完整的样本本体

这里我们包括完整的OWL本体示例。本体论公理是按照它们所使用的顶级表达特征排序的。此外，我们遵循一种通用的顺序，首先是本体和声明信息，然后是属性信息，然后才是类和数据类型，最后是个人。


功能-样式语法
前缀（：=<http://example.com/owl/families/>)前缀（otherOnt:=<http://example.org/otherOntologies/families网站/>)前缀（xsd:=<http://www.w3.org/2001/XMLSchema#>)前缀（owl：=<http://www.w3.org/2002/07/owl#>)本体论(<http://example.com/owl/families>导入（<http://example.org/otherOntologies/families.owl> )声明（具名个人（：John））声明（具名个人（：玛丽））声明（具名个人（：Jim））声明（具名个人（：James））声明（具名个人（：杰克））声明（具名个人（：账单））声明（具名个人（：Susan））申报（类别（：人））AnnotationAssertion（rdfs:comment:Person“表示所有人的集合。”）声明（类别（：女性））声明（类别（：父级））声明（类别（：父亲））声明（班级（：母亲））声明（班级（：社会角色））声明（类别（：人））申报（班级（：青少年））声明（类别（：无子女人士））宣言（阶级（：人类））声明（类别（：女性））声明（类（：HappyPerson））宣言（班级（：JohnsChildren））声明（类别（：缉毒人员））声明（类别（：MyBirthdayGuests））声明（类别（：死亡））声明（类别（：孤儿））声明（班级（：成人））声明（班级（：幼儿））声明（ObjectProperty（：hasWife））声明（ObjectProperty（：hasChild））声明（ObjectProperty（：hasDaughter））声明（ObjectProperty（：loves））声明（ObjectProperty（：hasSpouse））声明（ObjectProperty（：hasGrandparent））声明（ObjectProperty（：hasParent））声明（ObjectProperty（：hasBrother））声明（ObjectProperty（：hasUncle））声明（ObjectProperty（：hasSon））声明（ObjectProperty（：hasAncestor））声明（ObjectProperty（：hasband））声明（DataProperty（：hasAge））声明（DataProperty（：hasSSN））声明（数据类型（：personAge））声明（数据类型（：minorAge））声明（数据类型（：majorAge））声明（数据类型（：toddlerAge））子对象属性（：hasWife:hasSpouse）子对象属性(ObjectPropertyChain（：hasParent:hasParent）：has祖父母)子对象属性(ObjectPropertyChain（：hasFather:hasBrother）：有叔叔)子对象属性(：hasFather（父亲）：hasParent)等价对象属性（：hasChild otherOnt:child）反向对象属性（：hasParent:hasChild）等价数据属性（：hasAge otherOnt:age）DisjointObjectProperties（：hasSon:hasDaughter）ObjectPropertyDomain（：hasWife:男子）ObjectPropertyRange（：有妻子：女人）DataPropertyDomain（：hasAge:个人）DataPropertyRange（：hasAge xsd:nonNegativeInteger）对称对象属性（：hasSpouse）不对称对象属性（：hasChild）DisjointObjectProperties（：hasParent:hasSpouse）ReflexiveObjectProperty（：hasRelative）无反射对象属性（：parentOf）功能对象属性（：hasband）反函数对象属性（：hasband）TransitiveObjectProperty（：hasAncestor）函数数据属性（：hasAge）SubClassOf（：女人：人）SubClassOf（：母亲：女人）子类别(：祖父ObjectIntersectionOf（：男：父）)子类别(：青少年数据房屋值来自（：hasAge数据类型限制（xsd:integerxsd:minExclusive“12”^^xsd:integerxsd:maxInclusive“19”^^xsd:integer)))子类别(注释（rdfs:comment“声明每个人都是一个人”）：男：个人)子类别(：父亲ObjectIntersectionOf（：男：父）)子类别(：无子女人士对象交集(：个人对象补足(对象SomeValuesFrom(对象反转（：hasParent）猫头鹰：东西))))子类别(对象交集(对象之一（：玛丽：比尔：梅格）：女性)对象交集(：父级对象最大基数（1:hasChild）ObjectAllValuesFrom（：hasChild：女性）))等价类（：人：人）等价类(：母亲ObjectIntersectionOf（：女性：父母）)等价类(：父级ObjectUnionOf（：母亲：父亲）)等价类(：无子女人士对象交集(：个人ObjectComplementOf（：父级）))等价类(：父级ObjectSomeValuesFrom（：hasChild:人）)等价类(：快乐人士对象交集(ObjectAllValuesFrom（：hasChild:HappyPerson）ObjectSomeValuesFrom（：hasChild:HappyPerson）))等价类(：约翰儿童ObjectHasValue（：hasParent:John）)等价类(：缉毒人员ObjectHasSelf（：爱）)等价类(：我的生日客人对象一（：比尔：约翰：玛丽）)等价类(：孤儿对象所有值来自(对象反转（：hasChild）：已死亡))等价类（：成人其他Ont:成人）等价类(：父级对象SomeValuesFrom(：hasChild：个人))脱课（女：男）解散类别(：母亲：父亲：YoungChild)HasKey（：个人（）（：hasSSN））数据类型定义(：personAge数据类型限制（xsd:integerxsd:minInclusive“0”^^xsd:integerxsd:maxInclusive“150”^^xsd:integer))数据类型定义(：minor年龄数据类型限制（xsd:integerxsd:minInclusive“0”^^xsd:integerxsd:maxInclusive“18”^^xsd:integer))数据类型定义(：专业年龄数据交叉点(：personAge数据补充（：minorAge）))数据类型定义(：幼儿年龄DataOneOf（“1”^^xsd:integer“2”^^xsd:integer）)ClassAssertion（：人员：Mary）课堂断言（：女人：玛丽）类断言(对象交集(：个人ObjectComplementOf（：父级）)：杰克)类断言(对象最大基数（4:hasChild：父对象）：约翰)类断言(ObjectMinCardinality（2:hasChild：父对象）：约翰)类断言(对象精确基数（3:hasChild：父对象）：约翰)类断言(对象精确基数（5:hasChild）：约翰)ClassAssertion（：父亲：John）ClassAssertion（：社交角色：父亲）ObjectPropertyAssertion（：has妻子：约翰：玛丽）否定对象属性断言（：hasWife：Bill：Mary）否定对象属性断言(：has女儿：比尔：苏珊)DataPropertyAssertion（：hasAge:John“51”^^xsd:integer）否定数据属性断言（：hasAge:Jack“53”^^xsd:integer）同一个人（：詹姆斯：吉姆）同一个人（：John otherOnt:John Brown）同一个人（：Mary otherOnt:Mary Brown）不同的个人（：约翰：比尔）)
RDF/XML语法
<!DOCTYPE rdf:rdf[<!实体猫头鹰“http://www.w3.org/2002/07/owl#" ><!实体xsd“http://www.w3.org/2001/XMLSchema#" ><!实体rdfs“http://www.w3.org/2000/01/rdf-schema#" ><!其他实体”http://example.org/otherOntologies/families网站/" >]><rdf:rdf xml:base=“http://example.com/owl/families/"xmlns=“http://example.com/owl/families/"xmlns:otherOnt=“http://example.org/otherOntologies/families网站/"xmlns:owl=“http://www.w3.org/2002/07/owl#"xmlns:rdfs=“http://www.w3.org/2000/01/rdf-schema#"xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#"xmlns:xsd=“http://www.w3.org/2001/XMLSchema#"><owl:Ontology rdf:about=“http://example.com/owl/families"><owl:imports rdf:resource=“http://example.org/otherOntologies/families.owl" /></owl:本体><owl:ObjectProperty rdf:about=“hasWife”><rdfs:subPropertyOf rdf:resource=“hasSpouse”/><rdfs:domain rdf:resource=“Man”/><rdfs:range rdf:resource=“Woman”/></owl:ObjectProperty><owl:ObjectProperty rdf:about=“hasParent”><owl:inverseOf rdf:resource=“hasChild”/><owl:propertyDisjointWith rdf:resource=“hasSpouse”/></owl:ObjectProperty><owl:ObjectProperty rdf:about=“hasSon”><owl:propertyDisjointWith rdf:resource=“hasDaughter”/></owl:ObjectProperty><owl:ObjectProperty rdf:about=“hasFather”><rdfs:subPropertyOf rdf:resource=“hasParent”/></owl:ObjectProperty><owl:SymmetricProperty rdf:about=“hasSpouse”/>＜owl:AsymmetricProperty rdf:about=“hasChild”/><owl:ReflexiveProperty rdf:about=“hasRelative”/><owl:IrreflectiveProperty rdf:about=“parentOf”/><owl:FunctionalProperty rdf:about=“hasHusband”/>功能属性<owl:Inverse FunctionalProperty rdf:about=“hasHusband”/>反向功能属性<owl:TransitiveProperty rdf:about=“hasAncestor”/><rdf:描述rdf:about=“hasGrandparent”><owl:propertyChainAxiom rdf:parseType=“Collection”>＜owl:ObjectProperty rdf:about=“hasParent”/>＜owl:ObjectProperty rdf:about=“hasParent”/></owl:propertyChainAxiom></rdf:描述><rdf:描述rdf:about=“hasUncle”><owl:propertyChainAxiom rdf:parseType=“Collection”><owl:ObjectProperty rdf:about=“hasFather”/><owl:ObjectProperty rdf:about=“hasBrother”/></owl:propertyChainAxiom></rdf:描述><owl:ObjectProperty rdf:about=“hasChild”><owl:equivalentProperty rdf:resource=“&otherOnt；child”/></owl:ObjectProperty><owl:DatatypeProperty rdf:about=“hasAge”><rdfs:domain rdf:resource=“Person”/><rdfs:range rdf:resource=“&xsd；nonNegativeInteger”/><owl:equivalentProperty rdf:resource=“&otherOnt；age”/></owl:DatatypeProperty><owl:FunctionalProperty rdf:about=“hasAge”/><owl:Class rdf:about=“Woman”><rdfs:subClassOf rdf:resource=“Person”/></owl:Class>＜owl:Class rdf:about=“母亲”＞<rdfs:subClassOf rdf:resource=“Woman”/><owl:equivalentClass><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Woman”/><owl:Class rdf:about=“Parent”/></owl:intersectionOf></owl:Class></owl:equivalentClass></owl:Class>＜owl:Class rdf:about=“Person”＞<rdfs:comment>表示所有人的集合</rdfs:注释><owl:equivalentClass rdf:resource=“Human”/><owl:hasKey rdf:parseType=“Collection”><owl:DataProperty rdf:about=“hasSSN”/></owl:hasKey></owl:Class><owl:Class rdf:about=“Parent”><owl:equivalentClass><owl:Class><owl:unionOf rdf:parseType=“Collection”><owl:Class rdf:about=“母亲”/><owl:Class rdf:about=“父亲”/></owl:unionOf></owl:Class></owl:equivalentClass><owl:equivalentClass><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:someValuesFrom rdf:resource=“Person”/></owl:限制></owl:equivalentClass></owl:Class><owl:Class rdf:about=“无子女人士”><owl:equivalentClass><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Person”/><owl:Class><owl:complementOf rdf:resource=“Parent”/></owl:Class></owl:intersectionOf></owl:Class></owl:equivalentClass></owl:Class><owl:Class rdf:about=“祖父”><rdfs:subClassOf><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Man”/><owl:Class rdf:about=“Parent”/></owl:intersectionOf></owl:Class></rdfs:subClassOf></owl:Class><owl:Class rdf:about=“HappyPerson”><owl:equivalentClass><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:allValuesFrom rdf:resource=“HappyPerson”/></owl:限制><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:someValuesFrom rdf:resource=“HappyPerson”/></owl:限制></owl:intersectionOf></owl:Class></owl:equivalentClass></owl:Class><owl:Class rdf:about=“JohnsChildren”><owl:equivalentClass><owl:限制><owl:onProperty rdf:resource=“hasParent”/><owl:hasValue rdf:resource=“John”/></owl:限制></owl:equivalentClass></owl:Class><owl:Class rdf:about=“NarcisticPerson”><owl:equivalentClass><owl:限制><owl:onProperty rdf:resource=“loves”/><owl:hasSelf-rdf:datatype=“&xsd；boolean”>真的</owl:hasSelf></owl:限制></owl:equivalentClass></owl:Class>＜owl:Class rdf:about=“MyBirthdayGuests”＞<owl:equivalentClass><owl:Class><owl:oneOf rdf:parseType=“Collection”><rdf:描述rdf:about=“Bill”/><rdf:描述rdf:about=“John”/><rdf:描述rdf:about=“Mary”/></owl:oneOf></owl:Class></owl:equivalentClass></owl:Class><owl:Class rdf:about=“孤儿”><owl:equivalentClass><owl:限制><owl:onProperty><owl:ObjectProperty><owl:inverseOf rdf:resource=“hasChild”/></owl:ObjectProperty></owl:onProperty><owl:allValuesFrom rdf:resource=“死”/></owl:限制></owl:equivalentClass></owl:Class><owl:Class rdf:about=“青少年”><rdfs:subClassOf><owl:限制><owl:onProperty rdf:resource=“hasAge”/><owl:someValuesFrom><rdfs:数据类型><owl:onDatatype rdf:resource=“&xsd；integer”/><owl:withRestrictions rdf:parseType=“Collection”><rdf:说明><xsd:minExclusive rdf:datatype=“&xsd；integer”>12</rdf:描述><rdf:说明><xsd:maxInclusive rdf:datatype=“&xsd；integer”>19</xsd:maxInclusive></rdf:描述></owl:有限制></rdfs:数据类型></owl:someValuesFrom></owl:限制></rdfs:subClassOf></owl:Class><owl:Class rdf:about=“Man”><rdfs:subClassOf rdf:resource=“Person”/></owl:Class><owl:公理><owl:annotatedSource rdf:resource=“Man”/><owl:annotatedProperty rdf:resource=“&rdfs；subClassOf”/><owl:annotatedTarget rdf:resource=“Person”/><rdfs:comment>指出每个人都是一个人</rdfs:注释></owl:Axiom><owl:Class rdf:about=“成人”><owl:equivalentClass rdf:resource=“&otherOnt；成长”/></owl:Class><owl:Class rdf:about=“父亲”><rdfs:subClassOf><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Man”/><owl:Class rdf:about=“Parent”/></owl:intersectionOf></owl:Class></rdfs:subClassOf></owl:Class><owl:Class rdf:about=“无子女人士”><rdfs:subClassOf><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Person”/><owl:Class><owl:complementOf><owl:限制><owl:onProperty><owl:ObjectProperty><owl:inverseOf rdf:resource=“hasParent”/></owl:ObjectProperty></owl:onProperty><owl:someValuesFrom rdf:resource=“&owl；Thing”/></owl:限制></owl:complementOf></owl:Class></owl:intersectionOf></owl:Class></rdfs:subClassOf></owl:Class><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class><owl:oneOf rdf:parseType=“Collection”><rdf:描述rdf:about=“Mary”/><rdf:描述rdf:about=“Bill”/><rdf:描述rdf:about=“Meg”/></owl:oneOf></owl:Class><owl:Class rdf:about=“Female”/></owl:intersectionOf><rdfs:subClassOf><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Parent”/><owl:限制><owl:maxCardinality rdf:datatype=“&xsd；nonNegativeInteger”>1</owl:maxCardinality><owl:onProperty rdf:resource=“hasChild”/></owl:限制><owl:限制><owl:onProperty rdf:resource=“hasChild”/><owl:allValuesFrom rdf:resource=“Female”/></owl:限制></owl:intersectionOf></owl:Class></rdfs:subClassOf></owl:Class><owl:AllDisjointClasss><owl:members rdf:parseType=“Collection”><owl:Class rdf:about=“Woman”/><owl:Class rdf:about=“Man”/></owl:成员></owl:AllDisjointClasss><owl:AllDisjointClasss><owl:members rdf:parseType=“Collection”><owl:Class rdf:about=“母亲”/><owl:Class rdf:about=“父亲”/><owl:Class rdf:about=“YoungChild”/></owl:成员></owl:AllDisjointClasss><rdf:描述rdf:about=“personAge”><owl:equivalentClass><rdfs:数据类型><owl:onDatatype rdf:resource=“&xsd；integer”/><owl:withRestrictions rdf:parseType=“Collection”><rdf:说明><xsd:minInclusive rdf:datatype=“&xsd；integer”>0</xsd:minInclusive></rdf:描述><rdf:说明><xsd:maxInclusive rdf:datatype=“&xsd；integer”>150</rdf:描述></owl:有限制></rdfs:数据类型></owl:equivalentClass></rdf:描述><rdf:描述rdf:about=“minorAge”><owl:equivalentClass><rdfs:数据类型><owl:onDatatype rdf:resource=“&xsd；integer”/><owl:withRestrictions rdf:parseType=“Collection”><rdf:说明><xsd:minInclusive rdf:datatype=“&xsd；integer”>0</xsd:minInclusive></rdf:描述><rdf:说明><xsd:maxInclusive rdf:datatype=“&xsd；integer”>18</xsd:maxInclusive></rdf:描述></owl:有限制></rdfs:数据类型></owl:equivalentClass></rdf:描述><rdf:描述rdf:about=“majorAge”><owl:equivalentClass><rdfs:数据类型><owl:intersectionOf rdf:parseType=“Collection”><rdf:描述rdf:about=“personAge”/><rdfs:数据类型><owl:datatypeComplementOf rdf:resource=“minorAge”/></rdfs:数据类型></owl:intersectionOf></rdfs:数据类型></owl:equivalentClass></rdf:描述><rdf:描述rdf:about=“幼儿年龄”><owl:equivalentClass><rdfs:数据类型><owl:oneOf><rdf:说明><rdf:first-rdf:datatype=“&xsd；integer”>1<rdf:rest><rdf:说明><rdf:first-rdf:datatype=“&xsd；integer”>2<rdf:rest rdf:resource=“http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/></rdf:描述></rdf:rest></rdf:描述></owl:oneOf></rdfs:数据类型></owl:equivalentClass></rdf:描述><人物rdf:about=“Mary”><rdf:type rdf:resource=“Woman”/><owl:sameAs-rdf:resource=“&otherOnt；MaryBrown”/></人><owl:Named个人rdf:about=“James”><owl:sameAs-rdf:resource=“Jim”/></owl:NamedIndividual><rdf:描述rdf:about=“Jack”><rdf:type><owl:Class><owl:intersectionOf rdf:parseType=“Collection”><owl:Class rdf:about=“Person”/><owl:Class><owl:complementOf rdf:resource=“Parent”/></owl:Class></owl:intersectionOf></owl:Class></rdf:type></rdf:描述><owl:Named个人rdf:about=“John”><hasWife rdf:resource=“玛丽”/><hasAge rdf:datatype=“&xsd；integer”>51</hasAge><owl:differentFrom-rdf:resource=“Bill”/><owl:sameAs-rdf:resource=“&otherOnt；JohnBrown”/><rdf:type rdf:resource=“父亲”/><rdf:type><owl:限制><owl:maxQualifiedCardinality rdf:datatype=“&xsd；nonNegativeInteger”>4</owl:maxQualifiedCardinality><owl:onProperty rdf:resource=“hasChild”/><owl:onClass rdf:resource=“Parent”/></owl:限制></rdf:type><rdf:type><owl:限制><owl:minQualifiedCardinality rdf:datatype=“&xsd；nonNegativeInteger”>2</owl:minQualifiedCardinality><owl:onProperty rdf:resource=“hasChild”/><owl:onClass rdf:resource=“Parent”/></owl:限制></rdf:type><rdf:type><owl:限制>＜owl:qualifiedCardinality rdf:datatype=“&xsd；nonNegativeInteger”＞三</owl:合格基数><owl:onProperty rdf:resource=“hasChild”/><owl:onClass rdf:resource=“Parent”/></owl:限制></rdf:type><rdf:type><owl:限制><owl:cardinality rdf:datatype=“&xsd；nonNegativeInteger”>5</owl:基数><owl:onProperty rdf:resource=“hasChild”/></owl:限制></rdf:type></owl:NamedIndividual><SocialRole rdf:about=“父亲”/><owl:NegativePropertyAssertion><owl:sourceIndividual rdf:resource=“Bill”/><owl:assertionProperty rdf:resource=“hasWife”/><owl:target个人rdf:resource=“Mary”/></owl:NegativePropertyAssertion><owl:NegativePropertyAssertion><owl:sourceIndividual rdf:resource=“Jack”/><owl:assertionProperty rdf:resource=“hasAge”/><owl:targetValue rdf:datatype=“&xsd；integer”>53</owl:NegativePropertyAssertion><owl:NegativePropertyAssertion><owl:sourceIndividual rdf:resource=“Bill”/><owl:assertionProperty rdf:resource=“hasDaughter”/><owl:target个人rdf:resource=“Susan”/></owl:NegativePropertyAssertion></rdf:rdf>
Turtle语法
@前缀：<http://example.com/owl/families/> .@前缀otherOnt:<http://example.org/otherOntologies/families网站/> .@前缀owl:<http://www.w3.org/2002/07/owl#> .@前缀rdfs：<http://www.w3.org/2000/01/rdf-schema#> .@前缀rdf：<http://www.w3.org/1999/02/22-rdf-syntax-ns#> .@前缀xsd:<http://www.w3.org/2001/XMLSchema#> .<http://example.com/owl/families> rdf：类型owl：本体；owl:导入<http://example.org/otherOntologies/families.owl> .：hasSpouse rdf：键入owl:SymmetricProperty。：hasRelative rdf：类型owl:ReflexiveProperty。：parentOf rdf：类型owl:IrreflexiveProperty。：hasAncestor rdf：类型owl:TransitiveProperty。：hasband rdf：键入owl:FunctionalProperty。：hasband rdf：类型owl:InverseFunctionalProperty。：hasWife rdf：键入owl:ObjectProperty。：hasWife rdfs：域：男子；rdfs：范围：女性。：hasWife rdfs：subPropertyOf：hasSpouse。：hasSon-owl:propertyDisjointWith：hasDaughter。：hasFather rdfs:subPropertyOf:hasParent。：hasParent owl：inverseOf：hasChild。：hasParent owl:propertyDisjointWith:hasSpouse。：hasGrandparent owl:propertyChainAxiom（：hasParent:hasParent）。：has猫头鹰叔叔：propertyChainAxiom（：hasFather:hasBrother）。：hasAge owl:equivalentProperty otherOnt:age。：hasAge rdf:type owl:DatatypeProperty。：hasAge rdf：键入owl:FunctionalProperty。：hasAge rdfs:domain:Person；rdfs:range xsd:nonNegativeInteger。：hasChild owl:equivalentProperty otherOnt:child。：hasChild rdf:type owl:AsymmetricProperty。：女性rdfs:subClassOf：人。：母亲rdfs:subClassOf：女人。：猫头鹰妈妈：等价类[rdf:type owl:Class；owl:intersectionOf（：女人：父母）] .：Person rdf:type owl:Class。：个人猫头鹰：等价类：人类。：Person rdfs:comment“代表所有人的集合。”^^xsd:string。：个人owl:hasKey（：hasSSN）。：hasSSN rdf：类型owl:DataProperty。：父猫头鹰：equivalentClass[rdf:type owl:Class；owl:unionOf（：母亲：父亲）] .：父猫头鹰：equivalentClass[rdf：type owl：限制；owl:onProperty:hasChild；owl:someValuesFrom:Person] .：祖父rdfs:subClassOf[rdf:type owl:Class；owl:intersectionOf（：男：父）] .：快乐的人owl：等价类[rdf:type owl:Class；owl:intersectionOf（[rdf:type owl:Restriction；owl:onProperty:hasChild；owl:allValuesFrom:HappyPerson][rdf:type owl:限制；owl:onProperty:hasChild；owl:someValuesFrom:HappyPerson])] .：约翰儿童猫头鹰：等价类[rdf:type owl:限制；owl:onProperty:hasParent；owl:hasValue:约翰] .：NarcisticPerson猫头鹰：等价类[rdf:type owl:限制；owl:onProperty:爱；owl:hasSelf“true”^^xsd:boolean。] .：MyBirthdayGuests owl:equivalentClass[rdf:type owl:Class；猫头鹰：oneOf（：比尔：约翰：玛丽）] .：孤儿猫头鹰：等价类[rdf：type owl：限制；owl:onProperty[owl:inverseOf:hasChild]；owl:allValuesFrom:死] .：青少年rdfs:subClassOf[rdf:type owl:限制；owl:onProperty:hasAge；owl:someValuesFrom[rdf:type rdfs:数据类型；owl:onDatatype xsd:integer；owl:带限制（[xsd:minExclusive“12”^^xsd:integer][xsd:maxInclusive“19”^^xsd:integer])]] .：Man rdfs:subClassOf:Person。[]rdf：类型owl：Axiom；owl:annotatedSource:Man；owl:annotatedProperty rdfs:subClassOf；owl:annotatedTarget:Person；rdfs:comment“声明每个人都是一个人。”^^xsd:string。：成年猫头鹰：等价类otherOnt：成年。：父rdfs:subClassOf[rdf:type owl:Class；owl:intersectionOf（：男：父）] .：ChildlessPerson owl:equivalentClass[rdf:type owl:Class；owl:intersectionOf（：Person[owl:complementOf:Parent]）] .：无子女猫头鹰：subClassOf[rdf:type owl:Class；owl:intersectionOf（：个人[owl:补语Of[rdf：type owl：限制；owl:onProperty[owl:inverseOf:hasParent]；猫头鹰：一些价值来自猫头鹰]])] .[]rdf：类型owl：类；owl:intersectionOf（[rdf:type owl:Class；猫头鹰：oneOf（：玛丽：比尔：梅格）]：女性) ;rdfs:subClassOf[rdf:type owl:Class；owl:intersectionOf（：父对象[rdf:type owl:限制；owl:maxCardinality“1”^^xsd:nonNegativeInteger；owl:onProperty:hasChild][rdf:type owl:限制；owl:onProperty:hasChild；owl:allValuesFrom:Female])] .[]rdf：类型owl:AllDisjointClasss；猫头鹰：成员（：母亲：父亲：幼儿）。[]rdf：类型owl:AllDisjointClasss；猫头鹰：成员（：女人：男人）。：personAge owl:equivalentClass[rdf:type rdfs:Datatype；owl:onDatatype xsd:integer；owl:带限制([xsd:minInclusive“0”^^xsd:integer][xsd:maxInclusive“150”^^xsd:integer])] .
：minorAge owl:equivalentClass[rdf:type rdfs:Datatype；owl:onDatatype xsd:integer；owl:带限制([xsd:minInclusive“0”^^xsd:integer][xsd:maxInclusive“18”^^xsd:integer])] .
：majorAge猫头鹰：等效类[rdf:type rdfs:数据类型；owl:交集Of(：personAge[rdf:type rdfs:数据类型；owl:datatypeComplementOf:minorAge])] .：幼儿猫头鹰：等价类[rdf:type rdfs:数据类型；owl:oneOf（“1”^^xsd:integer“2”^^xsd:integer）] .：Mary rdf：类型：个人。：Mary rdf：类型：女人。：玛丽猫头鹰：和别人一样Ont:玛丽·布朗。詹姆斯·奥勒：相同As：吉姆。：Jack rdf：类型[rdf:type owl:Class；owl:intersectionOf（：个人[rdf:type owl:Class；owl:complementOf:父级])] .：John owl：与他人相同Ont：约翰布朗。：John rdf：键入owl:NamedIndividual。：John rdf：类型：父亲。约翰：妻子：玛丽。：John owl：不同于：Bill。：约翰：五十一岁。：John rdf：类型[rdf：type owl：限制；owl:maxQualifiedCardinality“4”^^xsd:nonNegativeInteger；owl:onProperty:hasChild；owl:onClass:父级] .：John rdf：类型[rdf：type owl：限制；owl:minQualifiedCardinality“2”^^xsd:nonNegativeInteger；owl:onProperty:hasChild；owl:onClass:父级] .：John rdf：类型[rdf：type owl：限制；owl:qualifiedCardinality“3”^^xsd:nonNegativeInteger；owl:onProperty:hasChild；owl:onClass:父级] .：John rdf：类型[rdf：type owl：限制；owl:基数“5”^^xsd:nonNegativeInteger；owl:onProperty:hasChild] .：父亲rdf：类型：SocialRole。[]rdf：类型owl:NegativePropertyAssertion；owl:source个人：比尔；owl:assertionProperty:hasWife；猫头鹰：目标个人：玛丽。[]rdf：类型owl:NegativePropertyAssertion；owl:source个人：比尔；owl:assertionProperty:hasDaughter；猫头鹰：目标个人：苏珊。[]rdf：类型owl:NegativePropertyAssertion；owl：源个人：Jack；owl:assertionProperty:hasAge；owl:targetValue 53。
曼彻斯特语法
前缀：：<http://example.com/owl/families/>前缀：xsd:<http://www.w3.org/2001/XMLSchema#>前缀：owl：<http://www.w3.org/2002/07/owl#>前缀：otherOnt:<http://example.org/otherOntologies/families网站/>本体：<http://example.com/owl/families>导入：<http://example.org/otherOntologies/families.owl>对象属性：hasWife子财产：hasSpouse领域：Man范围：女性对象属性：hasParent反转：hasChild对象属性：hasSpouse特点：对称ObjectProperty:hasChild特点：不对称对象属性：hasRelative特征：反射ObjectProperty:parentOf特点：不灵活标的财产：丈夫特点：功能特征：逆函数对象属性：hasAncestor特征：可传递对象属性：hasGrandparent子属性链：hasParento hasParent对象属性：hasUncle子财产链：hasFather o hasBrother对象属性：hasFather子属性：hasParent对象属性：hasBrotherObjectProperty：hasDaughter对象属性：hasSonObjectProperty:爱情分离属性：hasParent、hasSpouse分离属性：hasSon，hasDaughter等效属性：hasChild，otherOnt:child等效属性：hasAge，otherOnt:age数据属性：hasAge域：个人范围：xsd:nonNegativeInteger特点：功能数据属性：hasSSN数据类型：personAge等价于：整数[<=0，>=150]数据类型：minorAge等价于：整数[<=0，>=18]数据类型：majorAge等价于：personAge而非minorAge数据类型：幼儿年龄等价于：{1，2}数据类型：minorAge班级：女性SubClassOf:个人班级：母亲SubClassOf:女性等价物：女性和家长班级：人注释：rdfs:comment“表示所有人的集合。”等效于：人类HasKey：hasSSN类别：父级等价物to：hasChild some人等同于：母亲或父亲班级：无子女人士等价于：个人而非家长SubClassOf：人与非（逆hasParent some owl:Thing）班级：爷爷子类别：男性和父母班级：HappyPerson等价物：hasChild only Happy和hasChilld some Happy班级：约翰儿童等价于：hasParent值John类别：缉毒人员等价物：爱自己班级：孤儿等价于：inverse has only Dead班级：青少年SubClassOf:hasAge某个整数[<=13，>=19]班级：男子SubClassOf:Annotations:rdfs:comment“陈述每个人都是一个人。”班级：MyBirthdayGuests等价于：{比尔、约翰、玛丽}班级：父亲子类别：男性和父母类别：XSubClassOf：父级和hasChild最多1个，仅限hasChilld女性等同于：{玛丽、比尔、梅格}和女性班级：成人类别：死亡班级：父亲班级：女性班级：快乐类别：人类班级：社交角色班级：YoungChild退学类别：母亲、父亲、幼儿DisjointClasses：女性、男性等价类：成人，其他Ont：成人个人：Mary类型：人类型：女性个人：Jack类型：个人而非家长个人：John类型：父亲类型：hasChild max 4 Parent类型：hasChild min 2 Parent类型：hasChild正好3个Parent类型：hasChild正好5个事实：hasAge“51”^^xsd:integer事实：有妻子玛丽不同于：比尔个人：账单事实：玛丽太太没有事实：没有女儿苏珊个人：JamesSameAs:吉姆个人：Jack事实：not hasAge“53”^^xsd:integer个人：父亲类型：社交角色个人：梅格个人：Susan个人：Jim个人：其他Ont:JohnBrown个人：其他Ont：玛丽·布朗同一个人：约翰，其他人Ont:约翰布朗同一个人：玛丽，其他人Ont:玛丽·布朗
OWL/XML语法
<!DOCTYPE本体[<!实体xsd“http://www.w3.org/2001/XMLSchema#" ><!实体rdfs“http://www.w3.org/2000/01/rdf-schema#" >]><本体论xml:base=“http://example.com/owl/families/"本体论IRI=“http://example.com/owl/families"xmlns=“http://www.w3.org/2002/07/owl#"><前缀name=“owl”IRI=“http://www.w3.org/2002/07/owl#"/><前缀name=“otherOnt”IRI=“http://example.org/otherOntologies/families网站/"/><导入>http://example.org/otherOntologies/families.owl</导入><声明><NamedIndividual IRI=“约翰”/></声明><声明><Named个人IRI=“玛丽”/></声明><声明><Named个人IRI=“Jim”/></声明><声明><Named个人IRI=“James”/></声明><声明><Named个人IRI=“杰克”/></声明><声明><Named个人IRI=“账单”/></声明><声明><Named个人IRI=“Susan”/></声明><声明><Named个人IRI=“Meg”/></声明><声明><Class IRI=“个人”/></声明>＜注解断言＞<AnnotationProperty IRI=“&rdfs；注释”/>个人代表所有人的集合</文字></AnnotationAssertion><声明><IRI级=“女性”/></声明><声明><IRI=“父级”/></声明><声明><Class IRI=“父亲”/></声明><声明><IRI类=“母亲”/></声明><声明><Class IRI=“社会角色”/></声明><声明><IRI=“Man”类/></声明><声明><IRI=“青少年”/></声明><声明><Class IRI=“无子女人士”/></声明><声明><IRI=“人类”/>类</声明><声明><IRI级=“女性”/></声明><声明><Class IRI=“快乐人士”/></声明><声明><Class IRI=“约翰儿童”/></声明><声明><IRI=“缉毒人员”/></声明><声明><Class IRI=“MyBirthdayGuests”/></声明><声明><Class IRI=“死亡”/></声明><声明><IRI=“孤儿”类/></声明><声明><IRI=“成人”/></声明><声明><Class IRI=“YoungChild”/></声明><声明><ObjectProperty IRI=“hasWife”/></声明><声明><ObjectProperty IRI=“hasChild”/></声明><声明><ObjectProperty IRI=“hasDaughter”/></声明><声明><ObjectProperty IRI=“loves”/></声明><声明><ObjectProperty IRI=“hasSpouse”/></声明><声明><ObjectProperty IRI=“hasGrandparent”/></声明><声明><ObjectProperty IRI=“hasParent”/></声明><声明><ObjectProperty IRI=“hasBrother”/></声明><声明><ObjectProperty IRI=“hasUncle”/></声明><声明><ObjectProperty IRI=“hasSon”/></声明><声明><ObjectProperty IRI=“hasAncestor”/></声明><声明><ObjectProperty IRI=“hasband”/></声明><声明><DataProperty IRI=“hasAge”/></声明><声明><DataProperty IRI=“hasSSN”/></声明><声明><数据类型IRI=“personAge”/></声明><声明><数据类型IRI=“minorAge”/></声明><声明><数据类型IRI=“majorAge”/></声明><声明><Datatype IRI=“幼儿年龄”/></声明><数据类型定义><数据类型IRI=“personAge”/><数据类型限制><Datatype IRI=“&xsd；integer”/><FacetRestriction facet=“&xsd；minInclusive”><Literal datatypeIRI=“&xsd；integer”>0</FacetRestriction><FacetRestriction facet=“&xsd；maxInclusive”><Literal datatypeIRI=“&xsd；integer”>150</Literal></FacetRestriction></DatatypeRestriction></DatatypeDefinition><数据类型定义><数据类型IRI=“minorAge”/><数据类型限制><Datatype IRI=“&xsd；integer”/><FacetRestriction facet=“&xsd；minInclusive”><Literal datatypeIRI=“&xsd；integer”>0</FacetRestriction><FacetRestriction facet=“&xsd；maxInclusive”><Literal datatypeIRI=“&xsd；integer”>18</Literal></FacetRestriction></DatatypeRestriction></DatatypeDefinition><数据类型定义><数据类型IRI=“majorAge”/><数据交叉点><数据类型IRI=“personAge”/><数据补充><数据类型IRI=“minorAge”/></DataComplementOf></DataIntersectionOf></DatatypeDefinition><数据类型定义><Datatype IRI=“幼儿年龄”/><数据之一><Literal datatypeIRI=“&xsd；integer”>1</Literal><Literal datatypeIRI=“&xsd；integer”>2</Literal></DataOneOf></DatatypeDefinition><对称对象属性><ObjectProperty IRI=“hasSpouse”/></SymmetricObjectProperty><不对称对象属性><ObjectProperty IRI=“hasChild”/></不对称对象属性><分离对象属性><ObjectProperty IRI=“hasParent”/><ObjectProperty IRI=“hasSpouse”/></DisjointObjectProperties><反射对象属性><ObjectProperty IRI=“hasRelative”/></ReflexiveObjectProperty><无反射对象属性><ObjectProperty IRI=“parentOf”/></UnreflexiveObjectProperty>＜函数对象属性＞<ObjectProperty IRI=“hasband”/></FunctionalObjectProperty><反向函数对象属性><ObjectProperty IRI=“hasband”/></InverseFunctionalObjectProperty>＜传递对象属性＞<ObjectProperty IRI=“hasAncestor”/></TranitiveObjectProperty><对象属性域><ObjectProperty IRI=“hasWife”/><IRI=“Man”类/></ObjectPropertyDomain><对象属性范围><ObjectProperty IRI=“hasWife”/><IRI级=“女性”/></ObjectPropertyRange><反向对象属性><ObjectProperty IRI=“hasParent”/><ObjectProperty IRI=“hasChild”/></Inverse对象属性><分离对象属性><ObjectProperty IRI=“hasSon”/><ObjectProperty IRI=“hasDaughter”/></DisjointObjectProperties><等效对象属性><ObjectProperty IRI=“hasChild”/><ObjectProperty缩写IRI=“otherOnt:child”/></EquivalentObjectProperties><子对象属性><ObjectProperty IRI=“hasWife”/><ObjectProperty IRI=“hasSpouse”/></SubObjectPropertyOf><子对象属性><ObjectProperty IRI=“hasFather”/><ObjectProperty IRI=“hasParent”/></SubObjectPropertyOf><子对象属性><对象属性链><ObjectProperty IRI=“hasParent”/><ObjectProperty IRI=“hasParent”/></ObjectPropertyChain><ObjectProperty IRI=“hasGrandparent”/></SubObjectPropertyOf><子对象属性><对象属性链><ObjectProperty IRI=“hasFather”/><ObjectProperty IRI=“hasBrother”/></ObjectPropertyChain><ObjectProperty IRI=“hasUncle”/></SubObjectPropertyOf><子对象属性><对象属性链><ObjectProperty IRI=“hasFather”/><ObjectProperty IRI=“hasBrother”/></ObjectPropertyChain><ObjectProperty IRI=“hasUncle”/></SubObjectPropertyOf><哈斯键><Class IRI=“个人”/><DataProperty IRI=“hasSSN”/></HasKey><数据属性域><DataProperty IRI=“hasAge”/><Class IRI=“个人”/></DataPropertyDomain><数据属性范围><DataProperty IRI=“hasAge”/><Datatype IRI=“&xsd；nonNegativeInteger”/></DataPropertyRange><函数数据属性><DataProperty IRI=“hasAge”/></FunctionalDataProperty><等效数据属性><DataProperty IRI=“hasAge”/><DataProperty缩写IRI=“otherOnt:age”/></等效数据属性><子类><IRI级=“女性”/><Class IRI=“个人”/></SubClassOf><子类><IRI类=“母亲”/><IRI级=“女性”/></SubClassOf><子类><Class IRI=“祖父”/><对象交集><IRI=“Man”类/><IRI=“父级”/></ObjectIntersectionOf></SubClassOf><子类><Class IRI=“父亲”/><对象交集><IRI=“Man”类/><IRI=“父级”/></ObjectIntersectionOf></SubClassOf><子类><Class IRI=“无子女人士”/><对象交集><Class IRI=“个人”/><对象补充><对象SomeValuesFrom><对象反转><ObjectProperty IRI=“hasParent”/></对象反转><类缩写IRI=“owl:Thing”/></ObjectSomeValuesFrom></ObjectComplementOf></ObjectIntersectionOf></SubClassOf><子类><对象交集>＜ObjectOneOf＞<Named个人IRI=“玛丽”/><Named个人IRI=“账单”/><Named个人IRI=“Meg”/></ObjectOneOf><IRI级=“女性”/></ObjectIntersectionOf><对象交集><IRI=“父级”/><ObjectMaxCardinality基数=“1”><ObjectProperty IRI=“hasChild”/></ObjectMaxCardinality><对象所有值自><ObjectProperty IRI=“hasChild”/><IRI级=“女性”/></ObjectAllValuesFrom></ObjectIntersectionOf></SubClassOf><子类><IRI=“青少年”/><DataSomeValuesFrom><DataProperty IRI=“hasAge”/><数据类型限制><Datatype IRI=“&xsd；integer”/><FacetRestriction facet=“&xsd；minExclusive”><Literal datatypeIRI=“&xsd；integer”>12</Literal></FacetRestriction><FacetRestriction facet=“&xsd；maxInclusive”><Literal datatypeIRI=“&xsd；integer”>19</Literal></FacetRestriction></DatatypeRestriction></DataSomeValuesFrom></SubClassOf><子类><注释><AnnotationProperty IRI=“&rdfs；注释”/><Literal datatypeIRI=“&xsd；string”>“说明每个人都是一个人。”</注释><IRI=“Man”类/><Class IRI=“个人”/></SubClassOf><等价类><Class IRI=“快乐人士”/><对象交集><对象所有值自><ObjectProperty IRI=“hasChild”/><Class IRI=“快乐人士”/></ObjectAllValuesFrom><对象SomeValuesFrom><ObjectProperty IRI=“hasChild”/><Class IRI=“快乐人士”/></ObjectSomeValuesFrom></ObjectIntersectionOf></等价类><等价类><Class IRI=“约翰儿童”/><对象哈斯值><ObjectProperty IRI=“hasParent”/><NamedIndividual IRI=“约翰”/></ObjectHasValue></等价类><等价类><IRI=“缉毒人员”/><对象具有自身><ObjectProperty IRI=“loves”/></对象具有自身></等价类><等价类><IRI=“孤儿”类/><对象所有值自><对象反转><ObjectProperty IRI=“hasChild”/></对象反转><Class IRI=“死亡”/></ObjectAllValuesFrom></等价类><等价类><Class IRI=“MyBirthdayGuests”/>＜ObjectOneOf＞<Named个人IRI=“账单”/><NamedIndividual IRI=“约翰”/><Named个人IRI=“玛丽”/></ObjectOneOf></等价类><等价类><IRI=“成人”/><班级缩写IRI=“otherOnt:成人”/></等价类><等价类><IRI=“父级”/><对象SomeValuesFrom><ObjectProperty IRI=“hasChild”/><Class IRI=“个人”/></ObjectSomeValuesFrom></等价类><等价类><IRI=“父级”/><对象SomeValuesFrom><ObjectProperty IRI=“hasChild”/><Class IRI=“个人”/></ObjectSomeValuesFrom></等价类><等价类><Class IRI=“个人”/><IRI=“人类”/>类</等价类><等价类><IRI类=“母亲”/><对象交集><IRI级=“女性”/><IRI=“父级”/></ObjectIntersectionOf></等价类><等价类><IRI=“父级”/><对象联合><IRI类=“母亲”/><Class IRI=“父亲”/></ObjectUnionOf></等价类><等价类><Class IRI=“无子女人士”/><对象交集><Class IRI=“个人”/><对象补充><IRI=“父级”/></ObjectComplementOf></ObjectIntersectionOf></等价类><分离类><IRI级=“女性”/><IRI=“Man”类/></DisjointClasss><分离类><Class IRI=“父亲”/><IRI类=“母亲”/><Class IRI=“YoungChild”/></DisjointClasss><不同的个人><NamedIndividual IRI=“约翰”/><Named个人IRI=“账单”/></不同的个人><同一个人><Named个人IRI=“James”/><Named个人IRI=“Jim”/></同一个人><同一个人><NamedIndividual IRI=“约翰”/><Named个人缩写IRI=“otherOnt:JohnBrown”/></同一个人><同一个人><Named个人IRI=“玛丽”/><NamedIndividual缩写dIRI=“otherOnt:MaryBrown”/></同一个人><对象属性断言><ObjectProperty IRI=“hasWife”/><NamedIndividual IRI=“约翰”/><Named个人IRI=“玛丽”/></ObjectPropertyAssertion><数据属性断言><DataProperty IRI=“hasAge”/><NamedIndividual IRI=“约翰”/><Literal datatypeIRI=“&xsd；integer”>51</Literal></DataPropertyAssertion><类断言><Class IRI=“个人”/><Named个人IRI=“玛丽”/></ClassAssertion><类断言><IRI级=“女性”/><Named个人IRI=“玛丽”/></ClassAssertion><类断言><对象交集><Class IRI=“个人”/><对象补充><IRI=“父级”/></ObjectComplementOf></ObjectIntersectionOf><Named个人IRI=“杰克”/></ClassAssertion><类断言><ObjectMaxCardinality基数=“4”><ObjectProperty IRI=“hasChild”/><IRI=“父级”/></ObjectMaxCardinality><NamedIndividual IRI=“约翰”/></ClassAssertion><类断言><ObjectMinCardinality基数=“2”><ObjectProperty IRI=“hasChild”/><IRI=“父级”/></ObjectMinCardinality><NamedIndividual IRI=“约翰”/></ClassAssertion><类断言><ObjectExactCardinality基数=“3”><ObjectProperty IRI=“hasChild”/><IRI=“父级”/></ObjectExactCardinality><NamedIndividual IRI=“约翰”/></ClassAssertion><类断言><ObjectExactCardinality基数=“5”><ObjectProperty IRI=“hasChild”/></ObjectExactCardinality><NamedIndividual IRI=“约翰”/></ClassAssertion><类断言><Class IRI=“父亲”/><NamedIndividual IRI=“约翰”/></ClassAssertion><类断言><Class IRI=“社会角色”/><NamedIndividual IRI=“父亲”/></ClassAssertion><否定对象属性断言><ObjectProperty IRI=“hasWife”/><Named个人IRI=“账单”/><Named个人IRI=“玛丽”/></NegativeObjectPropertyAssertion><否定数据属性断言><DataProperty IRI=“hasAge”/><Named个人IRI=“杰克”/><Literal datatypeIRI=“&xsd；integer”>53</Literal></NegativeDataPropertyAssertion><否定对象属性断言><ObjectProperty IRI=“hasDaughter”/><Named个人IRI=“账单”/><Named个人IRI=“Susan”/></NegativeObjectPropertyAssertion></本体>

14附录：变更日志（资料性）

14.1建议后的变更

本节总结了自2009年10月27日的建议.

14.2建议后的变更

本节总结了自2009年9月22日的建议.

14.3上次通话后的变化

本节总结了自2009年6月11日最后一次召集工作草案.

15确认

OWL 2开发的起点是OWL1.1成员提交它本身是用户和开发人员反馈的结果，特别是在OWL经验与方向（OWLED）研讨会系列工作组还审议了推迟的问题来自WebOnt工作组.

本文件由OWL工作组编制（见下文），其内容反映了整个工作组内的广泛讨论。编辑们特别感谢杰宝（RPI），米歇尔·杜蒙蒂尔（卡尔顿大学），Christine Goldbreich（圣昆廷凡尔赛大学和LIRMM），亨森·格雷夫斯（洛克希德·马丁公司），伊凡·赫尔曼（W3C/ERCIM），Rinke Hoekstra（阿姆斯特丹大学），Doug Lenat（Cycorp），Deborah L.McGuinness（RPI），Alan Rector（曼彻斯特大学），Alan Ruttenberg（科学共享区）乌利·萨特勒（曼彻斯特大学），Michael Schneider（FZI），以及迈克·史密斯（克拉克和帕西娅）感谢他们的全面评论和有益评论。

本文件发布时，OWL工作组会议的定期与会者为：杰宝（RPI），Diego Calvanee（博赞-波尔扎诺自由大学），Bernardo Cuenca Grau（牛津大学计算实验室），Martin Dzbor（开放大学），Achille Fokoue（IBM公司），Christine Golbreich（圣昆廷凡尔赛大学和LIRMM），桑德罗·霍克（W3C/MIT），伊凡·赫尔曼（W3C/ERCIM），Rinke Hoekstra（阿姆斯特丹大学），Ian Horrocks（牛津大学计算实验室），Elisa Kendall（Sandpiper软件），Markus Krötzsch（FZI），Carsten Lutz（不来梅大学），Deborah L.McGuinness（RPI），Boris Motik（牛津大学计算机实验室），Jeff Pan（阿伯丁大学），Bijan Parsia（曼彻斯特大学），Peter F.Patel-Schneider（阿尔卡特朗讯贝尔实验室研究），塞巴斯蒂安·鲁道夫（FZI），Alan Ruttenberg（科学共享空间），乌利·萨特勒（曼彻斯特大学），迈克尔·施耐德（FZI），迈克·史密斯（克拉克和帕西娅），埃文·华莱士（NIST），Zhe Wu（甲骨文公司），以及安托万·齐默尔曼（DERI Galway）。我们还要感谢工作组过去的成员：杰里米·卡罗尔，Jim Hendler，以及Vipul Kashyap。

16参考文献

[描述逻辑]
描述逻辑手册：理论、实现和应用，第二版Franz Baader、Diego Calvanee、Deborah L.McGuinness、Daniele Nardi和Peter F.Patel-Schneider编辑，剑桥大学出版社，2007年。另请参阅说明逻辑主页.
【DLP】
描述逻辑程序：将逻辑程序与描述逻辑相结合Benjamin N.Grosof、Ian Horrocks、Raphael Volz和Stefan Decker。程序中。第十二届国际万维网会议（WWW 2003），匈牙利布达佩斯，2003年。页码：48-57
[DL-Lite（DL-Lite）]
描述逻辑中的可追踪推理和高效查询回答：DL-Lite系列迭戈·卡尔瓦内斯（Diego Calvanee）、朱塞佩·德贾科莫（Giuseppe de Giacomo）、多梅尼科·伦博（Domenico Lembo）、毛里齐奥·伦泽里尼（Maurizio Lenzerini）、里卡多·罗萨蒂（Riccardo Rosati）。自动推理杂志39（3）：385–4292007
[EL++]
推动EL信封Franz Baader、Sebastian Brandt和Carsten Lutz。程序中。2005年第19届国际人工智能联合会议（IJCAI 2005）
[福斯特]
语义Web技术基础帕斯卡·希茨勒（Pascal Hitzler）、马库斯·克罗茨奇（Markus Krötzsch）和塞巴斯蒂安·鲁道夫（Sebastian Rudolph）。查普曼和霍尔/CRC，2009，ISBN:9781420090505。
[OWL 2合规性]
OWL 2 Web本体语言：一致性（第二版）Michael Smith、Ian Horrocks、Markus Krötzsch、Birte Glimm编辑的W3C建议书，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-conformance-20121211/。最新版本位于http://www.w3.org/TR/owl2-一致性/.
[OWL 2曼彻斯特语法]
OWL 2 Web本体语言：曼彻斯特语法（第二版）马修·霍里奇（Matthew Horridge）、彼得·帕特尔·施耐德（Peter F.Patel-Schneider）。W3C工作组说明，2012年12月11日，http://www.w3.org/TR/2012/NOTE-owl2-manchester-syntax-20121211/。最新版本位于http://www.w3.org/TR/owl2-manchester语法/.
[OWL 2新功能和原理]
OWL 2 Web本体语言：新功能和原理（第二版）Christine Golbreich，Evan K.Wallace，编辑W3C建议书，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-new-features-2012121/。最新版本位于http://www.w3.org/TR/owl2-new-features网站/.
[OWL 2配置文件]
OWL 2 Web本体语言：配置文件（第二版）Boris Motik、Bernardo Cuenca Grau、Ian Horrocks、Zhe Wu、Achille Fokoue、Carsten Lutz编辑的W3C建议书，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-profiles-20121211/。最新版本位于http://www.w3.org/TR/oll2-配置文件/.
[OWL 2配置文件简介]
OWL 2概要：轻量级本体语言简介Markus Krötzsch。推理Web 2012。《计算机科学讲义》，第7487卷，第112-183页，施普林格出版社，2012年。出现。预打印可在http://korrekt.org/page/OWL_2_Profiles网站
[OWL 2快速参考指南]
OWL 2 Web本体语言：快速参考指南（第二版）Jie Bao，Elisa F.Kendall，Deborah L.McGuinness，Peter F.Patel-Schneider，编辑W3C建议书，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-quick-reference-20121211/。最新版本位于http://www.w3.org/TR/owl2-quick-reference/.
[OWL 2基于RDF-的语义]
OWL 2 Web本体语言：基于RDF的语义（第二版）迈克尔·施耐德，编辑。W3C建议，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-rdf-based-semantics-2012111/。最新版本位于http://www.w3.org/TR/owl2-rdf-based-semantics网站/.
[OWL 2 RDF映射]
OWL 2 Web本体语言：映射到RDF图（第二版）Peter F.Patel-Schneider，Boris Motik，编辑W3C建议书，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-mapping-to-rdf-2012121/。最新版本位于http://www.w3.org/TR/owl2-mapping-to-rdf/.
[OWL 2直接语义]
OWL 2 Web本体语言：直接语义学（第二版）Boris Motik，Peter F.Patel-Schneider，Bernardo Cuenca Grau，编辑W3C建议书，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-direct-semantics-20121211/。最新版本位于http://www.w3.org/TR/oll2-直接需求/.
[OWL 2规范]
OWL 2 Web本体语言：结构规范和功能风格语法（第二版）Boris Motik，Peter F.Patel-Schneider，Bijan Parsia，编辑W3C建议书，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-syntax-2012211/。最新版本位于http://www.w3.org/TR/owl2-语法/.
[OWL 2 XML序列化]
OWL 2 Web本体语言：XML序列化（第二版）Boris Motik，Bijan Parsia，Peter F.Patel-Schneider，编辑W3C建议书，2012年12月11日，http://www.w3.org/TR/2012/REC-owl2-xml-serialization-20121211/。最新版本位于http://www.w3.org/TR/owl2-xml-serialization网站/.
[页码*]
RDF模式包含的完整性、可判定性和复杂性以及涉及OWL词汇表的语义扩展赫尔曼·J·特·霍斯特。网络语义学杂志3（2-3）：79-1152005
[RDF概念]
资源描述框架（RDF）：概念和抽象语法Graham Klyne和Jeremy J.Carroll编辑的W3C建议书，2004年2月10日，http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/。最新版本可用为http://www.w3.org/TR/rdf-concepts/。
[RDF语义]
RDF语义Patrick Hayes编辑，W3C建议书，2004年2月10日，http://www.w3.org/TR/2004/REC-rdf-mt-20040210/。最新版本可用为http://www.w3.org/TR/rdf-mt/。
[RDF语法]
RDF/XML语法规范（修订版）Dave Beckett，编辑W3C建议书，2004年2月10日，http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/。最新版本可用为http://www.w3.org/TR/rdf-syntax-grammar/。
[RFC 3987]
RFC 3987：国际化资源标识符（IRI）M.Duerst和M.Suignard。IETF，2005年1月，http://www.ietf.org/rfc/rfc3987.txt
[SPARQL]
RDF的SPARQL查询语言Eric Prud’hommeaux和Andy Seaborne编辑的W3C建议书，2008年1月15日，http://www.w3.org/TR/2008/REC-rdf-sparql-query-20080115/。最新版本可用为http://www.w3.org/TR/rdf-sparql-query/。
[乌龟]
海龟：Terse RDF三重语言埃里克·普鲁德霍姆和加文·卡托尔斯。W3C Last Call工作草案，2012年7月10日，http://www.w3.org/TR/2012/WD-turtle-20120710/。最新版本可在http://www.w3.org/TR/curl/。
[XML架构数据类型]
W3C XML模式定义语言（XSD）1.1第2部分：数据类型David Peterson，Shudi（Sandy）Gao，Ashok Malhotra，C.M.Sperberg-McQueen，and Henry S.Thompson，eds.（1.1版）和Paul V.Biron，and Ashok Marhotra（1.0版）。W3C建议书，2012年4月5日，http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/。最新版本可用作http://www.w3.org/TR/xmlschema11-2/.