Protégé-OWL / SWRL中的本体属性定义

Question

我需要在Protégé中实现一个OWL本体，它包含两个类：s1和s2，它们都是System类的实例。这两个类由连接类s1_s2连接，其中包含属性omega。该物业必须根据以下法律取值：

  

omega = 1 * s1.complete

我如何在Protégé中实现它，这样我将来可以在SWRL规则中使用它？

Answer 1

通常，您首先要定义所需的类和属性：

此时，您可以添加一些公理来管理系统如何进行交互，属性如何工作等等。例如，您可以在属性上声明域和范围。这是 hasS2 属性中的域和范围：

您可能还想说每个 InterSystem 只有一个关联 S1 和 S2 ：

为了加入数学约束，你实际上需要SWRL;你将无法使用其他类型的OWL公理来强制执行约束。您想要的规则如下。如果在谓词上声明域和范围，则不需要出现在此规则中的所有类型谓词，因为它们可以从属性用法中推断出来。

  

S1（？s1）∧InterSystem（？i）∧具有S1（？i，？s1）∧   hasComplete（？s1，？complete）乘（？omega，1，？完成）→   hasOmega（？我，？欧米加）

这里的乘法实际上似乎是多余的，因为你乘以1，所以omega = alpha，在这种情况下，该规则的头部可能只是 hasOmega（？i，？alpha）。在Protégé，规则看起来像这样：

（在我使用的Protégé版本中（不是最新版本），我必须使用Window＆gt;创建新标签来创建规则标签，然后选择Window＆gt; Views＆gt;本体视图＆gt;将规则列表添加到界面的规则。）

这个OWL本体的RDF表示的Turtle序列化（你可以保存并加载到Protégé中）是：

@prefix :      <http://stackoverflow.com/q/21499126/1281433/systems#> .
@prefix rdfs:  <http://www.w3.org/2000/01/rdf-schema#> .
@prefix swrl:  <http://www.w3.org/2003/11/swrl#> .
@prefix owl:   <http://www.w3.org/2002/07/owl#> .
@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .
@prefix swrlb: <http://www.w3.org/2003/11/swrlb#> .
@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

<urn:swrl#s1>  a  swrl:Variable .

:hasComplete  a  owl:DatatypeProperty .

[ a          swrl:Imp ;
  swrl:body  [ a          swrl:AtomList ;
               rdf:first  [ a                    swrl:ClassAtom ;
                            swrl:argument1       <urn:swrl#i> ;
                            swrl:classPredicate  :InterSystem
                          ] ;
               rdf:rest   [ a          swrl:AtomList ;
                            rdf:first  [ a                    swrl:ClassAtom ;
                                         swrl:argument1       <urn:swrl#s1> ;
                                         swrl:classPredicate  :S1
                                       ] ;
                            rdf:rest   [ a          swrl:AtomList ;
                                         rdf:first  [ a                       swrl:IndividualPropertyAtom ;
                                                      swrl:argument1          <urn:swrl#i> ;
                                                      swrl:argument2          <urn:swrl#s1> ;
                                                      swrl:propertyPredicate  :hasS1
                                                    ] ;
                                         rdf:rest   [ a          swrl:AtomList ;
                                                      rdf:first  [ a                       swrl:DatavaluedPropertyAtom ;
                                                                   swrl:argument1          <urn:swrl#s1> ;
                                                                   swrl:argument2          <urn:swrl#complete> ;
                                                                   swrl:propertyPredicate  :hasComplete
                                                                 ] ;
                                                      rdf:rest   [ a          swrl:AtomList ;
                                                                   rdf:first  [ a               swrl:BuiltinAtom ;
                                                                                swrl:arguments  [ a          rdf:List ;
                                                                                                  rdf:first  <urn:swrl#omega> ;
                                                                                                  rdf:rest   [ a          rdf:List ;
                                                                                                               rdf:first  1 ;
                                                                                                               rdf:rest   ( <urn:swrl#complete> )
                                                                                                             ]
                                                                                                ] ;
                                                                                swrl:builtin    swrlb:multiply
                                                                              ] ;
                                                                   rdf:rest   ()

                                                                 ]
                                                    ]
                                       ]
                          ]
             ] ;
  swrl:head  [ a          swrl:AtomList ;
               rdf:first  [ a                       swrl:DatavaluedPropertyAtom ;
                            swrl:argument1          <urn:swrl#i> ;
                            swrl:argument2          <urn:swrl#omega> ;
                            swrl:propertyPredicate  :hasOmega
                          ] ;
               rdf:rest   ()

             ]
] .

:S2     a                owl:Class ;
        rdfs:subClassOf  :System .

<urn:swrl#omega>  a  swrl:Variable .

:S1     a                owl:Class ;
        rdfs:subClassOf  :System .

:InterSystem  a          owl:Class ;
        rdfs:subClassOf  [ a                         owl:Restriction ;
                           owl:onClass               :S1 ;
                           owl:onProperty            :hasS1 ;
                           owl:qualifiedCardinality  "1"^^xsd:nonNegativeInteger
                         ] ;
        rdfs:subClassOf  [ a                         owl:Restriction ;
                           owl:onClass               :S2 ;
                           owl:onProperty            :hasS2 ;
                           owl:qualifiedCardinality  "1"^^xsd:nonNegativeInteger
                         ] .

<urn:swrl#complete>  a  swrl:Variable .

<http://stackoverflow.com/q/21499126/1281433/systems>
        a       owl:Ontology .

:hasS2  a       owl:ObjectProperty .

:hasOmega  a    owl:DatatypeProperty .

:System  a      owl:Class .

:hasS1  a       owl:ObjectProperty .

<urn:swrl#i>  a  swrl:Variable .

这是一个良好的开端，但值得看看它是如何运作的。要查看可以应用规则的位置，我们需要一些实例数据和推理器。你提到你可以在Protégé中使用Pellet，所以我们都计算在内。对于某些实例数据，让我们创建 InterSystem ，其 S1 ，并分配 S1 的完整值。

您需要从Reasoner菜单中选择Pellet推理器，然后选择Reasoner＆gt;启动推理器。此时，您可以运行“hasOmega 值 42”的DL查询以确认该个人具有所需的属性（确保您选中右侧的“个人”复选框）：

如果您导航到 intersystem 个人，您可能不会看到推断值。要显示它，请转到Reasoner＆gt;配置...并检查Data Property Assertions选项：

之后，您可能需要重新启动推理器（推理器＆gt;无;推理器＆gt; Pellet;推理器＆gt;启动推理器），但之后您将能够看到推断值：