3

我想验证一个本体，如果有任何不正确的地方就抛出一个错误。

我要做的最验证看起来像这样：我有一个这样的类：

   <owl:Class rdf:about="&schema;ExampleClass">
        <rdfs:subClassOf rdf:resource="&schema;SuperClass"/>
        <rdfs:subClassOf>
            <owl:Restriction>
                <owl:onProperty rdf:resource="&schema;myProperty"/>
                <owl:onClass rdf:resource="&schema;OtherClass"/>
                <owl:qualifiedCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:qualifiedCardinality>
            </owl:Restriction>
        </rdfs:subClassOf>
    </owl:Class>

（有趣的部分是第二个 subClassOf。）在 Protege 中，这意味着ExampleClass is subClass of myProperty exactly 1 OtherClass.

因此，我想验证是否存在一个具有值的 myProperty：OtherClass 类型的个体。

是否可以验证这样的规则？完美的情况是，如果有一个规则可以为所有具有这种建模的类执行此操作（也许还有至少 1 个，正好 2 个，......）

另一个问题是：是否有一个现成的封闭世界推理器正在为我做这件事？

4

2 回答 2

6

您的示例不依赖于封闭世界原则的利用。这取决于对owl:qualifiedCardinality.

例如，让我们采用以下示例输入文件：

@prefix xsd:  <http://www.w3.org/2001/XMLSchema#>.
@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
@prefix owl:  <http://www.w3.org/2002/07/owl#>.
@prefix : <urn:x-so:ex#>.

:OtherClass a owl:Class .
:SuperClass a owl:Class .

:myProperty a rdf:Property
          ; rdfs:range  :OtherClass
          .

:ExampleClass rdfs:subClassOf :SuperClass
            ; rdfs:subClassOf [ a owl:Restriction
                              ; owl:onProperty :myProperty
                              ; owl:cardinality 1
#                             ; owl:onClass :OtherClass
#                             ; owl:qualifiedCardinality 1
                              ]
            .


:o0 a :OtherClass .
:o1 a :OtherClass .

:s0 rdf:type    :ExampleClass
  ; :myProperty :o0
  ; :myProperty :o1
  .

注意注释掉的行和它们上面引入的公理。这个本体是 owl-1 兼容的，所以有它的验证规则。在下面的测试中没有验证错误，为什么？因为我们可以推断，例如，:o0 owl:sameAs :o1这不会导致矛盾。

final Model baseModel = ModelFactory.createDefaultModel();
try( final InputStream in = this.getClass().getResourceAsStream("/so.ttl") ){
    baseModel.read(in, null, "TTL");
}
final OntModel model  = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM_RULE_INF, baseModel);

assertTrue(model.contains(s0, myProperty, o0));
assertTrue(model.contains(s0, myProperty, o1));

final ValidityReport report = model.validate();
assertTrue( report.isValid() );

然而，在下一个例子中，我们证明如果我们引入:o0 owl:differentFrom :o1，那么我们会得出一个矛盾：

final Model baseModel = ModelFactory.createDefaultModel();
try( final InputStream in = this.getClass().getResourceAsStream("/so.ttl") ){
    baseModel.read(in, null, "TTL");
}
final OntModel model  = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM_RULE_INF, baseModel);
model.add(o1, OWL.differentFrom, o0); // NOTE!!
assertTrue(model.contains(s0, myProperty, o0));
assertTrue(model.contains(s0, myProperty, o1));

final ValidityReport report = model.validate();
assertFalse( report.isValid() );

鉴于演示的场景，我会提出以下解决方案（按难度递增的顺序）：

解决方案 1：具有 OWL 1 约束的开放世界

如果可能的话，用 owl-1 约束来表达你的本体，然后你可以利用现有的规则集进行验证。

解决方案 2：添加 OWL 2 的开放世界

这并不容易。看一下etc/owl-fb.rules，jena-core您会注意到对一些通用 owl 构造（最值得注意的是基数）的支持需要Jena Builtin 的开发来简化规则表达式。如果那是你打算去的方向，我链接到另一个关于内置的答案。

以下规则来自jena-core的etc/owl-fb.rules文件来描述基数。它们不是完整的基数规则集。

[restriction5: (?C owl:onProperty ?P), (?C owl:cardinality ?X)
  -> (?C owl:equivalentClass card(?P, ?X)),
     (?C rdfs:subClassOf min(?P, ?X)),
     (?C rdfs:subClassOf max(?P, ?X)) ]

[restriction4: (?C owl:onProperty ?P), (?C owl:maxCardinality ?X)
  -> (?C owl:equivalentClass max(?P, ?X)) ]

[validationMaxN: (?v rb:validation on()), (?C rdfs:subClassOf max(?P, ?N)) greaterThan(?N, 1) (?P rdf:type owl:DatatypeProperty) ->
    [max2b: (?X rb:violation error('too many values', 'Too many values on max-N property (prop, class)', ?P, ?C))
          <- (?X rdf:type ?C), countLiteralValues(?X, ?P, ?M), lessThan(?N, ?M)  ] ]

restriction5min简单地根据最小和最大基数定义基数（max在这个例子中是函子）。validationMaxN是显示如何识别违规的特定规则（对于 N > 1）。它委托给CountLiteralValues内置函数来识别该属性存在的绑定数量。

如果您愿意引入CountQualifiedValuesBuiltin，那么您可以定义一组类似于以下的规则来引入新的公理：

[restriction4: (?C owl:onProperty ?P), (?C owl:maxQualifiedCardinality ?X), (?C owl:onClass ?Y)
  -> (?C owl:equivalentClass max(?P, ?X, ?Y)) ]

[validationMaxN: (?v rb:validation on()), (?C rdfs:subClassOf max(?P, ?N, ?Y)) greaterThan(?N, 1) (?P rdf:type owl:ObjectProperty) ->
    [max2b: (?X rb:violation error('too many values', 'Too many values on max-QN property (prop, class, qclass)', ?P, ?C, ?Y))
          <- (?X rdf:type ?C), countQualifiedValues(?X, ?P, ?Y, ?M), lessThan(?N, ?M)  ] ]

解决方案 3：添加 OWL 2 的封闭世界

这实际上与解决方案 2 并没有什么不同。但是，您将尝试为 OWL 构造定义替代语义，这是一个不平凡的问题。您可以引入一些验证规则（阅读etc/owl-fb.rules以获取示例）来捕获您特定的封闭世界假设。如果您强制将它们限制为仅在 时操作(?v rb:validation on())，那么您可以确保在执行验证时仅假设一个封闭世界。

边讨论

这是一个以 owl 1 表示的基数限制的示例。它与上面输入文件中的相同。这以TURTLE语法表示，并且对于转换为RDF/XML或任何其他有效的RDF序列化是微不足道的。

:ExampleClass rdfs:subClassOf :SuperClass
            ; rdfs:subClassOf [ a owl:Restriction
                              ; owl:onProperty :myProperty
                              ; owl:cardinality 1
                              ]
            .

这对限制在语义上并不完全等同于owl:qualifiedCardinality，但是，如果您有能力修改您的领域模型，您通常可以绕过它。

例如，说 .owl:qualifiedCardinality之类的话很棒:People :haveBodyPart exactly 2 :Eyes。例如，OWL 1 解决方法可以是创建一个:haveEye rdfs:subPropertyOf :haveBodyPart然后说:People :haveEye exactly 2（没有合格的基数限制）

于 2014-08-21T15:22:20.213 回答
4

听起来您正试图根据一些 OWL 公理检查一些完整性约束，但重要的是要注意 OWL 是基于开放世界假设的。这意味着即使您有：

人⊑∃hasParent.Person

这表示每个人（至少）都有一个 hasParent 属性的值和另一个 Person 个体的值，您仍然可以拥有一个完全不包含任何 hasParent 断言的一致本体！因此，您正在寻找的那种“验证”实际上更多是关于一个封闭的世界和完整的解释。

我可能不会使用基于规则的方法来解决这个问题，而是使用一些 SPARQL 查询来检查不满足我们期望他们满足的事情的个人。例如，在这种情况下，您可以编写一个通用规则来查找作为限制实例的个人，然后您可以检查是否可以在数据中找到与限制“匹配”的三元组。

对于这种特殊情况，您可以通过以下方式找到（ myProperty 恰好 1 OtherClass）（以及一般的合格基数）的（一些）实例：

?instance a [ owl:onProperty ?property ;
              owl:onClass ?class ;
              owl:qualifiedCardinality ?cardinality ] .

当然，如果某个人只能被推断为该类的一个实例，那么该模式将找不到它，但我们假设您正在使用一个封闭世界和完整的数据，所以应该这样工作。（“类似的东西”可能包括?instance a/rdfs:subClassOf* [ ... ]。）一旦你得到它，你可以编写一个检查数据是否“匹配”的子查询：

select ?instance ?property ?class (count(?value) as ?actualCardinality) where {
  ?instance ?property ?value .
  ?value a ?class
}
group by ?instance ?property ?class

然后你可以结合这些来识别 ?actualCardinality 不匹配 ?cardinality 的个人：

select ?instance
       ?property
       ?class
       ?cardinality
       (count(?value) as ?actualCardinality)
where {
  ?instance a [ owl:onProperty ?property ;
                owl:onClass ?class ;
                owl:qualifiedCardinality ?cardinality ] .

  ?instance ?property ?value .
  ?value a ?class
}
group by ?instance ?property ?class ?cardinality
having ( ?cardinality != ?actualCardinality )

我还没有测试过这些，所以可能有错别字，而且你还没有提供完整的数据，所以我也无法测试，但这条总线中的一些东西应该是可行的。

于 2014-08-21T13:09:46.073 回答