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

Question

我需要在Protégé中实现一个OWL-ontology，它包含两个类:s1和s2，都是System的实例> 类。这两个类是通过连接类s1_s2 连接起来的，其中包含属性omega。该属性必须根据以下规律取值:

omega = 1 * s1.complete

如何在 Protégé 中实现它，这样我以后可以在 SWRL-rule 中使用它？

Answer 1

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

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

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

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

S1(?s1) ∧ InterSystem(?i) ∧ hasS1(?i,?s1) ∧ hasComplete(?s1,?complete) multiply(?omega,1,?complete) → hasOmega(?i,?omega)

这里的乘法实际上似乎是多余的，因为你要乘以 1，所以 omega = alpha，在这种情况下，该规则的头部可能只是 hasOmega(?i,?alpha)。在 Protégé 中，规则如下所示:

(在我使用的 Protégé 版本(不是最新版本)中，我必须使用 Window > Create New Tab 来创建 Rules 选项卡，然后 Window > Views > Ontology Views >将规则列表添加到界面的规则。)

这个 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，然后选择 Reasoner > Start Reasoner。此时，您可以对“hasOmega value 42”运行 DL 查询，以确认个人具有所需的属性(确保选中右侧的“个人”复选框):

如果您导航到 intersystem 个体，您可能不会看到推断的值。要显示它，请转到 Reasoner > Configure... 并检查 Data Property Assertions 选项:

之后，您可能需要重新启动推理器(Reasoner > None；Reasoner > Pellet；Reasoner > Start Reasoner)，但之后您将能够看到推断的值: