中文XML论坛--《a semantic primer》第四章译文！！！

心血之作，仅供大家参考。没有功劳也有苦劳，翻译不对的地方，请多多指教。谢谢！

4 Web本体语言：OWL

4.1 简介
我们在前一章中讨论的RDF和RDFS的表达能力非常有限：RDF（大致上）局限于二元谓词（binary ground predicates），RDFS（大致上）局限于子类（subclass）层级划分和属性（property）的层级划分，以及属性的定义域（或译为域，domain）和值域（或译为范围，range）的定义。
然而，W3C1Web本体工作组提出的语义网的许多典型用例，要求能比RDF和RDFS提供更多的语义表达力。
美国和欧洲的许多研究团体已经明确了一种更强大的本体建模语言的需求。从而组成了联合研究行动组以定义一种更丰富的语言，称为DAML+OIL2（这个名称是由美国提议的DAML-ONT3和欧洲语言OIL4联合而成）
DAML+OIL从而成为W3C Web本体工作组定义OWL的起点，OWL语言的目标是成为语义网的标准化的广泛接受的本体语言。
在这一章，我们首先从必要条件出发讨论OWL的动机，以及它与RDFS之间的重要关系。然后我们具体讨论OWL的各种语言成分。
4.1.1 本体语言要求必备的条件
本体语言应使用户能描写出明确的形式上的概念化的领域模型。其需必备的主要条件是：
定义良好的语法（well-defined syntax）   有效的推理支持（efficient reasoning support）
形式化的语义（a formal semantics）      充足的表达能力（sufficient expressive power）
语义表达的便利性（convenience of expression）
定义良好的语法（well-defined syntax）的重要性是很显然的，并且在编程语言领域也有这样的要求；它是信息进行机器处理的一个必要条件。我们迄今为止提出的所有语言都具备定义良好的语法。DAML+OWL建立在RDF和RDFS之上，因而具有与之相同的语法。
当然，基于XML的RDF语法是否非常的用户友好尚有疑问；而且还存在着更适合于人们使用选择的其它语法（例如，参见OIL语法）。但是，这个缺点并没有很大关系，因为最终，用户可以开发出他们自己的本体创作工具，或者一般称之为，本体开发工具（ontology development tools），而不是直接用DAML+OIL或OWL语言描写本体。
形式化的语义（formal semantics）精确地（precisely）描述知识的涵义。这里的精确意味着，语义既不是指主观上的个人直觉，也不是说对于不同的人（或机器）其解释是不同的。例如，数理逻辑领域很好地确定了形式化语义的重要性。
形式化语义的一个应用是使人们能够进行关于知识的推理。针对本体知识，我们的推理可能包括：
• 类成员（Class membership）。如果x是类C的一个实例，并且C是D的一个子类，则我们可以推断x是D的一个实例。
• 类的等价（Equivalence of classes）。如果类A等价类B，并且类B等价类C，则A也等价C。
• 一致性（Consistency）。假设我们已经声明了x是类A的一个实例，并且A是B∩C的子类，A是D的子类，并且B和D是不相交的。则我们得到一个矛盾（不一致），因为A应该是空的，但是它却有实例x。这就表示本体中存在错误。
• 分类法（Classification）。如果我们已经声明某些属性-值对是类A中的成员的充分条件，则如果一个个体x满足这些条件，我们就可以得出结论，x一定是A的一个实例。
语义是推理支持（reasoning support）的先决条件。象前面的这种推导可以自动生成而不是手工生成。推理支持很重要，因为它可以用来：
• 检查本体和知识的一致性
• 检查类与类之间的非故意的关联
• 自动对类的实例进行分类
自动化的推理支持可以比手工检查更多的用例。象前面这样的检查对于设计大型本体是很有用的，在大型本体中有多个作者参与其中，并且从不同的源整合和共享本体。
形式化语义和推理支持的提供通常是通过将本体语言映射到一个已知的逻辑形式系统，并且通过使用那些形式系统已有的自动化推理机。OWL映射到（部分地）一个描述逻辑上，并且利用已有的推理机如FaCT和RACER。描述逻辑是谓词逻辑的一个子集，它使得有效的推理支持成为可能。
4.1.2  RDFS的表达力的局限性
RDF和RDFS可用来表达某些本体知识。RDF/RDFS主要的建模原语是关于类型层次结构中的词汇表的组织：子类（subclass）和子属性（subproperty）关系，定义域（domain）和值域（range）约束，以及类的实例。然而，缺少许多其他的特征。下面我们列举其中的一部分：
• 属性的范围（Local scope of properties）。rdfs:range为所有类的一个属性定义了范围（range），如eats。因此我们不能声明只适用于某些类的范围约束。例如，我们不能只指出母牛吃植物，而不指出其他动物可能还吃肉。
• 类的不相交（Disjointness of classes）。有时我们希望指出类是不相交的。例如，男人和女人是不相交的。但是在RDFS中，我们只能陈述子类关系，举例来说，女人是人的一个子类。
• 类的布尔组合（Boolean combinations of classes）。有时我们希望通过使用并、交和补来联接其它的类构造新的类。例如，我们可能希望定义人的类为男人类和女人类的不相交并集。RDFS不支持这些定义。
• 基数的约束（Cardinality restrictions）。有时我们希望对一个属性可能或者必须取多少值设置约束。例如，我们想指定一个人恰好有两个双亲，或者一门课程最少要有一名授课者。同样，这种约束在RDFS中是不可能表达的
• 属性的特殊特征（Special characteristics of properties）。有时需要指出一个属性是传递（transitive）的（像“大于”greater than），唯一（unique）的（像“是…的母亲” is mother of），或者与另一属性相反（inverse）（像“吃”eats与“被吃”is eaten by）。
因此我们需要一个比RDFS更丰富的本体语言，它能提供上述特征以及更多其它特征。在设计这样的一种语言时，我们应该了解语义的表达能力与有效推理支持之间的平衡关系。通常，语言的语义表达能力越丰富，其推理支持的有效性越差，往往穿越不可计算性的边界。因此，我们需要一个折衷，需要一种语言能够获得适度有效的推理机的支持而且具备充分的语义表达能力来表达本体和知识的大型类。
4.1.3  OWL与RDF/RDFS的兼容
理想地，OWL应该是RDFS的一个扩充，因为考虑到OWL使用类和属性的RDF语义（ rdfs:Class，rdfs:subClassOf等），并且应该添加语言建模原语来支持所需的更丰富的语义。这样的一个RDFS的扩充版本还应该与语义网的分层结构相一致。（见图1.3）
不幸地是，简单地扩充RDFS将无法获得丰富的语义表达能力和有效的推理。RDFS有一些非常强大的建模原语（见图3.8）。例如像rdfs:Class（所有类的类）和rdfs:Property（所有属性的类）的表达能力非常强大，如果使用这些原语扩展逻辑的话，将导致无法控制的计算复杂性。
4.1.4 三种OWL语言
　　本体语言的所有必备条件似乎是无法全部达到的：既具有推理支持的有效性和语义表达的便利性，并且与逻辑完整的RDFS语言相结合的一种强大的语言。
事实上，上述不同的需求促使W3C Web本体工作组定义了三种不同的OWL子语言，每一种子语言满足实现不同方面的需求。
OWL Full
完整的OWL语言称为OWL Full，它使用OWL语言的全部建模原语。它还允许以任意的方式将这些原语与RDF和RDFS结合起来。这包括通过将语言原语应用于彼此（在RDF中也曾提到），可以改变预定义（RDF或OWL）原语的语义。例如，在OWL Full中，我们可以对所有类的类施加基数的约束，从而实质上限制了任一本体中可描述的类的数量。
OWL Full的优点是它完全向上兼容RDF，无论是从语法上还是语义上：每个合法的RDF文档也是一个合法的OWL Full文档，每个有效的RDF/RDFS结论也是一个有效的OWL Full结论。OWL Full的缺点是该语言变得太强大以至于不可判定，而使其获得完备（或有效）推理支持的希望破灭。
OWL DL
为了重新获得计算效率，OWL DL（Description Logic的缩写）作为OWL Full子语言，限制了OWL和RDF中的语言成分（也译为构造子，constructor）的使用：基本上OWL的语言成分之间的相互应用是不允许的，从而确保该语言与已得到深入研究的描述逻辑相符。
其优点是它允许有效的推理支持。缺点是我们失去了与RDF的完全兼容：一个RDF文档通常必须在某些方面进行扩充并在其他方面进行限制，才能成为一个合法的OWL DL文档。每一个合法的OWL DL文档都是一个合法的RDF文档。
OWL Lite
对OWL DL进行更多的约束，而得到该语言成分的一个子集。例如，OWL Lite不接受枚举类、不相交陈述、以及任意的基数。
该语言的优点是它既容易掌握（对于使用者）又容易实现（对于工具建造者）。缺点当然是其有限的语义表达能力。
本体开发者在采用OWL语言的时候应该考虑哪种子语言最符合其需求。选择OWL Lite还是OWL DL取决于用户在多大程度需要OWL DL和OWL Full提供的表达能力更强的成分。选择OWL DL还是OWL Full取决于用户在多大程度上需要RDFS的元建模机制。使用OWL Full相比于OWL DL，对推理的支持是更难预测的，因为完全的OWL Full的实现是不可能的。
下面是这三种语言之间向上兼容的规则：
• 每个合法的OWL Lite本体都是一个合法的OWL DL本体；
• 每个合法的OWL DL本体都是一个合法的OWL Full本体；
• 每个有效的OWL Lite结论都是一个有效的OWL DL结论；
• 每个有效的OWL DL结论都是一个有效的OWL Full结论。
OWL仍然广泛地使用RDF和RDFS语法：
• 所有OWL语言都使用RDF语法。
• 实例的声明与RDF相同，使用RDF的描述和声明信息。
• OWL的语言成分如owl:Class、owl:DatatypeProperty和owl:ObjectProperty 是RDF相应语言成分的特殊化。
图4.1指出了OWL和RDF/RDFS的一些建模原语之间的子类关系。

语义网分层结构（见图1.3）的一个最主要的动机是希望能提供向下兼容性从而实现相应的穿越多层的软件的复用。然而，只有OWL Full达到了完全向下兼容（每个OWL-感知的处理器（OWL-aware processor）也能提供每个RDFS文档的正确的解释）的优点，而且是以计算难解性为代价。
在本章中，4.2节介绍了OWL的一些细节，4.3节对该语言进行了举例说明。
4.4节中指出，部分OWL定义可以用OWL语言本身书写，4.5节讨论了OWL一些还没解决的代表性需求，它们可能成为将来进行扩展的主题。
4.2  OWL语言
4.2.1  语法（Syntax）
    OWL建立于RDF和RDFS之上，并且使用RDF的基于XML的语法。既然它是OWL的原始语法，我们将在这里使用它，但是RDF/XML所提供的并不是个十分易读的语法。因为这个原因，还定义了OWL的其它语法形式。
• 一种基于XML的语法5 ，并不遵循RDF惯例，因而容易让人阅读。
• 在语言规范文档6（the language specification document）中使用的一种抽象语法，比XML语法和RDF/XML语法都更紧致和易读。附录A用该抽象语法列出了本章中所有的RDF/XML代码。
• 基于UML（统一建模语言）惯例的一种图形化语法，被广泛使用，因而是人们熟悉OWL的简单方法。
4.2.2 头信息（Header）
OWL文档通常称为OWL本体（OWL ontologies），并且也是RDF文档。OWL本体的根元素是一个rdf:RDF元素，同时指定了许多命名空间（namespaces）：
<rdf:RDF
xmlns:owl ="http://www.w3.org/2002/07/owl#"
xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:xsd ="http://www.w3.org/2001/XMLSchema#">
一个OWL本体通常以收集一些关于常规事务的断言（assertion）为起始。这些断言归于owl:Ontology元素之下，包含注释、版本控制，以及内含的其它本体。例如：
<owl:Ontology rdf:about="">
<rdfs:comment>An example OWL ontology</rdfs:comment>
<owl:priorVersion
rdf:resource="http://www.mydomain.org/uni-ns-old"/>
<owl:imports
rdf:resource="http://www.mydomain.org/persons"/>
<rdfs:label>University Ontology</rdfs:label>
</owl:Ontology>
这些断言中只有一个断言含有本体的逻辑内涵结论：owl:imports，它列出了其它的本体，其内容被设定为当前本体的一部分。注意，当使用命名空间消除命名冲突时，由被引入的本体提供可使用的定义。通常对于每个使用的命名空间都会有一个import元素，但是这也可能会引入多余的本体，例如，当本体提供定义而并未引入任何新的名字时。
还应注意owl:imports是一个传递性的属性：如果本体A引入了本体B，本体B引入了本体C，则本体A也引入了本体C。
4.2.3  类元素
  使用owl:Class元素定义类7。例如，我们可以定义associateProfessor类如下：
<owl:Class rdf:ID="associateProfessor">
<rdfs:subClassOf rdf:resource="#academicStaffMember"/>
</owl:Class>
   使用owl:disjointWith元素，我们还可以指出该类与assistantProfessor类和professor类是不相交的。这些元素可以包含在前面的定义中，或者通过使用rdf:about并参考ID来添加。这种机制继承自RDF:
    <owl:Class rdf:about="#associateProfessor">  （副教授）
<owl:disjointWith rdf:resource="#professor"/>  （教授）
<owl:disjointWith rdf:resource="#assistantProfessor"/>  （助理教授）
</owl:Class>
   可以使用owl:equivalentClass元素定义类的等价。
<owl:Class rdf:ID="faculty">
<owl:equivalentClass rdf:resource="#academicStaffMember"/>
</owl:Class>
    最后，有两个预定义类：owl:Thing和owl:Nothing。其创造者为最一般的类，它包含万物（everything is a thing万物也是物），并且后者是空类。因此每一个类都是owl:Thing的子类，owl:Nothing的超类。
4.2.4  属性元素（Property Elements）
在OWL中有两种属性：
• 对象属性（Object properties）将对象与其他对象关联，例如isTaughtBy 和supervises。
• 数据类型属性（Data type properties）将对象与数据类型值关联。例如phone、title和age等。OWL没有任何预定义数据类型，也没有提供专门的定义机制。OWL文档允许使用XML Schema的数据类型，因而利用了语义网的分层结构。
下面是一个数据类型属性的例子：
<owl:DatatypeProperty rdf:ID="age">
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema
#nonNegativeInteger"/>
</owl:DatatypeProperty>
通常在XML Schema中集中定义用户自定义的数据类型，然后用于OWL本体中。
下面是一个对象属性的例子：
<owl:ObjectProperty rdf:ID="isTaughtBy">
<rdfs:domain rdf:resource="#course"/>
<rdfs:range rdf:resource="#academicStaffMember"/>
<rdfs:subPropertyOf rdf:resource="#involves"/>
</owl:ObjectProperty>
可以声明多个定义域和值域。在这种情况下，分别采用定义域和值域的交集。
OWL允许我们使用“逆反属性”。一个典型的例子是属性对isTaughtBy和teaches：
<owl:ObjectProperty rdf:ID="teaches">
<rdfs:range rdf:resource="#course"/>
<rdfs:domain rdf:resource="#academicStaffMember"/>
<owl:inverseOf rdf:resource="#isTaughtBy"/>
</owl:ObjectProperty>
图4.2举例说明了一个属性与它的逆反之间的关系。实际上定义域和值域可以通过逆反属性得到（将定义域与值域交换）。

可以通过使用owl:equivalentProperty元素定义属性的等价。
<owl:ObjectProperty rdf:ID="lecturesIn">
<owl:equivalentProperty rdf:resource="#teaches"/>
</owl:ObjectProperty>
4.2.5 属性约束（Property Restrictions）
使用rdfs:subClassOf，我们可以指定一个类C是另一个类C’的子类；则C的所有实例也都是C’的实例。
假设我们希望声明，类C满足某一条件，也就是说C的所有实例都满足该条件。如果C’收集了满足该条件的所有对象，这与声明C是C’的子类是等价的。OWL正是这样做的。注意，通常C’是匿名的。
下面的元素要求第一学年的课程（first-year courses）只能由教授（professors）来教（依照一种值得置疑的观点，认为年龄和资格较老的教师更长于教学）：
<owl:Class rdf:about="#firstYearCourse">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#isTaughtBy"/>
<owl:allValuesFrom rdf:resource="#Professor"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
owl:allValuesFrom是用来指定由owl:onProperty指定的属性的所有取值的类（换句话说，该属性的所有值都必须来自此类）。在我们的例子中，属性isTaughtBy的值只允许取自professor。
我们如下声明数学课程由David Billington来教：
<owl:Class rdf:about="#mathCourse">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#isTaughtBy"/>
<owl:hasValue rdf:resource="#949352"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
owl:hasValue声明由owl:onProperty指定的属性必须取某一特定值。
    我们可以声明所有的大学教员都必须教授最少一门大学生课程：
    <owl:Class rdf:about="#academicStaffMember">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#teaches"/>
<owl:someValuesFrom
rdf:resource="#undergraduateCourse"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
    让我们比较一下owl:allValuesFrom和owl:someValuesFrom。前面的例子要求对于第一学年的每门课程，其每名授课人都必须是教授。用逻辑术语来说，我们使用了全称量词。
    后面的这个例子要求对于每名大学教员，存在一门大学生课程由他来教。同一名教员还有可能教另外的研究生课程。用逻辑术语来说，我们使用了存在量词。
通常，一个owl:Restriction元素包含一个owl:onProperty元素和一个或多个约束声明。一种约束声明定义了属性取值类型的约束，如：owl:allValuesFrom、owl:hasValue, 和owl:someValuesFrom。另一种约束声明定义了基数的约束。例如，我们可以要求每门课程最少要由一个人来教：
<owl:Class rdf:about="#course">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#isTaughtBy"/>
<owl:minCardinality
rdf:datatype="&xsd;nonNegativeInteger">
1
</owl:minCardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
    注意我们要指出“1”在这里被解释为非负整数（nonNegativeInteger）（而不是字符串），而且我们使用头元素中声明的xsd命名空间来参考XML Schema文档。
或许在实际情况中我们可能会指出，一个部门必须最少有10名成员，最多有30名成员：
<owl:Class rdf:about="#department">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasMember"/>
<owl:minCardinality
rdf:datatype="&xsd;nonNegativeInteger">
10
</owl:minCardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasMember"/>
<owl:maxCardinality
rdf:datatype="&xsd;nonNegativeInteger">
30
</owl:maxCardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
有可能要指定一个精确的数字，例如，一个哲学博士必须恰好有两个导师。我们可以在owl:minCardinality和owl:maxCardinality中用相同的数字。为简单起见，OWL还提供了owl:cardinality。
    总之我们需注意owl:Restriction定义了一个没有ID的匿名类，该类并不是由owl:Class定义的，仅拥有本地范围（local scope）：它只能在约束出现的那个位置使用。当我们讨论类的时候，请在头脑中保持两种概念：由owl:Class定义的有ID的类，以及收集满足某些约束条件的对象的本地匿名类，或者可以说是作为联合其他类的联合体。后者有时称为类表达式（class expressions）。
4.2.6  特殊属性
    属性元素的一些性质可以直接定义：
owl:TransitiveProperty定义传递属性，如“比…等级高”“比…高”或“是…的祖先” （“has better grade than”, “is taller than”,  “is ancestor of”）。
owl:SymmetricProperty定义对称属性，如“与…具有同样的等级”或“是…的兄弟姐妹” （“has same grade as”， “is sibling of”）。
    owl:FunctionalProperty定义了一个属性，对于每个对象最多只能取一个值，如“年龄”，“身高”或者“直接领导”（“age”, “height”, “directSupervisor”）。
owl:InverseFunctionalProperty定义了一个属性，对于两个不同的对象不能取相同的值，如“是…的社会安全号码”（“isTheSocialSecurityNumberfor”一个社会安全号码只能分配给一个人）。
    下面是这些语法形式的例子：
<owl:ObjectProperty rdf:ID="hasSameGradeAs">
<rdf:type rdf:resource="&owl;TransitiveProperty" />
<rdf:type rdf:resource="&owl;SymmetricProperty" />
<rdfs:domain rdf:resource="#student" />
<rdfs:range rdf:resource="#student" />
</owl:ObjectProperty>
4.2.7  布尔组合（Boolean Combinations）
我们有可能会讨论类（由owl:Class定义或者由类表达式定义）的布尔组合（并、交、补）。例如，我们可以说课程和职员是不相交的，如下所示：
<owl:Class rdf:about="#course">
<rdfs:subClassOf>
<owl:Class>
<owl:complementOf rdf:resource="#staffMember"/>
</owl:Class>
</rdfs:subClassOf>
</owl:Class>
这是说每一门课程是职员的补集的一个实例，也就是说，课程不是职员。注意这个陈述也可以使用owl:disjointWith来表达。
    使用owl:unionOf来构造类的并集；
<owl:Class rdf:ID="peopleAtUni">
<owl:unionOf rdf:parseType="Collection">
<owl:Class rdf:about="#staffMember"/>
<owl:Class rdf:about="#student"/>
</owl:unionOf>
</owl:Class>
这里不是说新类是并集的子类，而是说新类等于（equal）并集。换句话说，我们声明了类的等值（或等价）。而且，我们并未指出这两个类必须是不相交的：一个职员也有可能是学生。
用owl:intersectionOf来声明交集：
<owl:Class rdf:ID="facultyInCS">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#faculty"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#belongsTo"/>
<owl:hasValue rdf:resource="#CSDepartment"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
注意：我们定义了两个类的交集，其中一个是匿名的：属于CS学院的所有对象的类。这个类与全体教师（faculty）的交集使我们得到在CS学院工作的全体教师。
布尔组合可以是任意嵌套的。下面的例子定义了行政管理人员（administrative staff），他们既不是教师（faculty）也不是技术支持人员（technical support staff）：
<owl:Class rdf:ID="adminStaff">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#staffMember"/>
<owl:Class>
<owl:complementOf>
<owl:Class>
<owl:unionOf rdf:parseType="Collection">
<owl:Class rdf:about="#faculty"/>
<owl:Class rdf:about="#techSupportStaff"/>
</owl:unionOf>
</owl:Class>
</owl:complementOf>
</owl:Class>
</owl:intersectionOf>
</owl:Class>
4.2.8  枚举（Enumerations）
    枚举是一个owl:oneOf元素，用来通过列出类的所有元素的清单来定义一个类：
<owl:Class rdf:ID="weekdays">
<owl:oneOf rdf:parseType="Collection">
<owl:Thing rdf:about="#Monday"/>
<owl:Thing rdf:about="#Tuesday"/>
<owl:Thing rdf:about="#Wednesday"/>
<owl:Thing rdf:about="#Thursday"/>
<owl:Thing rdf:about="#Friday"/>
<owl:Thing rdf:about="#Saturday"/>
<owl:Thing rdf:about="#Sunday"/>
</owl:oneOf>
</owl:Class>
4.2.9  实例（Instances）
类的实例的声明与RDF中相同：
<rdf:Description rdf:ID="949352">
<rdf:type rdf:resource="#academicStaffMember"/>
</rdf:Description>
或者也可以这样声明：
<academicStaffMember rdf:ID="949352"/>
我们还可以提供更多的细节，如：
<academicStaffMember rdf:ID="949352">
<uni:age rdf:datatype="&xsd;integer">39</uni:age>
</academicStaffMember>
    与典型的数据库系统不同，OWL并没有采用唯一名假设（unique-names assumption）；因为名字或ID不同的两个实例并不意味着它们就是不同的个体。例如，如果我们声明每门课程最多由一名教师教：
<owl:ObjectProperty rdf:ID="isTaughtBy">
<rdf:type rdf:resource="&owl;FunctionalProperty" />
</owl:ObjectProperty>
    接着我们后面又声明某个给定的课程由两名教师教：
<course rdf:ID="CIT1111">
<isTaughtBy rdf:resource="#949318"/>
<isTaughtBy rdf:resource="#949352"/>
</course>
这并不会导致OWL推理机标记出错。最终，系统会推断出资源"949318"和"949352显然是等值的。为了保证不同的个体能真正地被识别，我们必须显式地声明它们不等值：
<lecturer rdf:ID="949318">
<owl:differentFrom rdf:resource="#949352"/>
</lecturer>

由于这种不等值陈述经常发生，如果我们要声明大量个体之间的不等值关系，将会导致此类陈述的数量过大，OWL提供了一种简略的表达方式来声明列出的所有个体两两之间是不等值的。
<owl:AllDifferent>
<owl:distinctMembers rdf:parseType="Collection">
<lecturer rdf:about="#949318"/>
<lecturer rdf:about="#949352"/>
<lecturer rdf:about="#949111"/>
</owl:distinctMembers>
</owl:AllDifferent>
    注意owl:distinctMembers只能与owl:allDifferent联合使用。
4.2.10  数据类型（Data Types）
虽然XML Schema提供了构造用户自定义数据类型的机制（举例来说，自定义adultAge数据类型为大于18的所有整数，或者自定义数据类型为以数字开头的所有字符串的），但是这些导出的数据类型不能在OWL中使用。实际上，甚至并非所有的内置的XML Schema数据类型都能在OWL中使用。OWL参考文档列出了所有能使用的XML Schema数据类型，其中包括最常使用的数据类型如字符串型，整数型，布尔型，时间型和日期型。
4.2.11  版本信息（Versioning Information）
    我们已经看到owl:priorVersion作为头信息的一部分，指出了当前本体的前期版本。版本信息并不具备形式的建模理论上的语义，但是可供人和程序阅读，从而达到本体管理的目的。
    除了owl:priorVersion，OWL还有三种陈述方式指出更多的非形式化的版本信息。它们都不携带任何形式化语义。
owl:versionInfo通常包含一个能提供关于当前版本的信息的字符串，例如RCS/CVS 关键字。
owl:backwardCompatibleWith包含一个对另一本体的引用。它指定某个本体为当前本体的前一个版本，并且还指出当前本体与之是向后兼容的。特别地，这表示前一版本中所有标识符的解释，与新版本中对这些标识符的解释是相同的。因此，这就提示文档作者，他们可以安全地将自己的文档提交为新的版本（只需参照新版本的URL，简单地对命名空间声明和owl:imports陈述进行更新）。
owl:incompatibleWith，用来指出当前本体是所引入的本体的后期版本，但是它并不是向后兼容的。一般地，使用它本体作者可以清楚，如果没有检查文档是否需要改变，文档就不能升级为新的版本。
4.2.12  OWL的层次（Layering of OWL）
    既然我们已经对OWL的所有语言成分进行了讨论，我们可以完整地指出在各子语言中分别使用了OWL语言的哪些特征(OWL Full, OWL or OWL Lite)。
OWL Full
在OWL Full中，可以任意组合使用所有的语言成分，只要所得结果是合法的RDF文档。
OWL DL
为了利用描述逻辑的形式支持和计算易处理性，OWL DL本体必须遵守以下约束：
• 词汇划分（Vocabulary partitioning）。任何资源只允许是类、数据类型、数据类型属性、对象属性、个体、数据值，或者是内置词汇的一部分，并且最多只能是其中的一种。这意味着，例如，一个类不能同时是一个个体，或者一个属性的取值不能一些来自一个数据类型，而一些来自一个类（这将使它既是数据类型属性又是对象属性）。
• 显式声明（Explicit typing）。不仅所有的资源必须进行划分（如前面的约束中提到的），而且必须进行显式地声明。例如，如果一个本体包括：
<owl:Class rdf:ID="C1">
<rdfs:subClassOf rdf:about="#C2" />
</owl:Class>
这已经表示C2是一个类（通过rdfs:subClassOf的值域可以确定）。然而，OWL DL本体仍须显式地声明：
<owl:Class rdf:ID="C2"/>
• 属性分离（Property separation）。由第一条约束可得出，对象属性集和数据类型属性集是不相交的。这意味着下面的这些声明不能用于数据类型属性：
owl:inverseOf,
owl:FunctionalProperty,
owl:InverseFunctionalProperty,
owl:SymmetricProperty
• 没有传递基数约束（No transitive cardinality restrictions）。该规则应用于传递属性（或者是它们的子属性，显然它们也是传递的）。注：OWL Lite和OWL DL给出了关于传递属性的一个边界条件：传递属性和它的父属性（superproperty）不能有值为1的最大基数（maxCardinality）限制。如果没有这个边界条件，OWL Lite和OWL DL都将成为不可判定语言。
• 受限的匿名类（Restricted anonymous classes）。匿名类只能作为owl:equivalentClass或owl:disjointWith的定义域和值域出现，并且可以作为rdfs:subClassOf的值域（但不能是定义域）。
OWL Lite
• 一个OWL Lite本体必须是一个OWL DL本体，并且还必须满足以下约束：
• 语言成分owl:oneOf, owl:disjointWith, owl:unionOf,owl:complementOf 和owl:hasValue是不允许的。
• 基数（最小基数，最大基数，和精确基数）只能声明为0和1，不再是任意非负整数。
• owl:equivalentClass不能在匿名类间声明，而只能在类标识符间声明。

4.3  实例
4.3.1  一个非洲野生动植物本体
    这个例子展示了一个描述非洲野生动植物的本体。图4.3说明了基类和子类之间的关系。注意子类信息只是本体包括的部分信息。其完整图大得多。图4.4用图示表示分枝是树的组成部分。
本体包含用rdfs:comment书写的注解。
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:owl ="http://www.w3.org/2002/07/owl#">
<owl:Ontology rdf:about="xml:base"/>

<owl:Class rdf:ID="animal">
<rdfs:comment>Animals form a class.</rdfs:comment>
</owl:Class>

<owl:Class rdf:ID="plant">
<rdfs:comment>
Plants form a class disjoint from animals.
</rdfs:comment>
<owl:disjointWith rdf:resource="#animal"/>
</owl:Class>

<owl:Class rdf:ID="tree">
<rdfs:comment>Trees are a type of plant.</rdfs:comment>
<rdfs:subClassOf rdf:resource="#plant"/>
</owl:Class>

<owl:Class rdf:ID="branch">
<rdfs:comment>Branches are parts of trees.</rdfs:comment>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#is_part_of"/>
<owl:allValuesFrom rdf:resource="#tree"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:ID="leaf">
<rdfs:comment>Leaves are parts of branches.</rdfs:comment>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#is_part_of"/>
<owl:allValuesFrom rdf:resource="#branch"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:ID="herbivore">
<rdfs:comment>
Herbivores are exactly those animals that eat only plants
or parts of plants.
</rdfs:comment>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#animal"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#eats"/>
<owl:allValuesFrom>
<owl:Class>
<owl:unionOf rdf:parseType="Collection">
<owl:Class rdf:about="#plant"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#is_part_of"/>
<owl:allValuesFrom rdf:resource="#plant"/>
</owl:Restriction>
</owl:unionOf>
</owl:Class>
</owl:allValuesFrom>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>

<owl:Class rdf:ID="carnivore">
<rdfs:comment>
Carnivores are exactly those animals that eat animals.
</rdfs:comment>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#animal"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#eats"/>
<owl:someValuesFrom rdf:resource="#animal"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>

<owl:Class rdf:ID="giraffe">
<rdfs:comment>
Giraffes are herbivores, and they eat only leaves.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#herbivore"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#eats"/>
<owl:allValuesFrom rdf:resource="#leaf"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:ID="lion">
<rdfs:comment>
Lions are animals that eat only herbivores.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#carnivore"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#eats"/>
<owl:allValuesFrom rdf:resource="#herbivore"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:ID="tasty_plant">
<rdfs:comment>
Tasty plants are plants that are eaten
both by herbivores and carnivores.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#plant"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#eaten_by"/>
<owl:someValuesFrom>
<owl:Class rdf:about="#herbivore"/>
</owl:someValuesFrom>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#eaten_by"/>
<owl:someValuesFrom>
<owl:Class rdf:about="#carnivore"/>
</owl:someValuesFrom>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>

<owl:TransitiveProperty rdf:ID="is_part_of"/>

<owl:ObjectProperty rdf:ID="eats">
<rdfs:domain rdf:resource="#animal"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="eaten_by">
<owl:inverseOf rdf:resource="#eats"/>
</owl:ObjectProperty>

</rdf:RDF>

4.3.2 一个打印机本体
这个例子的类与子类的关系如图4.5所示。
<!DOCTYPE owl [
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
]>

<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:owl ="http://www.w3.org/2002/07/owl#"
xmlns="http://www.cs.vu.nl/~frankh/spool/printer.owl#">

<owl:Ontology rdf:about="">
<owl:versionInfo>
My example version 1.2, 17 October 2002
</owl:versionInfo>
</owl:Ontology>

<owl:Class rdf:ID="product">
<rdfs:comment>Products form a class.</rdfs:comment>
</owl:Class>

<owl:Class rdf:ID="padid">
<rdfs:comment>
Printing and digital imaging devices
form a subclass of products.
</rdfs:comment>
<rdfs:label>Device</rdfs:label>
<rdfs:subClassOf rdf:resource="#product"/>
</owl:Class>

<owl:Class rdf:ID="hpProduct">
<rdfs:comment>
HP products are exactly those products
that are manufactured by Hewlett Packard.
</rdfs:comment>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#product"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#manufactured_by"/>
<owl:hasValue rdf:datatype="&xsd;string">
Hewlett Packard
</owl:hasValue>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>

<owl:Class rdf:ID="printer">
<rdfs:comment>
Printers are printing and digital imaging devices.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#padid"/>
</owl:Class>

<owl:Class rdf:ID="personalPrinter">
<rdfs:comment>
Printers for personal use form a subclass of printers.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#printer"/>
</owl:Class>

<owl:Class rdf:ID="hpPrinter">
<rdfs:comment>
HP printers are HP products and printers.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#printer"/>
<rdfs:subClassOf rdf:resource="#hpProduct"/>
</owl:Class>

<owl:Class rdf:ID="laserJetPrinter">
<rdfs:comment>
Laser jet printers are exactly those
printers that use laser jet printing technology.
</rdfs:comment>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#printer"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#printingTechnology"/>
<owl:hasValue rdf:datatype="&xsd;string">
laser jet
</owl:hasValue>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>

<owl:Class rdf:ID="hpLaserJetPrinter">
<rdfs:comment>
HP laser jet printers are HP products
and laser jet printers.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#laserJetPrinter"/>
<rdfs:subClassOf rdf:resource="#hpPrinter"/>
</owl:Class>

<owl:Class rdf:ID="1100series">
<rdfs:comment>
1100series printers are HP laser jet printers with
8ppm printing speed and 600dpi printing resolution.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#hpLaserJetPrinter"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#printingSpeed"/>
<owl:hasValue rdf:datatype="&xsd;string">
8ppm
</owl:hasValue>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#printingResolution"/>
<owl:hasValue rdf:datatype="&xsd;string">
600dpi
</owl:hasValue>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:ID="1100se">
<rdfs:comment>
1100se printers belong to the 1100 series and cost $450.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#1100series"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#price"/>
<owl:hasValue rdf:datatype="&xsd;integer">
450
</owl:hasValue>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>

<owl:Class rdf:ID="1100xi">
<rdfs:comment>
1100xi printers belong to the 1100 series and cost $350.
</rdfs:comment>
<rdfs:subClassOf rdf:resource="#1100series"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#price"/>
<owl:hasValue rdf:datatype="&xsd;integer">
350
</owl:hasValue>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>

<owl:DatatypeProperty rdf:ID="manufactured_by">
<rdfs:domain rdf:resource="#product"/>
<rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty rdf:ID="price">
<rdfs:domain rdf:resource="#product"/>
<rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty rdf:ID="printingTechnology">
<rdfs:domain rdf:resource="#printer"/>
<rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty rdf:ID="printingResolution">
<rdfs:domain rdf:resource="#printer"/>
<rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>

<owl:DatatypeProperty rdf:ID="printingSpeed">
<rdfs:domain rdf:resource="#printer"/>
<rdfs:range rdf:resource="&xsd;string"/>
</owl:DatatypeProperty>

</rdf:RDF>
这个本体示范了层次树中的兄弟姐妹不必是不相交的。例如，一个私人打印机可能是HP打印机也可能是LaserJet打印机，虽然这三个类都是所有打印机的类的子类。
4.4  OWL中的OWL（OWL in OWL）
下面我们介绍一部分用OWL术语定义的OWL自身的定义。在网上可找到完整的描述（见参考文献）。我们将对OWL中还未讨论的一些问题进行评论。
4.4.1  命名空间（Namespaces）
<?xml version="1.0"?>
<!DOCTYPE owl [
<!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
xml:base ="http://www.w3.org/2002/07/owl"
xmlns ="&owl;"
xmlns:owl ="&owl;"
xmlns:rdf ="&rdf;"
xmlns:rdfs="&rdfs;"
xmlns:dc ="http://purl.org/dc/elements/1.1/">
    当前文档的URI（OWL定义）被定义为缺省的命名空间。因此，后面将不使用前缀owl:。还需注意XML实体定义的用法，它可以使我们在属性（attribute）值中简写URL。
4.4.2 类的类（元类Metaclasses）
所有OWL类的类本身也是所有RDFS类的类的一个子类：
<rdfs:Class rdf:ID="Class">
<rdfs:label>Class</rdfs:label>
<rdfs:comment>The class of all OWL classes</rdfs:comment>
<rdfs:subClassOf rdf:resource="&rdfs;Class"/>
</rdfs:Class>
Thing是OWL中最一般的类，而Nothing是最特殊的类，即空对象类。它们有下面的关系：
Thing = Nothing∪NothingC
Nothing = ThingC = NothingC ∩NothingCC= Φ;
<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>
4.4.3 类的等价（Class Equivalence）
owl:EquivalentClass表示类的等价关系，隐含了一个子类关系，并且总是在两个类之间声明。owl:EquivalentProperty表示类似的属性的等价关系。不相交声明只能在类与类之间声明。
<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="EquivalentProperty">
<rdfs:label>EquivalentProperty</rdfs:label>
<rdfs:subPropertyOf rdf:resource="&rdfs;subPropertyOf"/>
</rdf:Property>

<rdf:Property rdf:ID="disjointWith">
<rdfs:label>disjointWith</rdfs:label>
<rdfs:domain rdf:resource="#Class"/>
<rdfs:range rdf:resource="#Class"/>
</rdf:Property>
任意两个事物之间可以声明为相同或不相同；在OWL Full中，类与类之间也可以使用这个声明。owl:sameAs仅仅是owl:sameIndividualAs的同义词。
<rdf:Property rdf:ID="sameIndividualAs">
<rdfs:label>sameIndividualAs</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>

<rdf:Property rdf:ID="sameAs">
<rdfs:label>sameAs</rdfs:label>
<EquivalentProperty rdf:resource="#sameIndividualAs"/>
</rdf:Property>
owl:distinctMembers属性只能用于owl:AllDifferent类：
<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>
4.4.4 从其它的类创建类
    owl:unionOf通过一个清单来创建一个类(该清单列出了其他类的表达式)。
<rdf:Property rdf:ID="unionOf">
<rdfs:label>unionOf</rdfs:label>
<rdfs:domain rdf:resource="#Class"/>
<rdfs:range rdf:resource="&rdf;List"/>
</rdf:Property>
owl:intersectionOf和owl:oneOf也是通过一个清单来创建类。但是owl:one of是列举出组成这个类的所有个体。owl:complementOf通过单一的其它类来定义类。
<rdf:Property rdf:ID="complementOf">
<rdfs:label>complementOf</rdfs:label>
<rdfs:domain rdf:resource="#Class"/>
<rdfs:range rdf:resource="#Class"/>
</rdf:Property>
4.4.5 类的属性的约束
    OWL中的约束用来定义满足某些条件的那些对象的类。
<rdfs:Class rdf:ID="Restriction">
<rdfs:label>Restriction</rdfs:label>
<rdfs:subClassOf rdf:resource="#Class"/>
</rdfs:Class>
    下面列出的属性只允许在约束定义中出现，即它们的定义域是owl:Restriction，但是它们对应的值域可以不同：
<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="minCardinality">
<rdfs:label>minCardinality</rdfs:label>
<rdfs:domain rdf:resource="#Restriction"/>
<rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
</rdf:Property>
owl:maxCardinality和owl:cardinality的定义与owl:minCardinality类似， owl:someValuesFrom的定义与owl:allValuesFrom类似。
对于owl:onProperty，是允许约束对象属性还是约束数据类型属性，区分这点是没有意义的。因此，约束属性owl:allValuesFrom的值域不是owl:Class（对象类）而是更一般的rdfs:Class类。
属性（Properties）
owl:ObjectProperty是rdf:Property的一个特例：
<rdfs:Class rdf:ID="ObjectProperty">
<rdfs:label>ObjectProperty</rdfs:label>
<rdfs:subClassOf rdf:resource="&rdf;Property"/>
</rdfs:Class>
owl:DatatypeProperty与owl:ObjectProperty类似：
owl:TransitiveProperty只能用于对象属性：
<rdfs:Class rdf:ID="TransitiveProperty">
<rdfs:label>TransitiveProperty</rdfs:label>
<rdfs:subClassOf rdf:resource="#ObjectProperty"/>
</rdfs:Class>
对称、函数和反函数属性与传递属性类似。
最后，owl:inverseOf与两个对象属性关联。
<rdf:Property rdf:ID="inverseOf">
<rdfs:label>inverseOf</rdfs:label>
<rdfs:domain rdf:resource="#ObjectProperty"/>
<rdfs:range rdf:resource="#ObjectProperty"/>
</rdf:Property>
虽然在线参考文档中并未提到，但是下面的声明也是正确的：
<TransitiveProperty rdf:ID="&rdfs;subClassOf"/>
<TransitiveProperty rdf:ID="&rdfs;subProperty/>

<rdf:Property rdf:about="cardinality">
<rdfs:subPropertyOf rdf:resource="mincardinality"/>
<rdfs:subPropertyOf rdf:resource="maxcardinality"/>
</rdf:Property>

<SymmetricProperty rdf:ID="inverseOf"/>
<rdf:Property rdf:about="inverseOf">
<inverseOf rdf:resource="inverseOf"/>
</rdf:Property>
    虽然这里用OWL语言阐述了部分OWL语义，但是并没有包括全部语义。因此单独的语义规范是必要的（OWL标准中有提供）。
4.5  将来的扩展（Future Extensions）
显然，OWL不是语义网的本体语言的最终语言。在OWL的需求文档中已经确定了许多其他的特征，还有许多正在讨论之中。本节中，我简要地列出一些对OWL的可能的扩展和改进。
4.5.1  模块和引入（Modules and Imports）
    引入别人定义好的本体将成为语义网的标准。然而，OWL的引入功能非常微不足道：OWL只允许引入整个本体，并指定其位置。即使这个本体只想使用另一个本体的很小一部分，它也要被迫引入整个本体。程序语言中的模块-构造是基于信息隐藏的想法的：模块把某个功能提供给外部世界（通过模块的输出子句），但是引入了模块的模块本身不必关心这个功能是如何实现的。相应的有关本体的信息隐藏的想法应该是怎样的，以及如何运用它构建良好的引入，是个开放性的研究问题。
4.5.2  缺省（Defaults）
    许多应用知识表示系统允许层次结构中更特殊的类覆写继承的值，并且把继承的值作为缺省值。虽然这种方法在实践中广泛应用，但是，如何对缺省值的非单调性恰当的形式化，还未达到一致意见。
4.5.3  封闭世界假设（Closed-World Assumption）
    现在OWL的语义采用的是基于开放世界假设的标准逻辑模型：如果不能证明一个陈述是真的，那么这个陈述就不能假定为是真的。显然，在巨大的并且仅部分可知的万维网中，这个假设是正确的。然而，在某些特定的应用中，相反的解决方法（封闭世界假设：如果不能证明一个陈述的否定是真的，那么这个陈述是真的）也是有用的。封闭世界假设与缺省的概念有密切联系，因而会导致同样的非单调性，OWL中不包含关于它的推理。
4.5.4  唯一名假设（Unique-Names Assumption）
    传统数据应用系统中假设不同名字的个体是真正的不同的个体。OWL遵循通常的逻辑范例，并不采用这种假设。如果两个个体（类或属性）有不同的名字，我可能还是会通过推理得出它们是同一个个体。与非封闭世界假设一样，非唯一名假设是针对万维网做出的似乎最有道理的假设。但是跟前面一样，唯一名假设在某些情况下是有用的。人们可能希望能更精细地指出本体的各部分采用还是不采用唯一名假设。
4.5.5  附属过程（Procedural Attachment）
    知识表示系统的一个普遍观点是对术语的定义并不是通过在语言中（如OWL）对术语进行明确定义，而是通过附加一段执行代码来计算术语的含义。虽然这种观点应用得很广泛，但是它并不很好地用于具有形式语义的系统内集成，而且OWL中也没有包含它。
4.5.6  属性链规则（Rules for Property Chaining）
如前面所解释的，为了使OWL可判定，OWL现在不允许属性的合成，但是当然在很多应用中这是很有用的操作。更普遍地，人们会希望将属性定义为其它属性之上的一般规则（如霍恩子句Horn或其它）。基于规则的知识表示系统和DL类型的知识表示系统的这种集成当前非常活跃的研究领域。
这里提到的一些问题（规则、非单调性）将在第5章进行讨论。
4.6  总结（Summary）
    OWL是被提议的Web本体语言。它使我们以机器可达的方式描述知识的语义。
    OWL建立于RDF和RDFS之上：使用RDF语法（基于XML）；使用RDF描述定义实例；使用大部分RDFS建模原语。
    通过将OWL映射到逻辑上，提供形式化的语义和推理支持。基于此目的，使用了谓词逻辑和描述逻辑。
    虽然OWL应用于实际是十分丰富的，其扩展版本仍正在发展中。它们将提供更多的逻辑特征，包括规则。
建议阅读的资料
下面是OWL的主要的参考文献：
• D. McGuinness and F van Harmelen, eds. OWLWeb Ontology Language Overview. August 18, 2003. <http://www.w3.org/TR/owl-features/>.
• M. Dean and G. Schreiber, eds. F. van Harmelen, J. Hendler, I. Horrocks, D. McGuinness, P. Patel-Schneider, L. Stein, OWL Web Ontology Language Reference. August 18, 2003. <http://www.w3.org/TR/owl-ref/>.
• M. Smith, C.Welty, and D. McGuinness, eds. OWLWeb Ontology Language: Guide. August 18, 2003. <http://www.w3.org/TR/owl-guide/>.
与DAML+OIL和OIL相关的有趣的文章：
• J. Broekstra, M. Klein, S. Decker, D. Fensel, F. van Harmelen, and I. Horrocks, Enabling knowledge representation on the Web by Extending RDF Schema. In Proceedings of the 10th World Wide Web Conference (WWW10), 2001. <http://www10.org/cdrom/papers/291/>
• D. Fensel, I. Horrocks, F. van Harmelen, D. McGuinness and P. Patel- Schneider. OIL: An Ontology Infrastructure for the Semantic Web. IEEE Intelligent Systems 16 March-April (2001): 38–45. <http://www.cs.vu.nl/ frankh/abstracts/IEEE-IS01.html>.
• D. McGuiness. Ontologies come of age. In Spinning the Semantic Web, ed. D. Fensel, J. Hendler, H. Lieberman and W. Wahlster. MIT Press 2003.
• P. Patel-Schneider, I. Horrocks and F. van Harmelen, Reviewing the Design of DAML+OIL: An Ontology Language for the Semantic Web, In Proceedings of the 18th National Conference on Artificial Intelligence (AAAI02). 2002. <http://www.cs.vu.nl/ frankh/abstracts/AAAI02.html>.
下面是有关描述逻辑的一些参考文献：
• F. Baader, D. Calvanese, D. McGuinness, D. Nardi, P. Patel-Schneider, eds. The Description Logic Handbook: Theory, Implementation and Applications. Cambrdge: Cambridge University Press, 2002.
• E. Franconi. Description Logics Course Informaton. <http://www.cs.man.ac.uk/_franconi/dl/course/>.
• I. Horrocks and U. Sattler. Ontology Reasoning in the SHOQ(D) Description Logic. In Proceedings of the 17th International Joint Conference on Artificial Intelligence (IJCAI-01). 2001, 199–204.
• I. Horrocks. Tutorial on Description Logic. <http://www.cs.man.ac.uk/_horrocks/Slides/IJCAR-tutorial/Print/>.
下面是两个有趣的WEB网站：
• <http://www.w3.org/2001/sw/WebOnt/>. Information on OWL.
• <http://www.daml.org>. Information on DAML+OIL. See especially the pages /language, /ontologies and /tools.
下面是与本体的普遍观念有关的一些链接，而这些观念本质上与本章的内容有很大的不同。Thesauri（叙词表）是简单的非正规的本体。
• <http://www.lub.lu.se/metadata/subject-help.html>. An extensive collection of pointers to thesauri.
• <http://www.topicmaps.org>. Topic maps constitute a simple ontology language in use today.
• <http://dublincore.org>. An example of an ontology used extensively in the digital library domain is the Dublin Core.
练习和项目（Exercises and Projects）
4.1 在http://w3.org上阅读OWL的在线规范和完整命名；
4.2 给出三种不同的方法声明两个类是不相交的；
4.3 描述事实：所有的数学课程只能由David Billington来教（不考虑其它的课程）。再描述事实：数学课程正好(exactly)是David Billington教授的课程。是否清楚两者的不同？
4.4 严格地说，对称属性（SymmetricProperty）在OWL中不是必要的，因为它可以用其它的语言原语来表达。解释如何做到这点（提示：也可以考虑逆反（inverse））。
4.5 对于函数属性（FunctionalProperty）回答类似的问题。如何用其它的OWL语言成分来表达它。
4.6 大致上确定OWL的哪些特征是必需的，哪些仅仅是为方便起见，但可以用其它的建模原语实现。
4.7 在以非洲野生物为例的本体中，如果在carnivores（食肉动物）的定义中我们用owl:someValuesFrom替代owl:allValuesFrom，将会出现什么问题？（提示：考虑tasty
Plants的定义）。
4.8 陈述下面的概念之间的关系：
FunctionalProperty、InverseFunctionalProperty和Inverseof
4.9 解释为什么把owl:Class声明为rdfs:Class的子类是必需的。
4.10 在第3章中我们提到了RDF的公理语义。关于OWL也可以开发类似的公理语义。定义intersectionOf的公理语义。
4.11 定义inverseOf的公理语义。
4.12 开发基数约束的公理语义：
(a)定义noRepeatsList。如果在L中没有任何一个元素出现的次数超过一次，则L是一个“非重复列表”（no repeats list）。这个概念不是OWL语言的一部分，但是将用于计算基数约束的元素的个数。
(b)定义minCardinality和maxCardinality属性的定义域为Restriction，值域为NonNegativeInteger。
(c) 给出一个能俘获minCardinality的语义的公理：如果onProperty(R, P)并且 minCardinality(R, n)，则x是R的一个实例。如果，且仅仅如果存在一个”非重复列表”L且L的长度≥n，则对所有的y∈L，有： P(x, y)。
(d)用类似的方法表达maxCardinality的语义。
4.13 看一看<http://www.daml.org/ontologies>上的本体。
4.14 用OWL语言写出你自己的本体。
4.15 OIL是OWL的前身。阅读关于OIL语言的章节和一些本体实例。比较OIL语言与OWL语言，注意两者的共同点和不同点。
4.16 比较OWL与DAML+OIL的在线文档。
4.17  用OWL的术语重新写出DAML+OIL文档中的一些实例。
4.18 试试思考OWL中还缺少的特征。提示：考虑项目和相关的人。对于每个项目什么条件应该是真的，以及对于每个人（对其所属公司重要的人）什么条件应该是真的？你能用OWL表达出这些条件吗？

译者附：文中的引用标注：
1. <http://www.w3.org/2001/sw/WebOnt/>
2. <http://www.daml.org/2001/03/daml+oil-index.html>
3. <http://www.daml.org/2000/10/daml-ont.html>
4. <http://www.ontoknowledge.org/oil/>
5. defined in http://www.w3.org/TR/owl-xmlsyntax/
6. <http://www.w3.org/TR/owl-semantics/>
7. owl:Class is a subclass of rdfs:Class.


	W 3 C h i n a ( since 2003 ) 旗下站点苏ICP备05006046号《全国人大常委会关于维护互联网安全的决定》《计算机信息网络国际联网安全保护管理办法》	189.453ms