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 is subClass of myProperty exactly 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添加的开放世界

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

以下规则来自jena-core的{{1}}文件来描述基数。它们不是完整的基数规则。

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是Functors）。 max是特定规则（对于N＆gt; 1），它显示了如何识别违规行为。它委托CountLiteralValues内置函数来识别属性存在的绑定数。

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

CountQualifiedValues

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

这实际上与解决方案2没有什么不同。但是，您将尝试为OWL构造定义替代语义，这是一个非常重要的问题。您可以引入一些用于验证的规则（读取[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) ] ]以获取示例）来捕获您特定的封闭世界假设。如果您强制将其限制为仅在etc/owl-fb.rules时运行，那么您可以确保在执行验证时只假设一个封闭世界。

旁边讨论

以下是owl 1中表示的基数限制的示例。它与上面输入文件中的基数限制相同。这用(?v rb:validation on())语法表示，并且很容易转换为TURTLE或任何其他有效的RDF/XML序列化。

RDF

这对限制在语义上并不完全等同于:ExampleClass rdfs:subClassOf :SuperClass ; rdfs:subClassOf [ a owl:Restriction ; owl:onProperty :myProperty ; owl:cardinality 1 ] .，但是，如果您能够修改域模型，则可以经常解决它。

例如，owl:qualifiedCardinality非常适合说owl:qualifiedCardinality之类的内容。例如，OWL 1解决方法可能是创建:People :haveBodyPart exactly 2 :Eyes然后说:haveEye rdfs:subPropertyOf :haveBodyPart（没有限定基数限制）

Answer 2

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

人⊑⊑hasParent.Person

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

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

对于这种特殊情况，您可以找到（某些）（myProperty恰好1个其他类）（以及一般的合格基数）的实例：

?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不匹配的人？基数：

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 )

我还没有测试任何这个，所以可能存在拼写错误，而且你还没有提供完整的数据，所以我也无法对它进行测试，但是这条概述中的某些内容应该是可行的。

耶拿在本体论上的验证规则

2 个答案: