rdf - 本体验证的耶拿规则

Question

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

我要做的最验证看起来像这样:我有这样的课:

   <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 是 myProperty 的子类，正好是 1 个 OtherClass。

所以我想验证是否有一个 myProperty 具有值:OtherClass 类型的个体。

是否可以验证这样的规则？如果有一个规则来为所有使用这种建模的类(可能还有至少 1 个、正好 2 个......)执行此操作，那就完美了。

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

Answer 1

您的示例不依赖于对封闭世界原则的利用。这取决于对 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 的开放世界

这并不容易。看看 jena-core 中的 etc/owl-fb.rules 你会注意到一些通用 owl 结构的支持(尤其是基数)需要 development of 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)  ] ]

restriction5 仅根据最小和最大基数定义基数(本示例中的 min 和 max 是 Functor)。 validationMaxN 是显示如何识别违规的特定规则(对于 N > 1)。它委托(delegate)给 CountLiteralValues 内置函数来识别该属性存在的绑定(bind)数量。

如果您愿意引入一个 CountQualifiedValues 内置，那么您可以定义一组类似于以下的规则来引入新的公理:

[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 构造定义 alternative 语义，这是一个不平凡的问题。您可以引入一些验证规则(阅读 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 2 :Eyes 之类的内容。例如，OWL 1 的解决方法可以是创建一个 :haveEye rdfs:subPropertyOf :haveBodyPart 然后说 :People :haveEye 正好 2(没有 qualified 基数限制)