SPARQL 查询 return 匹配满足的限制

Question

我正在尝试对定义了限制的 class 编写查询，这将确定是否满足限制，如果满足，return。

一个例子class定义如下：

:ThingB  a            owl:Class ;
    rdfs:subClassOf   :ThingA ;
    rdfs:subClassOf   [ a                  owl:Restriction ;
                        owl:allValuesFrom  [ a                   owl:Class ;
                                             owl:intersectionOf  ( :ThingC :ThingD )
                                           ] ;
                        owl:onProperty     owl:isConfirmedBy
                      ] ;
    rdfs:subClassOf   [ a                   owl:Restriction ;
                        owl:onProperty      owl:isConfirmedBy ;
                        owl:someValuesFrom  [ a            owl:Class ;
                                              owl:unionOf  ( :ThingE :ThingF :ThingG :ThingH )
                                            ]
                      ] .

我希望能够编写一个查询，说明如果我同时拥有 ThingC 和 ThingD 以及 ThingE、ThingF、ThingG 或 ThingH 中的任何一个，那么 return ThingB。

只有当我同时拥有 ThingC 和 ThingD 时，以下查询才会执行第一部分，即 return ThingB：

SELECT 
*
WHERE
{
    ?thing rdfs:subClassOf ?restriction .
    ?restriction (owl:allValuesFrom | owl:someValuesFrom)/(owl:intersectionOf | owl:unionOf) ?list .

    FILTER NOT EXISTS { 
        ?list rdf:rest*/rdf:first ?things.
        FILTER( !(?things in (:ThingC, :ThingD )) )
    }
}

我如何包含限制的第二部分，即必须至少有一个 ThingE、ThingF、ThingG 或 ThingH 才能 return 匹配 ThingB？

Answer 1

您可以做一些您正在谈论的事情，但重要的是要记住 OWL 是基于开放世界的推理。这意味着如果你没有明确地说出某事，并且你没有办法推断它是对还是错，OWL 不会假设任何一种方式；它只是未知的。例如，如果你只说 "John loves Mary"，那么你还没有说 "John loves Sue"（显然），但你也没有说 "John does not love Sue."

例如，您可以这样说："Man ⊑ ∀ owns.Hat" ("Men own only hats.")。现在，这不是一个定义，所以你不能仅仅因为某物只有帽子就说它是一个男人。你可以发现一些违规行为，如果你能找到声称是男人但拥有的东西不是帽子。（当然，找到绝对不是帽子的东西需要一些推理，因为在开放世界的假设下，通常很难知道什么是不是比知道它是什么是.)

综上所述，您可以使用 ontology 和 SPARQL 做一些事情。让我们先重新创建一些数据：

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

:       a       owl:Ontology .
:A      a       owl:Class .
:C      a       owl:Class .
:D      a       owl:Class .
:E      a       owl:Class .
:F      a       owl:Class .
:G      a       owl:Class .
:H      a       owl:Class .

:isConfirmedBy  a  owl:ObjectProperty .

:B      a                owl:Class ;
        rdfs:subClassOf  :A ;
        rdfs:subClassOf  [ a                   owl:Restriction ;
                           owl:onProperty      :isConfirmedBy ;
                           owl:someValuesFrom  [ a                   owl:Class ;
                                                 owl:intersectionOf  ( :E :F :G :H )
                                               ]
                         ] ;
        rdfs:subClassOf  [ a                  owl:Restriction ;
                           owl:allValuesFrom  [ a                   owl:Class ;
                                                owl:intersectionOf  ( :C :D )
                                              ] ;
                           owl:onProperty     :isConfirmedBy
                         ] .

首先，让我们看看如何找到（可能的）违规行为。如果您发现自称是 Man 的东西得到非 C 和 D 的确认，或者未得到 E、F、G 或 H 的确认，您可能会发现违规行为。再次，我必须强调这很难，因为通常情况下你会说这样的话：

B ⊑ ∀ isConfirmedBy.(C ⊓ D)
β : B
isConfirmedBy(β,x)

这并不矛盾，即使您不知道 x 是 C 而 x 是 D。相反，您可以推断

x : (C ⊓ D)

然后从中你可以推断出：

x : C
x : D

因此，基于：

I am trying to write a query on a class with a restriction defined on it, that will determine whether the restriction has been satisfied and, if it has, return it.

听起来您要查询 return 候选 B 的实例。这些 到目前为止我们知道不违反会员的消极条件，满足会员的积极条件。在这种情况下，您会寻找以下内容：

没有被任何不是 C 和 D 的东西证实
被某些东西证实是 E、F、G 或 H。

你可以这样写：

select ?candidate where {
  #-- find candidates that are confirmed by
  #-- by something that's an E, F, G, or H.
  values ?type { :E :F :G :H }
  ?candidate :isConfirmedBy/rdf:type ?type

  #-- But remove any that are confirmed by 
  #-- by something that's is *not* both a C
  #-- and a D.
  filter exists {
    ?candidate :isConfirmedBy ?x
    filter not exists { ?x a :C, :D }
  }
}

请注意，这不能确保每个候选人实际上都是 B，因为仍然有一些事情可能我们还不知道的候选人。

Answer 2

我没有你的ontology，但是有了我自己的编造版本，我想出了以下策略。如果我理解正确的话，ThingC 和 ThingD 的存在是必不可少的，而且 ThingE、ThingF 或 ThingG 必须存在之一。所以基本上我认为你需要三个查询的交集。

SELECT distinct * 
Where {
{?thing rdfs:subClassOf ?restriction .
?restriction (owl:allValuesFrom | owl:someValuesFrom)/(owl:intersectionOf | owl:unionOf) ?list .
 FILTER EXISTS { 
    ?list rdf:rest*/rdf:first ?things.
    FILTER( (?things in (:ThingE, :ThingF,  :ThingG)) )
}}
{
?thing rdfs:subClassOf ?restriction .
?restriction (owl:allValuesFrom | owl:someValuesFrom)/(owl:intersectionOf | owl:unionOf) ?list .
FILTER  EXISTS { 
    ?list rdf:rest*/rdf:first ?things.
    FILTER( (?things in (:ThingD)) )
}}
{
?thing rdfs:subClassOf ?restriction .
?restriction (owl:allValuesFrom | owl:someValuesFrom)/(owl:intersectionOf | owl:unionOf) ?list .
FILTER  EXISTS { 
    ?list rdf:rest*/rdf:first ?things.
    FILTER( (?things in (:ThingC)) )
}}
}

我仍然不确定，当用 ThingB subClassOf hasRestriciton some ThingC 和 ThingB subClassOf hasRestriciton some ThingD 等公理定义类时，是否应该是您正在寻找的答案的一部分。在这种情况下，它不会出现。

SPARQL 查询 return 匹配满足的限制

SPARQL query to return matches on satisfied restrictions

rdf

owl

sparql