Question

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

示例类定义如下：

: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上的匹配？

Answer 1

你可以做一些你正在谈论的事情，但重要的是要记住OWL是基于开放的世界推理。这意味着如果你没有明确说出某些东西，并且你没有办法推断它是真还是假，那么OWL不会采取任何一种方式;它只是未知数。例如，如果你只说“约翰爱玛丽”，那么你没有说过“约翰爱苏”（显然），但你也没有说“约翰不喜欢苏”。

例如，你可能会说：“男人∀∀拥有。哈特”（“男人只拥有帽子。”）。现在，这不是一个定义，所以你不能只是说，因为某些东西只拥有帽子，它是一个男人。你可以找到一些违规行为，如果你能找到一些自称是男人的东西，但拥有不帽子的东西。（当然，找到一些绝对不是帽子的东西需要一些推理，因为在开放世界的假设下，通常很难知道什么是而不是而不是知道是什么。）

所有这一切，你可以使用你的本体和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
                         ] .

首先，让我们看看如何找到（可能的）违规行为。如果你发现了一些声称是男人的东西，你可能会发现违规，这些东西是由不是C和D的东西证实的，或者是没有被E，F，G或H确认的。再次，我必须强调这是非常困难的，因为通常会发生的事情是：你会说：

B⊑∀isConfirmedBy。（C⊓D）
  β：B
  isConfirmedBy（β，X）

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

x：（C⊓D）

然后，你可以推断：

x：C
x：D

所以，基于：

我正在尝试在定义了限制的类上编写查询它，这将决定是否已满足限制并且，如果有，则将其退回。

听起来你要求的是一个返回候选 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

我没有你的本体论，但是我自己制作了一个版本，我提出了以下策略。如果我理解正确，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查询返回满足限制的匹配项

2 个答案: