RDF - 分发 rdf :type to all items in the list

Question

考虑以下 RDF:

semapi:BaseClass     a rdfs:Class; 
                     rdfs:subClassOf rdfs:Class .

semapi:hasChainTo a rdf:Property; 
                   rdfs:domain semapi:BaseClass;
                   rdfs:range  semapi:BaseClass .                   

semapi:DerivedClass  a rdfs:Class; rdfs:subClassOf semapi:BaseClass .                  

instances:Instance1 a semapi:DerivedClass;
                    semapi:hasChainTo (
                        [
                            a semapi:DerivedClass;
                                    semapi:hasChainTo (
                                           [C1]
                                           [C2]
                                    )
                            ]
                     )

如果semapi:hasChainTo rdfs:range semapi:BaseClass 那么它意味着列表是rdf:type semapi:BaseClass。

我真正想说的是列表中的每个 item 都是 rdf:type (ei. [C1] rdf:type semapi:BaseClass, [C2] rdf:type semapi:BaseClass, ...)

我该怎么做？我需要 Owl(最好不需要)吗？

Answer 1

根据您想要执行此操作的方式，您有几种选择。我认为你试图坚持非 OWL 推理，所以我们将确保包括这样的解决方案，但我也想谈谈 OWL 解决方案，因为对于一些类似的情况，它工作得很好。

使用 OWL 和自定义 ObjectList

如果您确实可以选择使用 OWL 推理器，那么这是一个很好的案例，您可以在其中创建自己的列表词汇表并使用一些属性链。这个想法是你引入一个类List和一个人nil和属性 first和 rest .您实际上只是在自己的命名空间中复制词汇表。然后假设您定义了两个属性

• likes : 将个体 X 与另一个个体 Y 联系起来； “X 喜欢 Y”。
• likesList : 将个体 X 与 X 喜欢的个体的列表(虽然不是 RDF 列表)相关联。

然后可以引入两个属性链公理

• likesList subPropertyChain likesList o rest : 如果 X likesList (_ ...)，则 X likesList (...)。

这样，从X likes (A B C)我们得到 X likes (A B C) , X likes (B C) , X likes (C) , 和 X likes nil .

• likes subPropertyChain likesList o first : 如果 X 喜欢列表 (A ...)，则 X 喜欢 A。

然后，从上面的所有这些推断语句中，我们得到 X likes A , X likes B , 和 X likes C .

在 Turtle 中，这看起来像:

@prefix :        <http://www.example.org/distributing#> .
@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#> .

<http://www.example.org/distributing>
      a       owl:Ontology .

:List
      a       owl:Class .

:nil  a       :List , owl:NamedIndividual .

:first
      a       owl:ObjectProperty .

:rest
      a       owl:ObjectProperty .

:likes
      a       owl:ObjectProperty ;
      owl:propertyChainAxiom
              (:likesList :first) .

[]    a       owl:Axiom ;
      rdfs:comment "If X likesList (A ...), then X likes A." ;
      owl:annotatedProperty
              owl:propertyChainAxiom ;
      owl:annotatedSource :likes ;
      owl:annotatedTarget (:likesList :first) .

:likesList
      a       owl:ObjectProperty ;
      rdfs:comment "Relates an individual I1 to a ObjectList of individuals that I1 likes." ;
      owl:propertyChainAxiom
              (:likesList :rest) .

[]    a       owl:Axiom ;
      rdfs:comment "If X likesList (A B C), then since (B C) is the rest of (A B C), X likesList (B C), too." ;
      owl:annotatedProperty
              owl:propertyChainAxiom ;
      owl:annotatedSource :likesList ;
      owl:annotatedTarget (:likesList :rest) .

如果您必须手动编写 RDF，这会有点不方便，因为您必须这样做

X :likesList [ :first A ;
               :rest [ :first B ;
                       :rest [ :first C ;
                               :rest nil ] ] ] .

并且不能使用漂亮的 (...) Turtle 包含的语法。这对你遇到的情况也没有帮助，因为 OWL 类不是个体，所以它们不能是对象属性的对象，并且 rdf:type不是对象属性。我只是想包括这个，因为它是对象属性在(非 RDF)个人列表上分布的好方法，并且因为该方法使以下解决方案更加清晰。

使用 SPARQL 查询

给定的数据如下:

@prefix : <urn:ex:> .

:X :pList (:A :B :C :D) .

像这样的 SPARQL 查询

prefix : <http://example.org/>
prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

construct { 
  ?x :p ?y 
} 
where { 
  ?x :pList/rdf:rest*/rdf:first ?y
}

产生

@prefix :        <http://example.org/> .
@prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

:X    :p            :A ;
      :p            :C ;
      :p            :B ;
      :p            :D .

为了模仿上面基于 OWL 的方法，我使用了两个属性 pList和 p , 但它们可能相同，在这种情况下 p将在列表中“分发”。

有了某个地方的数据存储，您应该能够使用 insert/where 进行 SPARQL 更新。 :

prefix : <http://example.org/>
prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

insert { 
  ?x :p ?y 
} 
where { 
  ?x :pList/rdf:rest*/rdf:first ?y
}

将数据添加到商店。

使用类似 Prolog 的语法

如果你真的想用推理机来执行这个推理，你就会在推理机特定的领域。然而，许多推理机都支持类似 Prolog 的查询语言，您也可以在那里编写这些规则。我不知道 AllegoGraph 的 RDFS++ 语法，但一般结构将包含一些定义，例如:

?x p ?y :- ?x pList ?list, ?list rdf:first ?y

?x pList ?l :- ?x pList ?list, ?list rdf:rest ?l