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。

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

我该怎么做？我需要猫头鹰吗(最好不需要)？

Answer 1

根据您想要如何执行此操作，您有几种选择。我认为您正在尝试坚持非 OWL 推理，因此我们将确保包含这样的解决方案，但我也确实想谈谈 OWL 解决方案，因为对于某些类似的情况，它效果很好。

使用 OWL 和自定义 ObjectList

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

• 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