ontology OWL

本主题由 admin_cn 于 7-12-2007 17:39 移动

shadow

ZOBBA FOUNDER

Rank: 8 Rank: 8

发短消息
加为好友
当前离线

1楼大中小发表于 7-12-2007 15:52 只看该作者

ontology OWL

* XML (http://www.w3.org/XML/)提供了一种结构化文档的表层语法，但没有对这些文档的含义施加任何语义约束。
* XML Schema (http://www.w3.org/XML/Schema)是一个约束XML文档结构和为XML扩充了数据类型的语言。
* RDF (http://www.w3.org/TR/2002/WD-rdf-concepts-20021108/)是一个关于对象（或资源）和它们之间关系的数据模型，且为该数据模型提供了简单的语义，这个数据模型能够用XML语法表示。6 r' u' f0 Z* G) @4 N: h! V. I
* RDF Schema (http://www.w3.org/TR/2002/WD-rdf-schema-20021112/)是一个描述RDF资源的属性（property）和类（classe）的词汇表，提供了关于这些属性和类的层次结构的语义。
* OWL 添加了更多的用于描述属性和类的词汇，例如类之间的不相交性（disjointness）、基数（cardinality，如刚好一个）、等价性、属性的更丰富类型、属性特征（例如对称性）、以及枚举类(enumerated classes)。 / q3 t/ u. p" L) c( O9 j7 t
OWL旨在用于那些需要由应用程序而不是由人类来处理文档中的信息的情形。OWL可被用来明确表示词汇表中术语的含义以及术语间的关系。如此表示的术语及术语间的关系的表示被称为本体(ontology)。在表达含义和语义方面，OWL比XML、RDF和RDF-S有更多的表达手段，因此在Web上表达机器可理解内容的能力也比这些语言强。OWL是DAML+OIL Web本体语言 (http://www.w3.org/TR/2004/REC-ow ... 0210/#DAMLReference)的修改版，并吸取了在DAML+OIL的设计和应用中得到的经验教训。
OWL语言的使用：
* 通过定义类以及类的属性来形式化某个领域；0 f& T0 J( A: s  N% e# l
* 定义个体并说明它们之间的属性；
* 在OWL语言的形式化语义允许的层次上，对类和个体进行推理。: U* {4 U* _" ?1 Z9 v2 K
/ Q  W+ K, c3 H8 ^1 S
OWL提供了三种表达能力递增的子语言，以分别用于特定的实现者和用户团体。2 L: l# g1 p0 W
* OWL Lite用于提供给那些只需要一个分类层次和简单约束的用户。例如，虽然OWL Lite支持支持基数限制，但只允许基数为0或1。提供支持OWL Lite的工具应该比支持其他表达能力更强的OWL子语言更简单，并且从辞典（thesauri）和分类系统（taxonomy）转换到OWL Lite更为迅速。相比OWL DL，OWL Lite还具有更低的形式复杂度，详细信息参考OWL 参考（OWL Reference）的OWL Lite部分 (http://www.w3.org/TR/owl-ref/#OWLLite)。1 {' X/ \: n% _
* OWL DL用于支持那些需要最强表达能力而需要保持计算完备性（computational completeness，即所有的结论都能够确保被计算出来）和可判定性（decidability，即所有的计算都能在有限的时间内完成）。OWL DL包括了OWL语言的所有语言成分，但使用时必须符合一定的约束，例如，一个类可以是多个类的子类时，但它不能同时是另外一个类的实例。OWL DL 这么命名是因为它对应于描述逻辑，它是一个研究作为OWL形式基础的逻辑的研究领域。
* OWL Full支持那些需要尽管没有可计算性保证，但有最强的表达能力和完全自由的RDF语法的用户。例如，在 OWL Full中，一个类可以被同时看为许多个体的一个集合以及本身作为一个个体。它允许在一个本体增加预定义的（RDF、OWL）词汇的含义。这样，不太可能有推理软件能支持对OWL FULL的所有成分的完全推理。; x3 a9 l8 F" H' }
* 每个合法的OWL Lite本体都是一个合法的OWL DL本体； * 每个合法的OWL DL本体都是一个合法的OWL Full本体；
* 每个有效的OWL Lite结论都是一个有效的OWL DL结论； * 每个有效的OWL DL结论都是一个有效的OWL Full结论。 ! `0 I/ ], Q; U# E, q6 d
OWL Full可以看成是对RDF的扩展，而 OWL Lite和OWL DL可以看成是对一个受限的RDF版本的扩展。所有的OWL文档（Lite，DL，Full）都是一个RDF文档；所有的RDF文档都是一个OWL Full文档，但只有一些RDF文档是一个合法的OWL Lite和OWL DL文档。
: \. \3 D  U6 V$ J4 H' }
OWL Lite语言的构词（constructs）如下列出：
RDF Schema特性：
* Class (Thing, Nothing)
* rdfs:subClassOf
* rdf:Property ' t' n5 `  o3 c! t6 Y- e
* rdfs:subPropertyOf , u, ^6 k2 {% _& k2 ]
* rdfs:domain 9 a0 i, x5 @) }1 Q/ u& h& P
* rdfs:range
* Individual
(不)等价性：
* equivalentClass / k/ E' s& A0 T- G
* equivalentProperty * M2 X0 N$ {0 D6 H
* sameAs 6 z/ d, a; D& H& J  i; I! e
* differentFrom
* AllDifferent
* distinctMembers
属性特征：
* ObjectProperty
* DatatypeProperty & ]5 c7 {8 a) q$ Q6 J( p- z
* inverseOf
* TransitiveProperty 4 l3 E# l, W: T$ m8 x0 E# T5 _
* SymmetricProperty   R/ ]6 H6 z7 d
* FunctionalProperty
* InverseFunctionalProperty $ i0 G# z! a# a. [- ^
属性约束：
* Restriction 9 W( f2 N* d6 c4 c+ M" Z
* onProperty
* allValuesFrom 7 n6 w  g0 B2 b/ `
* someValuesFrom
受限基数：
* minCardinality (仅仅0或1)% k" {; p! r2 G' ^& }/ e
* maxCardinality (仅仅0或1)
* cardinality (仅仅0或1)3 g% F; Z8 g/ p* p
头信息：3 ^" Q4 F5 m9 u! a! M( o1 d
* Ontology   ^9 _$ _. ?# Y
* imports
类的交集：; [9 S4 r: }5 Y  O
* intersectionOf
版本信息：
* versionInfo / N4 T7 j5 m8 X1 x# ~4 ?
* priorVersion
* backwardCompatibleWith 4 f4 r! \+ v" C0 t) Y* a) d7 `
* incompatibleWith
* DeprecatedClass ; v" A" o- s% H& t! r- C
* DeprecatedProperty
注解属性：/ t, d& e' Q3 T8 l$ o, U" A9 V1 ~
* rdfs:label ' _* _  C2 X6 o$ v$ O
* rdfs:comment! ?4 p# F( e' Q# C9 b; a4 Z- c
* rdfs:seeAlso * C: w! k9 p3 r$ [' \& W
* rdfs:isDefinedBy ! ?/ Y( X" x1 T0 G! _
* AnnotationProperty
* OntologyProperty
数据类型：
* xsd datatypes 7 T/ s# [3 c9 |) _: ]

OWL DL和Full概要：
类的公理：; U* b9 y' E8 u% T1 Y: c
* oneOf, dataRange ) v, h  W$ y; F6 L3 J9 k
* disjointWith , J4 }4 q+ z4 t* V$ X3 L  `" U
* equivalentClass (可应用于类表达式)
* rdfs:subClassOf (可应用于类表达式)8 R  ~2 b# r! V
类表达式的布尔组合：
* unionOf 4 x% o7 Y( X4 B) E# A
* complementOf 6 Q$ O! I+ P9 X
* intersectionOf 4 h6 Z3 E. `9 Y5 Q- Z" S& b$ I1 |
任意的基数：9 Q, ^' D. W. b
* minCardinality - ]  E! `% }! t/ V# i( ~% X
* maxCardinality/ J* r: `" [( r1 R( {. u' |0 {
* cardinality
填充值信息：- B. U* J5 h# g1 q: z+ C: c2 S# z
* hasValue . h7 V7 G# H# q

1.本体的结构
OWL是语义网活动的一个组成部分。这项工作的目的是通过对增加关于那些描述或提供网络内容的资源的信息，从而使网络资源能够更8 U) J9 i& _9 Q  N0 d
容易地被那些自动进程访问。由于语义网络固有的分布性，OWL必须允许信息能够从分布的信息源收集起来。其中，允许本体间相互联
系，包括明确导入其他本体的信息，能够部分实现这样的功能。$ q6 }- w; m* a( A
另外，OWL提出了一个开放世界的假设。也就是说，对资源的描述并不局限于在一个简单的文件或范围内。类C1本来是由本体O1定义出
来的，然而，它也可以是由其他的本体扩展出来的。对C1进行这样的假设的结果是单调的。新的信息不能否定之前的信息。新的信息
可以是和旧的信息矛盾的，但是事实和推导只能被增加而不能被删减。) M$ X0 E5 z4 B7 u6 D
当设计一个本体的时候，设计者必须考虑到这种矛盾的可能性。一种期望是，工具的支持将帮助侦测到这样的情况。7 |' I5 t% E; @; `$ j
为了能写出一个能被唯一翻译的而且能被软件（代理）使用的本体，我们要求OWL有一个语法和正规的语义。5 [/ P4 X- U  e: E% j

2.命名空间# H2 M: U% B" h+ E0 X
<rdf:RDF 3 d, R0 h' {0 _5 e1 {3 o
   xmlns    ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" $ c8 P5 n9 A( [5 [& y' v0 V, W6 l
   xmlns:vin ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" . U$ I) \) T+ D; @9 i, t
   xml:base  ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#"
   xmlns:food="http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#" * j# d: x( |) t0 `  D% M: D
   xmlns:owl ="http://www.w3.org/2002/07/owl#"- [/ a* D# V0 y# L2 Z
   xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"& E0 J; s0 a0 |( Y
   xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
   xmlns:xsd ="http://www.w3.org/2001/XMLSchema#">
前两个声明标识了与该本体相关的命名空间。第一个声明指定了缺省命名空间，即表明所有无前缀的限定名（qualified names）都出
自当前本体。第二个声明为当前本体指定了前缀 vin:。第三个声明为当前文档（参见下文 (http://www.w3.org/TR/2004/REC-owl-, r/ T/ \  {- p3 t; H) V& d: J
guide-20040210/#owl_imports)）指定了基准URI（base URI）。第四个声明指出食物（food）本体将用前缀food:来标识。
第五个命名空间声明指出，在当前文档中，前缀为owl:的元素应被理解是对出自http://www.w3.org/2002/07/owl#中的事物的引用。
这是引入OWL词汇表的惯例用法。4 ]: a) @1 k4 J" y7 K% J8 M/ w& p/ a
OWL要依赖RDF、RDFS以及XML Schema数据类型中的构词（constructs）。在本文档中，rdf:前缀表明事物出自命名空间 % V* e0 ~& H9 w: ~
http://www.w3.org/1999/02/22-rdf-syntax-ns#。接下来的两个命名空间声明分别为RDF Schema和XML Schema数据类型指定前缀
rdfs:和xsd:。
; Q' {; E0 G" G6 Z" h: p4 j
3.实体定义
为帮助书写冗长的URLs，在本体的定义之前，在文档类型声明（DOCTYPE）中提供一些实体定义（entity definitions）常常是很有用- t* b5 d( e/ A
的。这些被命名空间声明定义的名称仅当作为XML标签的一部分时才具有意义。属性值（attribute values）是不具有命名空间的。但( m, g) q1 {$ x( n. R0 x# S" t
是在OWL里，我们经常要用属性值来引用本体标识符。我们可以写出它们的完整URI形式，比如“http://www.w3.org/TR/2004/REC-' M1 P8 q/ ?- {2 b) E* J
owl-guide-20040210/wine#merlot”。或者，利用实体定义来简略URI的书写，例如：9 h) A3 w% i. k2 j
<!DOCTYPE rdf:RDF [
   <!ENTITY vin  "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" >
   <!ENTITY food "http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#" > ]>5 Q3 _0 E7 F# J* n6 j, D- D
在声明这些实体后，可以将“&vin;merlot”作为“http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#merlot”的简写。
所以上述命名空间可写为：
<?xml version="1.0"?>* t1 ]. @. C7 Y5 ]% \" R( M
<!DOCTYPE rdf:RDF [2 g+ O4 @; K7 F6 W
   <!ENTITY vin  "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" >
   <!ENTITY food "http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#" > ]>
<rdf:RDF . b5 g) U  W5 H' s+ d$ z- @8 }
   xmlns    ="&vin;" # Q8 o/ j& z( m
   xmlns:vin ="&vin;" ! ~# X+ o- g, Z6 W
   xml:base  ="&vin;" ( f1 [0 R& q) t
   xmlns:food="&food;": `5 {6 C+ y" U5 q
   xmlns:owl ="http://www.w3.org/2002/07/owl#"
   xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"1 K; W$ g# N, M! J
   xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
   xmlns:xsd ="http://www.w3.org/2001/XMLSchema#"> : h) p+ r0 C5 A+ U6 d
4.本体头部/ U; p' a% X1 J
建立了命名空间后，接下来我们通常要在owl:Ontology标签里给出一组关于本体的声明。这些标签支持一些重要的常务工作比如注释
、版本控制以及其他本体的嵌入等。
<owl:Ontology rdf:about=""> & z# C7 ]5 {+ s7 ~4 T
<rdfs:comment>An example OWL ontology</rdfs:comment>6 W9 s7 e5 r7 `# \4 S; \0 X
<owl:priorVersion rdf:resource="http://www.w3.org/TR/2003/PR-owl-guide-20031215/wine"/>   Q! C$ l; \# r1 c6 @% `2 |
<owl:imports rdf:resource="http://www.w3.org/TR/2004/REC-owl-guide-20040210/food"/> $ T, i; [" C. _7 @: {  f
<rdfs:label>Wine Ontology</rdfs:label>
...
owl:Ontology元素是用来收集关于当前文档的OWL元数据的。% R. E. B: x9 H6 F( |1 t
rdf:about属性为本体提供一个名称或引用。根据标准，当rdf:about属性的值为""时，本体的名称是owl: Ontology元素的基准URI。
典型地，这是一个包含本体的文档的URI。在使用了xml:base的上下文中则是一个特殊情况，这时owl: Ontology元素的基准URI也许会* D; `- m: n) w# T  K: T
被设为其他URI。1 F. E( N: [' F+ q8 f2 K0 J& s) k
rdfs:comment提供了显然必须的为本体添加注解的能力。
owl:priorVersion是一个为用于本体的版本控制系统提供相关信息（hook）的标准标签。, b' e5 Y( L, \' }( f9 x% l
owl:imports提供了一种嵌入机制，接受一个用rdf:resource属性标识的参数。导入另一个本体将把那个本体中的全部声引入到当前本0 @. |) Z6 u% m8 g% O: [
体中。为了充分利用好这一机制，通常要与命名空间声明结合使用。请注意这两种机制的区别：命名空间声明提供的是一种方便对其( T% i% {8 S" R' ~2 A. w/ j4 f
他本体定义的名称进行引用的方法。概念上，owl:imports用于表明包含目标本体中的声明。在导入另一个本体02时，在02中导入的其" n' U8 T3 _& K+ t6 ]
他本体也将被导入。/ A$ [$ x! q. H
rdfs:label对本体进行自然语言标注。) D/ i/ }( _" I6 ~7 M5 K
5.基本元素4 R8 T0 x, ^, R7 A, M9 o6 ^$ Y
1> 简单的类和个体
使用本体是为了用它进行关于个体的推理。为了在一种有效的方式下做到这一点，我们需要一种机制来描述个体所属的类以及这些个
体通过类成员关系而继承得到的属性。尽管我们总能为个体声明特定的属性，但是本体的大部分能力在于"基于类的推理"。% f: F4 w3 A, U8 J
当我们希望强调区分一个类是作为对象还是作为包含元素的集合。称由属于某个类的个体所构成的集合为该类的外延(extension)。; t" H( ^8 ]7 T: [
1>>简单的具名类－－Class, rdfs:subClassOf
一个领域中的最基本概念应分别对应于各个分类层次树的根。OWL中的所有个体都是类owl:Thing的成员。因此，各个用户自定义的类! b$ `( s! n4 e2 Z
都隐含地是 owl:Thing的一个子类。要定义特定领域的根类，只需将它们声明为一个具名类（named class）即可。OWL也可以定义空
类，owl:Nothing。$ q4 J; b8 Y/ O/ n: U( r! d
4 Y# v( b+ `3 J9 M, n
定义可以是增量的和分布式的：
语法<owl:Class rdf:ID="Region"/> 被用于引入一个名称（作为定义的一部分）。该rdf:ID属性（attribute）类似于XML中的ID属
性。在这一文档中，我们现在可以用#Region来引用Region类，例如 rdf:resource="#Region"。而其他的本体可以通; N8 ~; y/ v9 o1 {% v4 I0 z& x" A* H
过"http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#Region"这一完整形式来引用该名称。; M% r6 ?- {& Z
语法<owl:Class rdf:about="Region"/>来扩展对一个资源的定义。语法 rdf:about="&ont;#x" 的使用在分布式本体的创建中是一个
关键要素。它允许导入x类的定义并对它进行扩展，而不需修改源定义文档，从而支持增量构建更大的本体。
rdfs:subClassOf是用于类的基本分类构造符。它将一个较具体的类与一个较一般的类关联。如果X是Y的一个子类（subclass），那么
X的每个实例同时也都是Y的实例。rdfs:subClassOf关系是可传递的，即如果X是Y的子类，而Y又是Z的子类，那么X就是Z的子类。% c- l9 c4 w0 \1 b9 Y* q
<owl:Class rdf:ID="Wine"> / U& Y' F* t: Y% j4 p1 L
<rdfs:subClassOf rdf:resource="&food;PotableLiquid"/>
<rdfs:label xml:lang="en">wine</rdfs:label> 4 ?5 y3 y+ L+ V1 B3 S4 [
<rdfs:label xml:lang="fr">vin</rdfs:label>
...
</owl:Class>
rdfs:label是可选的，它为该类提供一个人类可读的名称。负责呈现的工具可以利用这个元素。“lang”属性为多语言提供了支持。
一个label（标号）就像一个注释，不向本体的逻辑解释添加任何内容。- u+ n/ `, m, l0 e# V2 N1 v5 @( `
2>>个体
要引入一个个体（individual），只需将它们声明为某个类的成员。
<owl:Class rdf:ID="WineGrape"># S- _8 O2 Q7 d' }
<rdfs:subClassOf rdf:resource="&food;Grape" />
</owl:Class>
<WineGrape rdf:ID="CabernetSauvignonGrape" />1 J5 p0 m) e$ q- J6 U; F1 j  n% c4 y
关于OWL中类与个体的区别，有一些重要的问题。一个类仅是一个名称和一些描述某集合内个体的属性；而个体是该集合的成员。因此
，类应自然地对应于与某论域中的事物的出现集合，而个体应对应于可被归入这些类的实际的实体。! L- A! P! F& N" h9 \
2>简单属性& N- k" C9 V2 _9 P+ j1 t  V- w
1>>定义属性－－ObjectProperty, DatatypeProperty, rdfs:subPropertyOf, rdfs:domain, rdfs:range4 Z2 K8 b$ [# ?$ _( n6 ?% v
一个属性是一个二元关系。有两种类型的属性：1 J- v) D2 K7 W% S
* 数据类型属性（datatype properties），类实例与RDF文字或XML Schema数据类型间的关系。) P7 p' k0 S1 ?) M2 k: k
* 对象属性（object properties），两个类的实例间的关系。注意：对象属性这个名称并不是要反映与RDF术语rdf:object的联系。: E, \' o" g& |' e) F  A. j7 }8 ~
<owl:ObjectProperty rdf:ID="hasWineDescriptor">( r. m5 |" t# ?( N8 p! D  i1 h# T
<rdfs:domain rdf:resource="#Wine" />2 P1 a  ~0 h  ~7 g8 x  m
<rdfs:range  rdf:resource="#WineDescriptor" />
</owl:ObjectProperty> 5 p; j/ V4 |) y& j  j! E: V
<owl:ObjectProperty rdf:ID="hasColor">
<rdfs:subPropertyOf rdf:resource="#hasWineDescriptor" />- M5 J* [5 Z- I. n* l4 }, c
<rdfs:range rdf:resource="#WineColor" />: ]$ L0 T% |4 _
...: K  A: R7 C6 [5 K; o7 X
</owl:ObjectProperty>
为同一属性声明多个定义域表明该属性的定义域是所有这些类的交集（多个值域声明也类似这样）。属性也可以像类一样按照层次结% L8 F  u% w* k% J$ e
构来组织。
介绍locatedIn属性，它将事物和事物所在的地区相关联：
<owl:ObjectProperty rdf:ID="locatedIn">
...5 g& S1 D" K5 ]
<rdfs:domain rdf:resource="http://www.w3.org/2002/07/owl#Thing" />
<rdfs:range rdf:resource="#Region" />% ~4 e! Y; e# ]2 s' l( x$ I
</owl:ObjectProperty>
该定义域定义允许任何事物被值域某个区域中，包括该区域自身。这一关系的传递的组合本质上构建了一个包含子区域和事物的地理
网络。没有包含其他事物于其中的那些事物可以属于任意类,而包含其他事物或者区域的那些事物则必须是区域。
示例：% H- \8 J# j% r5 T' A
<owl:ObjectProperty rdf:ID="madeFromGrape">
<rdfs:domain rdf:resource="#Wine"/>( o+ q) A$ `0 a! n9 a" x8 Z% o
<rdfs:range rdf:resource="#WineGrape"/> ) a, ?3 ]( U, D9 N
</owl:ObjectProperty>
<owl:Class rdf:ID="Wine">
<rdfs:subClassOf rdf:resource="&food;PotableLiquid"/>
4 y4 U/ R5 F) _  {
<rdfs:subClassOf>- \. z8 d2 ]+ }* o% j/ o( [7 ?
   <owl:Restriction>* n" ]% j2 V  c8 q) ^4 }
      <owl:onProperty rdf:resource="#madeFromGrape"/>
      <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
   </owl:Restriction>& q+ R5 g% V& t* m0 p0 H. C
</rdfs:subClassOf>$ H% W7 x. z% ~1 \" r
...  9 |% ~( f% r/ t1 }" R" w% I
</owl:Class>' \# F; S( g+ ~8 t
第二个子类属性元素中定义了一个无名类（unnamed class），该无名类代表至少具有一个madeFromGrape属性的事物集合。我们称这
些类为匿名类。在Wine类的定义中包含该限定表明属于Wine类的事物，也是该匿名类的成员。也就是说，任何葡萄酒都必须参与至少
一个madeFromGrape关系。" Q% f! t3 c5 }$ Q8 S0 ^
2>>属性和数据类型' @0 N2 T5 f1 z7 V4 Y) L% n
根据是将个体关联到个体、还是将个体关联到数据类型，我们可以区分两类属性：前者称为对象属性；后者称为数据类型属性。数据3 p  v3 {' B( |5 n* ?* d0 `4 t
类型属性的值域范围是RDF文字或者是XML Schema数据类型中定义的那些简单类型。
OWL使用XML Schema内嵌数据类型中的大部分。对这些数据类型的引用是通过对http://www.w3.org/2001/XMLSchema这个URI引用。; g  h2 x( T7 w
3>属性特性% f4 {' _8 e$ H, T
1>>TransitiveProperty 传递属性7 l, }( e$ L* O) F8 B$ V
如果一个属性P被声明为传递属性，那么对于任意的x,y和z： P(x,y)与P(y,z) 蕴含 P(x,z)0 G, o$ w) Z$ t4 P! W/ c9 |
2>>SymmetricProperty 对称属性! P; F2 Y. Z( F4 z& `; n* z, o' S
如果一个属性P被声明为对称属性，那么对于任意的x和y： P(x,y)当且仅当P(y,x)) `" c* l- n% G& S+ J
示例：
<owl:ObjectProperty rdf:ID="adjacentRegion">
<rdf:type rdf:resource="&owl;SymmetricProperty" />6 t: ~) S7 `: r. B# Z+ Z
<rdfs:domain rdf:resource="#Region" />
<rdfs:range rdf:resource="#Region" />( w! o3 C- z8 U& |
</owl:ObjectProperty>: C' e' X! @' A! _' e
<Region rdf:ID="MendocinoRegion">4 x8 }/ q; E4 H% [4 Q7 W- h( H; M
<locatedIn rdf:resource="#CaliforniaRegion" />
<adjacentRegion rdf:resource="#SonomaRegion" />" Y* S5 |/ x+ A9 o/ I8 s- k
</Region>2 L# w' o! J% X+ a& l! j
3>>FunctionalProperty 函数型属性8 l7 H5 J+ `+ R' i  Z; c/ t
如果一个属性P被标记为函数型属性，那么对于所有的x, y, 和z:  P(x,y)与P(x,z) 蕴含 y = z
示例：
<owl:Class rdf:ID="VintageYear" /> * w0 Z1 |0 C! ~0 `- \
<owl:ObjectProperty rdf:ID="hasVintageYear">
<rdf:type rdf:resource="&owl;FunctionalProperty" />) g, z+ ~4 a  d4 g- \1 s
<rdfs:domain rdf:resource="#Vintage" />
<rdfs:range  rdf:resource="#VintageYear" />
</owl:ObjectProperty>+ e$ L; S3 ?  z! }: I7 B
一种葡萄酒有着一个特定的制造年份。也即，一个给定的 Vintage个体只能使用hasVintageYear属性与单独一个年份相关联。
4>>inverseOf 逆属性/ w  y$ h. d" ^" N# x3 }9 F
如果一个属性P1被标记为属性P2的逆, 那么对于所有的x 和 y:  P1(x,y) 当且仅当P2(y,x), O1 `, y+ d7 W  I+ i6 k, C
请注意owl:inverseOf的语法，它仅仅使用一个属性名作为参数。A 当且仅当B意思是 (A蕴含B)并且(B蕴含A).
示例：
<owl:ObjectProperty rdf:ID="hasMaker">( ]' G: y  @( o+ N, x/ L6 ?
<rdf:type rdf:resource="&owl;FunctionalProperty" />9 Y5 _4 j+ Z6 t* S( F3 I! t
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="producesWine">
<owl:inverseOf rdf:resource="#hasMaker" />
</owl:ObjectProperty># h( s9 H: ^, b4 u0 R2 I
各种葡萄酒都有制造商，这些制造商在Wine类的定义中被限制为酿酒厂（Winery）。而每个酿酒厂生产的酒均以该酿酒厂为制造商。) l( w$ y1 P8 t" b; n% G
5>>InverseFunctionalProperty－－反函数属性
如果一个属性P被标记为反函数型的，那么对于所有的x, y和z:  P(y,x)与P(z,x) 蕴含 y = z   S# {7 ~6 C2 ^: g( z! A% j8 G8 z8 V( Y& w
示例：
<owl:ObjectProperty rdf:ID="hasMaker" /> 6 W% b* y& B! G- c# P7 s
<owl:ObjectProperty rdf:ID="producesWine">( X- _! V: _2 X* D! ^2 ~, e
<rdf:type rdf:resource="&owl;InverseFunctionalProperty" />2 e! U0 P7 q* U
<owl:inverseOf rdf:resource="#hasMaker" />
</owl:ObjectProperty>
producesWine属性是反函数型属性。因为一个函数型属性的逆必定是反函数型的。反函数型属性的值域中的元素可以看成是在数据库( f$ ^/ W& W( z2 V# B  S
意上定义一个唯一的键值。owl:InverseFunctional意味着属性的值域中的元素为定义域中的每个元素提供了一个唯一的标识。
4>属性限制－－在一个明确的上下文owl:Restriction中限制属性的值域,owl:onProperty元素指出了受限制的属性。( r+ s! P# r6 G" O
1>>allValuesFrom, someValuesFrom
owl:allValuesFrom属性限制要求：对于每一个有指定属性实例的类实例，该属性的值必须是由owl:allValuesFrom从句指定的类的成
员。owl:someValuesFrom限制与之相似。这两种限制形式间的不同就是全称量词与存在量词间的不同。
示例：
<owl:Class rdf:ID="Wine">
<rdfs:subClassOf rdf:resource="&food;PotableLiquid" />
...
<rdfs:subClassOf>: t. S1 a5 Z6 M5 ^5 z
   <owl:Restriction>; T% u' \5 z9 Q" @
   <owl:onProperty rdf:resource="#hasMaker" />
   <owl:allValuesFrom rdf:resource="#Winery" />) {; B1 {# u  d8 |6 E' w7 y4 V
   </owl:Restriction>
</rdfs:subClassOf>

...$ l$ m( [6 O, p
</owl:Class>, c# F( M) c$ Y
Wine的制造商必须是Winery。allValuesFrom限制仅仅应用在Wine的hasMaker属性上。7 j3 ?+ V9 R8 `3 \
在上个例子中，如果我们用owl:someValuesFrom替换owl:allValuesFrom，那就意味着至少有一个Wine类实例的hasMaker属性是指向一
个Winery类的个体的。2 v7 Z3 J4 ]7 s1 d4 i
2>>基数限制－－使用owl:cardinality，这一约束允许对一个关系中的元素数目作出精确的限制。' B) l8 ]1 ~- J% z
示例：$ r, G1 P; I/ I# q
<owl:Class rdf:ID="Vintage">
<rdfs:subClassOf>
   <owl:Restriction>
   <owl:onProperty rdf:resource="#hasVintageYear"/> . W# J6 e, \# q0 G. r5 j3 [
   <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>: b; n: d. n" w6 }) L. D; n( o
   </owl:Restriction>, a$ g+ q: F7 q, Z' ]6 I* {" l& y
</rdfs:subClassOf>/ p" R5 F1 I4 Y, @0 z( X
</owl:Class>
我们标识hasVintageYear属性为一个函数型属性，也即意味着每个Vintage有至多一个VintageYear。而如果对Vintage类的( Q6 i! P- l. p) D- W7 T/ _
hasVintageYear属性使用基数限制则是对其作出了更强的断言，它表明了每个Vintage有恰好一个VintageYear。+ A  \! S4 m# _* V% g9 O
值域限制在0和1的基数表达式(Cardinality expressions)是OWL Lite的一部分。这使得用户能够表示“至少一个”，“不超过一个”
，和“恰好一个”这几种意思。OWL DL中还允许使用除0与1以外的正整数值。owl:maxCardinality能够用来指定一个上界。, a4 H; b0 A3 h
owl:minCardinality能够用来指定一个下界。使用二者的组合就能够将一个属性的基数限制为一个数值区间。
3>>hasValue [OWL DL]
hasValue 使得我们能够根据“特定的”属性值的存在来标识类。因此，一个个体只要至少有“一个”属性值等于hasValue的资源，这
一个体就是该类的成员。
示例：: C/ Y# F1 i- |' {
<owl:Class rdf:ID="Burgundy">
...
<rdfs:subClassOf>" \, U3 _  ]! R. g/ w# ], s: C
   <owl:Restriction>9 @) E: E) e" L7 q  g
   <owl:onProperty rdf:resource="#hasSugar" />
   <owl:hasValue rdf:resource="#Dry" />- w+ m5 Y/ ~1 Z: W
   </owl:Restriction>" w; T0 _: {  u6 O" b
</rdfs:subClassOf>
</owl:Class>
这里我们声明了所有的Burgundy酒都是干(dry)的酒。也即，它们的hasSugar属性必须至少有一个是值等于Dry（干的）。9 n% U6 l2 @8 b" n9 f4 }& `
与allValuesFrom 和someValuesFrom类似，这是一个局部的限制。它仅仅对Burgundy类的hasSugar属性作出限制。

5.本体映射
为了让本体发挥最大的作用，就需要让本体得到充分的共享。为了使得在开发本体时尽可能的节省人力，就需要使得开发出的本体能; @/ J; y# J) P) @% \' x2 t4 m, Y
够被重用。更理想的情况是他们能够被组合使用。在开发一个本体的过程中，很多的精力都被投入到将类与属性联系起来以获取最大: E& x) p, I& v( ]1 T$ U  i8 F6 U& w; T
的意义的工作上去了,意识到这一点也是很重要的。我们希望对类成员作出的断言较为简单同时又要求有广泛的和有用的含意在里面。& m4 i/ M- Q1 s: i
这也是在本体开发过程中最为困难的工作。如果你能够找到已经经过广泛使用和精炼的本体，那么采用它才有意义。# L4 \, f4 G$ T/ L1 P' m
1>类和属性之间的等价关系－－equivalentClass, equivalentProperty; [, p) x4 G. @$ }
在食物本体中，我们现在想把在餐宴菜肴中对葡萄酒特点的描述与葡萄酒本体相联系起来。达到这一目的一种方法就是在食物本体中; r$ S  [. d8 \' F3 [+ U
定义一个类(&food;Wine)，然后在葡萄酒本体中将一个已有的类声明为与这个类是等价的。' H; \0 k+ Y( d8 ~" Z
<owl:Class rdf:ID="Wine">
<owl:equivalentClass rdf:resource="&vin;Wine"/>
</owl:Class>
属性owl:equivalentClass被用来表示两个类有着完全相同的实例。但我们要注意，在OWL DL中，类仅仅代表着个体的集合而不是个体2 q6 i) o6 h4 N
本身。然而在OWL FULL中，我们能够使用owl:sameAs来表示两个类在各方面均完全一致。类似的，owl:equivalentProperty属性声明
表达属性的等同。
示例：
<owl:Class rdf:ID="TexasThings">
<owl:equivalentClass>
   <owl:Restriction>
   <owl:onProperty rdf:resource="#locatedIn" />$ J* m$ N* m& z7 k8 T% Z2 \
   <owl:someValuesFrom rdf:resource="#TexasRegion" />5 ]% _  C5 _; \" j$ o7 i' }
   </owl:Restriction>7 ^" @7 b2 }: i9 u3 ^, h* {" G5 \
</owl:equivalentClass>
</owl:Class>. f2 r/ t; i6 J; L/ H: I
TexasThings指的是那些恰好位于Texas地区的事物。使用owl:equivalentClass 和使用rdfs:subClassOf 的不同就像必要条件和充要
条件的不同一样。如果是使用subClassOf的话，位于Texas地区的事物不一定是TexasThings。但是，如果使用owl:equivalentClass，" Q3 F, D6 b4 ?, d3 A! C
位于Texas地区的事物一定属于TexasThings类。
2>个体间的同一性z－－sameAs
描述个体之间相同的机制与描述类之间的相同的机制类似，仅仅只要将两个个体声明成一致的就可以了。; E2 F2 {3 a( i% r- p- H
示例：
<Wine rdf:ID="MikesFavoriteWine>
   <owl:sameAs rdf:resource="#StGenevieveTexasWhite" />
</Wine>
要清楚，修饰（或引用）两个类用sameAs还是用equivalentClass效果是不同的。用sameAs的时候，把一个类解释为一个个体，就像在
OWL Full中一样，这有利于对本体进行分类。
3>不同的个体－－differentFrom, AllDifferent
这一机制提供了与sameAs相反的效果。
<WineSugar rdf:ID="Dry" />
# R, i1 l! P& S, ~
<WineSugar rdf:ID="Sweet">
<owl:differentFrom rdf:resource="#Dry"/>
</WineSugar> 1 s) |) V6 x' H/ G) N0 h" p
' G2 n- s: r8 Q$ }! W! S
<WineSugar rdf:ID="OffDry">  o: I5 w6 L/ n: o9 D  ?7 `! r
<owl:differentFrom rdf:resource="#Dry"/>
<owl:differentFrom rdf:resource="#Sweet"/> " h( G0 H. u, B: d- V+ A/ h
</WineSugar>) {1 A* E8 I0 \' d2 D& L4 p
这是一种声明这三个值相互不同的方法。但在有些时候，更重要的是利用这些定义元素能把这种不同区别开来。
还有一种更便利的定义相互不同个体的机制。如下面申明红葡萄酒、白葡萄酒和玫瑰葡萄酒的例子。2 f( R& [1 ]  J& @" L' q* \
<owl:AllDifferent>9 c& t% e' k9 J% N9 w
<owl:distinctMembers rdf:parseType="Collection">
   <vin:WineColor rdf:about="#Red" />
   <vin:WineColor rdf:about="#White" />0 V2 K: b# T+ E5 @; [
   <vin:WineColor rdf:about="#Rose" />
</owl:distinctMembers>7 N# h" Q% E. k0 F
</owl:AllDifferent>7 y  w% ]1 V7 c4 n; e
注意，owl:distinctMembers属性声明只能和owl:AllDifferent属性声明一起结合使用。7 J. Z+ [$ L3 h7 e. E. h# h# \
! \' W2 c+ J' F7 O2 e- {, \
6. 复杂类6 r9 r( `1 |$ x9 S* H9 Y& t2 R
1>集合运算符 intersectionOf,unionOf,complementOf
记住:OWL类外延是由个体组成的集合，而这些个体都是类的成员。OWL使用基本的集合操作算子来处理类的外延。
1>>交运算intersectionOf
<owl:Class rdf:ID="WhiteWine">
<owl:intersectionOf rdf:parseType="Collection">5 {! T* q/ E: D. p% {7 M$ d+ y
   <owl:Class rdf:about="#Wine" />0 o' ]2 m5 g4 g" F0 g
   <owl:Restriction>* x* _" K2 W( }1 w* u
   <owl:onProperty rdf:resource="#hasColor" />
   <owl:hasValue rdf:resource="#White" />/ l! Q8 u+ _. Z0 r4 I5 _1 ]
   </owl:Restriction>
</owl:intersectionOf>
</owl:Class>% \- S2 I9 c- `8 F% e- [
上面的语句说明WhiteWine恰好是类Wine与所有颜色是白色的事物的集合的交集。$ \1 o! W3 R1 u9 _
(请注意：'rdf:parseType= "Collection"'是必需的语法元素。)& e* f3 U' m. f5 v. `8 F
<owl:Class rdf:about="#Burgundy">4 T3 f8 i7 L2 t: _
<owl:intersectionOf rdf:parseType="Collection">
   <owl:Class rdf:about="#Wine" />
   <owl:Restriction>
   <owl:onProperty rdf:resource="#locatedIn" />' C. K0 P( @4 n( P; @. U8 Q2 t% G6 E
   <owl:hasValue rdf:resource="#BourgogneRegion" />
   </owl:Restriction>
</owl:intersectionOf>/ G# v7 u, w; h1 @: Y# w$ f# v
</owl:Class>5 N' u, j2 ?1 i1 ?6 A
<owl:Class rdf:ID="WhiteBurgundy">
<owl:intersectionOf rdf:parseType="Collection">' g% L$ L; K7 r- [1 m; P
   <owl:Class rdf:about="#Burgundy" />
   <owl:Class rdf:about="#WhiteWine" />
</owl:intersectionOf>
</owl:Class>
2>>并运算unionOf
<owl:Class rdf:ID="Fruit">+ v( g4 {4 T# x) K
<owl:unionOf rdf:parseType="Collection">
   <owl:Class rdf:about="#SweetFruit" />8 v0 E& Y8 C/ Q1 u! e: q& G
   <owl:Class rdf:about="#NonSweetFruit" />/ F; S' A/ {6 L+ y  d
</owl:unionOf>
</owl:Class>
3>>补运算complementOf
complementOf结构从某个论域(domain of discourse)选出不属于某个类的所有个体。通常它将指向一个非常大的个体集合：% X" L7 L, U2 \  w. |, `- Q+ ^
<owl:Class rdf:ID="NonFrenchWine">) R8 i  _' [- M3 v9 K
<owl:intersectionOf rdf:parseType="Collection">- [9 i/ F5 [) l
   <owl:Class rdf:about="#Wine"/>$ y' v9 z0 h9 j2 Q5 U
   " r2 n% B. l/ T# V( U5 O& Z
   <owl:Class>
   <owl:complementOf>2 \+ k# E+ b& G  Q
      <owl:Restriction>. Z& Y1 z8 K! b) p  L8 I8 ]: o- K
         <owl:onProperty rdf:resource="#locatedIn" />0 G/ S) k& e+ b8 A0 t/ R& y
         <owl:hasValue rdf:resource="#FrenchRegion" />" M; k( W% y, C+ A# S
      </owl:Restriction>' y( V+ {' w7 f5 f3 l1 x
   </owl:complementOf>
   </owl:Class>. ~3 V) C2 F* e
</owl:intersectionOf>7 q( [  J/ s: A% N& M, H# w, l9 C
</owl:Class>
2>枚举类 oneOf 7 r6 c' t1 {$ H; ~' ?4 h
OWL提供了一种通过直接枚举类的成员的方法来描述类。这是通过使用oneOf结构来完成。特别地，这个定义完整地描述了类的外延，2 b( [. p, \! o& }' D: Z5 S/ x3 W
因此任何其他个体都不能被声明为属于这个类。oneOf结构的每一个元素都必须是一个有效声明的个体。一个个体必须属于某个类。5 l  z; L5 D5 w6 r1 V+ t1 p& y
<owl:Class rdf:ID="WineColor">- E8 |% h; N  n& N% v
<rdfs:subClassOf rdf:resource="#WineDescriptor"/>0 i$ K  X, w+ w4 t0 ?
<owl:oneOf rdf:parseType="Collection">
   <owl:Thing rdf:about="#White"/>
   <owl:Thing rdf:about="#Rose"/>
   <owl:Thing rdf:about="#Red"/>, ]0 C; N4 c. l% e2 s5 F
</owl:oneOf>
</owl:Class>
3>不相交类 disjointWith3 k, f9 R; o% K% x
使用owl:disjointWith构造子可以表达一组类是不相交的。它保证了属于某一个类的个体不能同时又是另一个指定类的实例。7 s2 {: o+ H/ B" g
<owl:Class rdf:ID="Pasta">
<rdfs:subClassOf rdf:resource="#EdibleThing"/>. W' q1 i. V6 T) u. c
<owl:disjointWith rdf:resource="#Meat"/>& H8 p2 C6 Y; v( \
<owl:disjointWith rdf:resource="#Fowl"/>4 N1 e: `: P/ Z+ p
<owl:disjointWith rdf:resource="#Seafood"/>
<owl:disjointWith rdf:resource="#Dessert"/>+ s) g/ C5 z" }6 V; `) }5 J
<owl:disjointWith rdf:resource="#Fruit"/>
</owl:Class>
注意它只声明了Pasta与其它所有类是不相交的。例如，它并没有保证Meat和Fruit是不相交的。为了声明一组类是互不相交的，我们1 |* Z3 `# I7 d/ J* w
必须对每两个类都使用owl:disjointWith来声明。
当n很大时，我们可以使用另一些方法以避免声明的数目按二次方增长。工作原理如下：我们描述一个父类，它的元素有一个基数等于) Y9 X4 }2 v5 e- s' S
一的属性。接着，对于这个父类的每一个子类，我们都要求这个子类的实例的这一属性必须具有一个唯一的值。在这种情况下，各个. }0 V6 g' p1 @9 V
不同子类就不可能有共同的成员了。9 z0 _% T" T; a/ R8 s/ S
7.本体的版本控制
本体和软件一样需要维护，因此它们将随着时间的推移而改变。在一个owl:Ontology元素内，链接到一个以前定义的本体版本是可能
的。属性owl:priorVersion被用来提供这种链接，并能用它跟踪一个本体的版本历史。' x! {6 Z1 g, [/ ?
<owl:Ontology rdf:about="">
...
<owl:priorVersion rdf:resource="http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine"/> " v4 y# N$ X$ ?4 [3 M8 [
...' }7 S/ T1 k  p& m8 U% X/ l$ q
</owl:Ontology>: y5 b7 ~  c' A' r, c: G
本体版本可能彼此互不兼容，例如，一个本体以前的版本可能包含与现在版本中的陈述相矛盾的陈述。在一个owl:Ontology元素中，4 e' T5 X7 U8 b* p" s
我们使用owl:backwardCompatibleWith和owl:incompatibleWith这些属性来指出本体版本是兼容还是不兼容以前的版本。如果没有进
行owl:backwardCompatibleWith声明，那么我们假定就不存在兼容性。除了上面讲到的两个属性，还有一个属性 owl:versionInfo适
用与版本控制系统，它提供了一些相关信息（hook）。和前面三个属性相反的是，owl:versionInfo的客体是一个文字值（literal）; d- A3 b$ ~" @5 \% x2 ]& w
，这一属性除了可以用来注释本体之外还可以用来注释类和属性。6 B2 _+ I3 J/ j  u. L1 {' i/ `
OWL Full提供的表示能力能够对一个类进行任何类型的声明，也即可以声明一个类可以是另一个类的实例，或者一个类（不是它的实
例）有一个属性和一个对应的属性值。这一框架就能被用来为版本跟踪信息建立一个由类和属性构成的本体。OWL的名称间中包括了两: n! A& r  b( }, k* M9 m
个预定义的类owl:DeprecatedClass和 owl:DeprecatedProperty来完成这个目的。他们被用来指明某个类或属性在未来发布的版本中
可能以一种不兼容的方式发生变化。

搜索更多相关主题的帖子: ontology OWL

TOP

shadow