【问题标题】:SPARQL query to return matches on satisfied restrictionsSPARQL 查询返回满足限制的匹配
【发布时间】:2015-03-02 15:01:47
【问题描述】:

我正在尝试对一个定义了限制的类编写查询,这将确定是否满足限制,如果满足,则返回它。

一个示例类定义如下:

: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 中的任何一个,则返回 ThingB。

以下查询将执行第一部分,即仅当我同时拥有 ThingC 和 ThingD 时才返回 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 之一才能返回 ThingB 上的匹配项?

【问题讨论】:

  • 我对此很感兴趣。我可以让你的本体试一试吗?我没有的本体有这种情况,所以我的努力​​没有任何结果!
  • @Artemis 感谢您的回复,但我无法向您提供我们的本体。希望我上面给出的示例足够详细,以便您能够在自己的本体中复制问题。
  • 您是否要验证您的 abox wrt 到您的 tbox?
  • @Michael 我不得不承认我不完全理解你的问题,因为我对本体和 SPARQL 很陌生。从我刚刚简要阅读的有关 abox 和 tbox 术语的内容来看,我认为我所要求的可以像您所说的那样简洁地描述,但我不确定。用我更简单的术语来说,我已经对我的类定义了限制,我希望能够运行一个查询,该查询将返回其限制已被一组输入值满足的任何类。
  • Person 是一个类的例子,这些在你的 tbox 中。你可以说“所有人都必须只有一个年龄”——这就是你正在考虑的那种限制,是吗?如果有个人“迈克尔”(在您的 abox 中),您想知道他们是否有年龄,因此,限制是否“满足”。也就是说,检查您的 abox 是否对您的 tbox 有效。对吗?

标签: rdf sparql owl


【解决方案1】:

你可以做一些你正在谈论的事情,但重要的是要记住 OWL 是基于开放世界推理的。这意味着,如果您没有明确说出某件事,并且您无法推断它是真是假,那么 OWL 不会假设任何一种方式。这只是未知数。例如,如果您只说“约翰爱玛丽”,那么您还没有说“约翰爱苏”(显然),但您也没有说“约翰不爱苏”。

例如,您可能会这样说:“Man ⊑∀ owns.Hat”(“男人只拥有帽子。”)。现在,这不是一个定义,所以你不能说因为某物只有帽子,它是一个男人。你可以发现一些违规行为,如果你能找到自称是男人但拥有的东西不是帽子的东西。 (当然,找到绝对不是帽子的东西需要一些推理,因为在开放世界假设下,通常很难知道某物是什么不是,而不是知道它是什么 em>.)

说了这么多,你可以用你的本体和 SPARQL 做一些事情。让我们先重新创建一些数据:

@prefix :      <http://stackoverflow.com/q/28812904/1281433/> .
@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&sqsubseteq; ∀ isConfirmedBy.(C &sqcap; D)
β : B
isConfirmedBy(β,x)

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

x : (C &sqcap; D)

然后从中,您可以推断:

x : C
x : D

所以,基于:

我正在尝试对一个定义了限制的类编写查询 它,这将确定是否已满足限制 如果有,请退回。

听起来您要求的查询将返回 B 的 candidate 实例。这些将是 据我们所知不违反消极入会条件,满足积极入会条件。在这种情况下,您会寻找以下内容:

  1. 不被任何不属于 C 和 D 的事物所证实
  2. 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,因为仍有一些关于候选人的事情可能是真的我们还不知道。

【讨论】:

  • 感谢您的好评。我想我们使用本体的方式并不是真正的开放世界,因为就我们的目的而言,我们只需要知道“很有可能”我们的候选人就是我们所说的那样。举一个真实的例子,我们有一个候选人“怀孕”,并推断如果你是女性并且年龄在 12 到 54 岁之间,并且你也有,比如说,错过了一段时间或有晨吐,那么你很有可能怀孕了。显然有很多违规行为,但正如我所说,我们只需要知道它很可能,就可以采取行动。
  • 我没有机会全面调查您的答案,但它确实值得深思,并提供了解决问题的新方法,所以谢谢!
【解决方案2】:

我没有你的本体,但是我自己的一个虚构版本,我想出了以下策略。如果我理解正确,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 ThingCThingB subClassOf hasRestriciton some ThingD 等公理定义类时,是否应该成为您正在寻找的答案的一部分。在这种情况下,它不会出现。

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2018-10-14
    • 1970-01-01
    • 2014-03-23
    • 2013-08-10
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多