rdf - 在 SPARQL 中操作 RDF 集合的函数

Question

我想知道是否有一些函数可以在 SPARQL 中操作 RDF 集合。

一个激励问题如下。

假设你有:

@prefix : <http://example.org#> .
:x1 :value 3 .
:x2 :value 5 .
:x3 :value 6 .
:x4 :value 8 .

:list :values (:x1 :x2 :x3 :x4) .

并且您要计算以下公式: ((Xn - Xn-1) + ... (X2 - X1))/(N - 1)

有什么通用的计算方法吗？

到目前为止，我只能为一组固定的值计算它。例如，对于 4 个值，我可以使用以下查询:

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

SELECT ?r { 
 ?list :values ?ls .
 ?ls rdf:first ?x1 .
 ?ls rdf:rest/rdf:first ?x2 .
 ?ls rdf:rest/rdf:rest/rdf:first ?x3 .
 ?ls rdf:rest/rdf:rest/rdf:rest/rdf:first ?x4 .
 ?x1 :value ?v1 .
 ?x2 :value ?v2 .
 ?x3 :value ?v3 .
 ?x4 :value ?v4 .
 BIND ( ((?v4 - ?v3) + (?v3 - ?v2) + (?v2 - ?v1)) / 3 as ?r)
}

我想要的是某种访问第 N 个值并定义某种递归函数来计算该表达式的方法。我认为这是不可能的，但也许有人有一个很好的解决方案。

Answer 1

没有使公式更容易的内置插件......

SPARQL 确实包含一些用于算术和聚合计算的数学函数。但是，我不知道在 SPARQL 中简明地表示数学表达式的任何特别方便的方法。我最近一直在看一篇论文，该论文讨论了一种表示数学对象(如表达式和定义)的本体。他们实现了一个系统来评估这些，但我认为它没有使用 SPARQL(或者至少，它不仅仅是 SPARQL 的简单扩展)。

Wenzel, Ken, and Heiner Reinhardt. "Mathematical Computations for Linked Data Applications with OpenMath." Joint Proceedings of the 24th Workshop on OpenMath and the 7th Workshop on Mathematical User Interfaces (MathUI). 2012.

......但我们仍然可以这样做。

也就是说，这种特殊情况并不太难做到，因为在 SPARQL 中使用 RDF 列表并不难，而且 SPARQL 包含此表达式所需的数学函数。首先，关于 RDF 列表表示，这将使解决方案更容易理解。 (如果你已经熟悉这个，你可以跳过下一段或两段。)

RDF 列表是链表，每个列表都通过 rdf:first 与其第一个元素相关联。属性(property)，列表的其余部分由 rdf:rest .所以方便的符号 (:x1 :x2 :x3 :x4)实际上是以下的简写:

_:l1 rdf:first :x1 ; rdf:rest _:l2 .
_:l2 rdf:first :x2 ; rdf:rest _:l3 .
_:l3 rdf:first :x3 ; rdf:rest _:l4 .
_:l3 rdf:first :x4 ; rdf:rest rdf:nil .

用 [] 表示空白节点，我们可以让这更清楚一点:

[ rdf:first :x1 ;
  rdf:rest [ rdf:first :x2 ;
             rdf:rest [ rdf:first :x3 ;
                        rdf:rest [ rdf:first :x4 ;
                                   rdf:rest rdf:nil ]]]]

一旦确定了列表的头部，即具有 rdf:first :x1 的元素, 然后任何列表 l 可以通过 rdf:rest/rdf:rest 的偶数次重复(包括 0)从它到达是一个列表，其 rdf:first是列表的奇数元素(因为您从 1 开始索引)。从 l 开始，再往前一个 rdf:rest ，我们在一个 rdf:first是列表的偶数元素。

由于 SPARQL 1.1 属性路径让我们编写 (rdf:rest/rdf:rest)*表示 rdf:rest 的任何偶数重复，我们可以编写以下查询来绑定(bind) :value ?n 的奇数元素以及以下偶数元素的值为 ?nPlusOne . SELECT 中的数学形式很简单，虽然要得到 N-1，我们实际上使用 2*COUNT(*)-1 ，因为行数(每行绑定(bind)元素 n 和 n+1)为 N/2。

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

SELECT ( SUM(?nPlusOne-?n)/(2*COUNT(*)-1) as ?result) {
 ?list :values [ (rdf:rest/rdf:rest)* [ rdf:first [ :value ?n ] ; 
                                        rdf:rest  [ rdf:first [ :value ?nPlusOne ]]]] .
}

结果(使用 Jena 的命令行 ARQ):

$ arq --query query.sparql --data data.n3 
------------------------------
| result                     |
==============================
| 1.333333333333333333333333 |
------------------------------

这是预期的，因为

 (5 - 3) + (8 - 6)     2 + 2     4      _ 
------------------- = ------- = --- = 1.3
      (4 - 1)            3       3

更新

我刚刚意识到，上面的实现是基于我对求和是否正确的问题的评论，因为它很容易简化。也就是上面的实现

(x2 - x1) + (x4 - x3) + ... + (xN - xN-1) / (N - 1)

而最初的问题要求

(x2 - x1) + (x3 - x2) + … + (xN-1 - xN-2) + (xN - xN-1) / (N - 1)

原来的更简单，因为这些对由每个 rdf:rest 标识。的原始列表，而不仅仅是偶数重复。使用与上述相同的方法，此查询可以表示为:

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

SELECT ( SUM(?nPlusOne-?n)/COUNT(*) as ?result) {
 ?list :values [ rdf:rest* [ rdf:first [ :value ?n ] ; 
                             rdf:rest  [ rdf:first [ :value ?nPlusOne ]]]] .
}

结果:

$ arq --query query.sparql --data data.n3 
------------------------------
| result                     |
==============================
| 1.666666666666666666666666 |
------------------------------

当然，由于表达式可以简化为

xN - x1 / (N - 1)

我们也可以只使用绑定(bind) ?x1 的查询到列表的第一个元素， ?xn到最后一个元素， ?xi到列表的每个元素(以便 COUNT(?xi) (以及 COUNT(*) )是列表中的项目数):

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

SELECT (((?xn-?x1)/(COUNT(?xi)-1)) as ?result) WHERE {
 ?list :values [ rdf:rest*/rdf:first [ :value ?xi ] ;
                 rdf:first [ :value ?x1 ] ;
                 rdf:rest* [ rdf:first [ :value ?xn ] ; 
                             rdf:rest  rdf:nil ]] .
}
GROUP BY ?x1 ?xn

结果:

$ arq --query query.sparql --data data.n3 
------------------------------
| result                     |
==============================
| 1.666666666666666666666666 |
------------------------------