当前位置：首页 > news >正文

初探Succinct Jagged稀疏多项式承诺方案

news 来源：原创 2025/6/8 12:25:45

1. 引言

2025年5月20日，Succinct团队发布了其论文 Jagged Polynomial Commitments (or: How to Stack Multilinears)，以及基于该技术的verifier——https://github.com/succinctlabs/hypercube-verifier/tree/main（Rust），使其能在大约 12 秒内完成对以太坊区块的证明，展示了链上实时证明的可行性。尽管这只代表了平均情况，并且能耗仍然较高，但它是使用 ZK 技术扩展以太坊的一个重大进展。

Jagged Polynomial Commitments (or: How to Stack Multilinears) 论文大量使用了multilinear多线性多项式和 sumcheck 协议，背景参考资料有：

sumcheck
GKR
以及 Basefold

此外，关于sparse commitments稀疏承诺及其应用的更多背景，可参看：

Srinath Setty 和 Justin Thaler 2025年论文 Twist and Shout: Faster memory checking arguments via one-hot addressing and increments
Srinath Setty、Justin Thaler 和 Riad Wahby 2023年论文 Unlocking the lookup singularity with Lasso

如果想了解一次性读取分支程序（read-once branching programs）及其在多线性扩展评估（evaluating multilinear extensions）中的应用，可参看：

2018年论文 Delegating Computations with (almost) Minimal Time and Space Overhead。

2. Jagged 函数

典型的算术化方案由若干张表组成（如，一张用于 CPU，一张用于 ALU，另一张用于内存等），并对这些表施加一组代数约束。每张表的每一列都使用单变量或多变量多项式进行编码，之后证明者对这些编码进行承诺（通过多项式承诺方案 PCS）。在所有情况下，都要求每一列的长度为 2 的幂，这使得能够使用快速傅里叶变换（FFT）或多线性拉格朗日基多项式（multilinear Lagrange basis polynomials）进行高效编码。

这种约束带来了若干限制：

1）每张表中所有列的长度必须相同；
2）需要对列进行填充，使其长度为 2 的幂。

这会带来大量开销，因为必须将所有列填充到相同长度，并在表中存储大量无效（如为零）的占位项。

希望使用某种稀疏的数据表示方式，也就是说，只存储所有非占位值。
此外，还希望将所有内容压缩成一列，从而只对一个编码进行承诺。

这正是Jagged Polynomial Commitments (or: How to Stack Multilinears)论文的核心贡献之一：

找到一种方式，在不使用大量填充的情况下，获得表的稠密表示（需要注意的是，最终的列长度仍需为 2 的幂，可能仍需一定的填充）。

将通过一张表来解释稠密表示（dense representation）背后的思想，但这个思路可以扩展到多张表，只需添加一个额外的变量来记录表的编号以及每张表有多少列。

假设有一张表，共有 32 列（ $32 = 2^5$ ）。对于每一列，保留该列的长度 $l_k$ ，即不包含占位项（dummy entries）的真实数据数量。如：

$l_0 = 2^{20}$
$l_1 = 2^{18} + 15$
$l_2 = 2^{16} + 1475$
……等等。

证明者可以构造一个向量 $t$ ，其每个元素为列长度的累加和。即：

$t_0 = l_0$
$t_1 = l_0 + l_1$
$t_2 = l_0 + l_1 + l_2$

总结起来为：

$t_0 = l_0$
$t_{k+1} = t_k + l_{k+1}$

注意，由于所有 $l_k$ 都是正数，向量 $t$ 的元素是非递减的。

可以将所有列按顺序叠加合并成一列。给定合并后的列向量中的某个索引 $j$ ，可以确定这个元素原本属于哪个列和哪一行：

1）首先找出最小的 $k$ ，使得 $j < t_k$ 。这个 $k$ 就是该元素所在的原始列。
2）然后计算行号： $i = j - t_{k-1}$ （如果 $k = 0$ ，则 $i = j$ ）

这样，在原始表格和合并后的列之间建立了一一对应的关系，将这种表示方式称为稠密表示（dense representation）。

稠密表示的总长度是 $2^m$ ，其中：
$\lceil \log_2 \max(t) \rceil$

由于可以根据索引 $j$ 找到对应的列和行，因此可以定义两个函数：
$\mathrm{col}(j) = \min_k \{ t_k > j \}$
$\mathrm{row}(j) = j - t_{k-1}$

用字母 $q$ 表示稠密表示的多线性编码（multilinear encoding），则每个条目对应原始整个表格的多线性扩展（multilinear extension）中的非占位部分 $p$ ，即：
$p(\mathrm{row}(j), \mathrm{col}(j)) = q(j)$

这种方式节省了大量表示整张表所需的空间，代价是需要证明者发送向量 $t$ 。

可以进一步证明，如果想要评估 $p(z_r, z_c)$ ，等价于：
$p(z_r, z_c) = \sum p(x, y) \cdot \mathrm{eq}(x, z_r) \cdot \mathrm{eq}(y, z_c) = \sum q(i) \cdot \mathrm{eq}(\mathrm{row}(i), z_r) \cdot \mathrm{eq}(\mathrm{col}(i), z_c)$

因为 $p (x, y)$ 中的任何零值都不会对总和产生贡献。

3. 为什么 Jagged 函数对多线性多项式有效？

多变量多项式使用 sumcheck 协议 将 statements 归约为对多项式在某个随机点的求值。如，可以使用 sumcheck 协议来验证某个多变量多项式 $g$ 在 hypercube 超立方体上的求值为零，通过如下的 zero-check 零检验公式：
$\sum \mathrm{eq}(r, x) \cdot g(x) = 0$

在与证明者交互之后，验证者最终只需要对某个点 $z$ 进行一次求值计算，即验证：
$\mathrm{eq}(r, z) \cdot g(z)$
以及一些与单变量多项式相关的简单检查。

使用多项式承诺方案（PCS），证明者可以向验证者提供对 $g$ 的访问权限，并使用 PCS 的evaluation protocol 评估协议对点 $z$ 进行求值。

对于单变量多项式，通常通过与定义在某个域 $D$ 上的消零多项式（vanishing polynomial） $Z_D(x)$ 相除，来验证 $g (x)$ 是否在 $D$ 上为零。如果 $D$ 拥有良好的结构（如由 $n$ 次单位根组成），那么 $Z_D(x)$ 可被高效计算。在这种情况下：
$Z_D(x) = x^n - 1$
然而，对于稀疏多项式， $Z_D(x)$ 的表示可能非常复杂，从而导致难以高效计算。

因此，多线性多项式不需要计算这种商项，并且可以预先在更一般的有限域中工作（相比之下，FFT 需要平滑的域，且通常要求 $F| - 1 = 2^n c$ ，其中 $n$ 至少为 $24$ ）。

4. 如何处理大量列？

Jagged Polynomial Commitments (or: How to Stack Multilinears) 论文提供了两种优化方式以处理大量列的问题：

1）Fancy jagged：如果表中所有列的高度（行数）相同，那么可以减少构造向量 $t$ 所需传输的信息量。
2）承诺列高：证明者可以将每列的高度信息（在表格之前添加）包含在表中，并对其进行承诺。

5. Jagged PCS

Jagged Polynomial Commitments (or: How to Stack Multilinears) 论文的另一个核心内容是：

构建适用于稀疏或 jagged 多项式的多项式承诺方案（PCS）。

回顾之前的公式：
$p(z_r, z_c) = \sum p(x, y) \cdot \mathrm{eq}(x, z_r) \cdot \mathrm{eq}(y, z_c) = \sum q(i) \cdot \mathrm{eq}(\mathrm{row}(i), z_r) \cdot \mathrm{eq}(\mathrm{col}(i), z_c)$

可以将函数 $f_t$ 的多线性扩展定义为：
$f_t(x) = \mathrm{eq}(\mathrm{row}(x), z_r) \cdot \mathrm{eq}(\mathrm{col}(x), z_c)$

使用适用于多线性函数乘积的 sumcheck 协议，只需向验证者证明：
$q(\alpha) \cdot f_t(\alpha)$

进一步拆分为：
$q(\alpha) = \beta_1,\quad f_t(\alpha) = \beta_2$

关键点在于：验证者可以高效计算 $f_t$ 。这一点在论文中的 Claim 3.2.1 中进行了证明。

为了证明函数 $f_t$ 可以被高效计算，Jagged Polynomial Commitments (or: How to Stack Multilinears) 论文引入了一个函数 $g (w, x, y, z)$ ，该函数满足：
$\iff x < z \quad \text{且} \quad x = w + y$

该函数 $g$ 可直接与 $f_t$ 相关联，并且可以通过一个 宽度为 4 的分支程序（branching program） 高效计算：
$f_t(z_r, z_c, i) = \sum_y \mathrm{eq}(z_r, y) \cdot g(z_c, y, t_{y-1}, t_y)$

这个证明依赖于多线性扩展的唯一性，因此只需在输入 $z_r, z_c, i$ 作为二进制字符串的情形下检查上述等式是否成立。

如果 $g(z_r, i, t_{y-1}, t_y) = 1$ ，那么：

$i < t_y$
$i = z_r + t_{y-1}$

由于 $z_r \ge 0$ ，可以推出：

$t_{y-1} \le i < t_y$
$z_r = i - t_{y-1}$

又因为有：

$\mathrm{col}_t(i) = z_c$
$\mathrm{row}_t(i) = z_r$

所以可以推出：
$f_t(z_r, z_c, i) = 1$
反过来，如果 $f_t(z_r, z_c, i) = 1$ ，那么变量 $w, x, y, z$ 自然满足 $g (w, x, y, z) = 1$ 的条件。

从上述分析可知，可以通过进行 $2^k$ 次 $g$ 的求值来计算 $f_t$ 。根据claim 3.2.2，一个宽度为 4 的只读分支程序（read-once branching program）可以高效计算 $g$ ，方法是：

逐位读取 $w, x, y, z$ ，并按流式方式处理。

判断 $g$ 是否非零的两个条件：

$i < t_y$
$z_r = i - t_{y-1}$

可以通过一次查看 4 位并跟踪两个额外变量来完成检查。

接下来，Jagged Polynomial Commitments (or: How to Stack Multilinears) 论文讨论了如何使用只读矩阵分支程序（read-once matrix branching program）来实现符号求值（symbolic evaluation），这是在批量证明多个求值点时所需要的。

这个程序由一系列矩阵 $M_j^{\sigma}$ 构成，其中：

$\sigma \in \{0,1\}^b$
$\dots, n$
还有一个sink vector 终结向量 $u$

对于输入 $\in \{0,1\}^n$ ，该程序的输出是如下向量的第一项：
$\left( \prod_j M_j^{x_j} \right) u$

即：
$e_1^T \left( \prod_j M_j^{x_j} \right) u$

其中 $e_1^j = \delta_{1j}$ ——当且仅当 $j = 1$ 时，其值为1，其它情况均为0值。

如果矩阵是布尔矩阵（即每个元素都是 0 或 1），那么矩阵乘法仅涉及加法操作。Jagged Polynomial Commitments (or: How to Stack Multilinears) 论文称这样的矩阵是乘法友好型（multiplication friendly），因为它们的乘法只涉及线性数量的加法、不需要乘法。

当终结向量 $u$ 尚未给出时，可以以符号形式完成计算；当最终给出 $u$ 时，即可获得整个矩阵分支程序的最终值。

关键思想是，可以得到一个向量 $\text{res}$ ，使得：
$\text{res} \cdot u = f_{M,u}(z)$
其中：

$f$ 是由矩阵 $M$ 和向量 $u$ 所定义的矩阵分支程序的多线性扩展。
向量 res 的表达式为：
$\text{res} = e_1^t \prod_j \left( \sum_{\sigma} \text{eq}(z_j, \sigma) M_j^\sigma \right)$

6. 多点求值的批量证明（Batch-proving of multiple evaluations）

在此面临的问题是：

验证者需要计算 $k$ 个不同点上的多项式取值，这可能非常昂贵。

然而，通过与证明者的交互，可以将所有这些求值归约为一次求值。这是一种标准技巧，方法是：

验证者选取一组随机权重 $\alpha_0, \alpha_1, \ldots, \alpha_{k-1}$ ，然后证明者执行一次随机线性组合。

具体来说，假设希望证明：
$\begin{aligned} h(z_0) &= v_0 \\ h(z_1) &= v_1 \\ &\vdots \\ h(z_{k-1}) &= v_{k-1} \end{aligned}$

证明者将上述求值按权重 $\alpha_j$ 做线性组合：
$\sum_j \alpha_j h(z_j) = \sum_j \alpha_j v_j$

证明者的目标是说服验证者每个 $h(z_j) = v_j$ 成立，因此将所有 $v_j$ 发送给验证者，而验证者可以自行计算右边的线性组合 $\sum \alpha_j v_j$ 。

对于左边，证明者可以高效计算。注意：
$z_j ) = \sum h (b) \mathrm{eq} (b , z_j) = \sum h_k \mathrm{eq} (b , z_j)$
其中 $\sum_j b_j 2^j$ ， $b = b_0 b_1 b_2 ... b_{ k - 1}$ 。

也就是说，可以将 $h(z_j)$ 看作是向量 $h$ （其中 $h_k = h(b)$ ）与 Lagrange basis polynomials拉格朗日基多项式向量 $\text{eq}(b, z_j)$ 的内积。

由于内积是(bi)linear 线性运算，可以将整体线性组合写为：
$\sum \alpha_j h( z_j ) = \sum h(b) \left(\sum \alpha_j \mathrm{eq} (b , z_j) \right)$

于是，证明者和验证者可以在函数：
$\cdot \sum \alpha_j \cdot \text{eq}(b, z_j)$
上执行 sumcheck 协议，最终，验证者只需在随机点 $\rho$ 上计算一次：
$h(\rho) \cdot \sum \alpha_j \cdot \text{eq}(\rho, z_j)$