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

问题描述 投票:3回答:1

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

omega = 1 * s1.complete

我怎样才能在Protégé中实现它,这样我将来可以在SWRL规则中使用它?

owl ontology protege swrl
1个回答
8
投票

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

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

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

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

S1(?s1)∧ InterSystem(?i)∧ hasS1(?i,?s1)∧ hasComplete(?s1,?complete)乘(?omega,1,?complete)→ hasOmega(?我,?欧米加)

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

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

这个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,所以我们都计算在内。对于某些实例数据,让我们创建它的S1和InterSystem,并分配S1的完整值。

您需要从Reasoner菜单中选择Pellet推理器,然后选择Reasoner> Start Reasoner。此时,您可以运行“hasOmega值42”的DL查询以确认该个人具有所需的属性(确保您选中右侧的“个人”复选框):

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

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

© www.soinside.com 2019 - 2024. All rights reserved.