Lasso、Jolt 以及 Lookup Singularity——Part 2

1. 引言

前序博客见：

• Lasso、Jolt 以及 Lookup Singularity——Part 1

相关论文见：

• Srinath Setty（微软研究中心）、Justin Thaler（a16z密码学研究中心以及Georgetown University）、Riad Wahby（Carnegie Mellon University）2023年论文《Unlocking the lookup singularity with Lasso》
• Arasu Arun（New York University）、Srinath Setty（微软研究中心）、Justin Thaler（a16z密码学研究中心以及Georgetown University）2023年论文《Jolt: SNARKs for Virtual Machines via Lookups》

相应的开源代码实现见：

• https://github.com/a16z/Lasso（Rust）

Lasso、Jolt 以及 Lookup Singularity——Part 1中内容概要为：

• 1）Lookup argument：是指Prover $P$对vector $a\in {\mathbf{F}}^m$进行commit，并证明$a$中的每个元素均在预定义的table $t\in {\mathbf{F}}^n$中。
• 2）Lasso：为一组新的Lookup argument族：
  • Lasso的Prover $P$ 要比之前的lookup argument 快一个量级。
  • Lasso的Prover $P$ 对更少的field elements进行commit，且所有这些field elements都是small的。
  • 无需对许多table $t$进行commit。
  • 支持巨大（decomposable，或，LDE-structured）lookup table
  • Lasso的Prover $P$ 的commit开销为：$O(c(m+N^{1/c}))$个field elements。
• 3）Jolt：为新的zkVM技术。
  • 相比于之前的zkVM技术，Jolt的Prover $P$ 的commit开销要低很多。
  • 所实现的primitive instructions，通过对该instruction的整个evaluation table，做一次lookup。

2. 何为Lookup Singularity？

Lookup Singularity概念 由Barry WhiteHat在2022年11月在zkResearch论坛 Lookup Singularity中首次提出：

• 其主要目的是：让SNARK前端生成仅需做lookup的电路。
• Barry预测这样有很多好处，特别是对于可审计性 以及 形式化验证：
  • 更易于审计单个lookup argument和各种lookup tables，不再需要数千行的硬编码电路。
• 承认现有的lookup argument方案具有性能瓶颈 但 预测将得到改进：
  • 强调可能需要支持巨大table，如size为$2^{128}$的table。
• Lasso/Jolt可能可实现该愿景？

3. 何为Jolt？

Jolt反驳的故事点：

• 1）twitter上常提到的一个直观的观点——“更简单的指令集（如Cairo-VM），对应，更快的zkVM”，但事实上：
  • 1.1）Prover的开销主要在commit开销——Jolt Prover的开销 比 现有zkVM的Prover开销 要少；
  • 1.2）Jolt Prover的可扩展性更强，事实上Jolt Prover的开销与指令复杂度无关。
    • Jolt（每个指令）的复杂度仅依赖于该指令的输入size。
    • 只要每个指令的evaluation table是“structured”。
    • 出乎意料的是，复杂指令是“structured”的。
• 2）很多SNARKs方案（如HyperNova、ProtoStar等）都关注支持high-degree constraints，efficient SNARKs需要high-degree constraints，但当对应zkVM应用场景时，则没那么重要：
  • Jolt使用R1CS（为degree-2 constraints）。
  • 大多数工作量都“推给了lookup argument”。
  • 剩下的工作量很容易且简单地用R1CS来使用。
• 3）认为“基于large fields是浪费的（wasteful）”，这也是人们喜欢使用FRI的原因之一（还有一个原因是FRI可能具有post Quantum安全性）。在特定场景下，基于small field的field运算，要比，基于big field的field运算，快得多。但当使用基于椭圆曲线的承诺方案，对small field element进行commit时，其速度可以很快：
  • Jolt中几乎Prover commit的所有值都是small的。
  • 对于基于MSM的承诺方案，对某small field element进行commit所需的group运算次数，仅依赖于该element的size。
  • 与element所处的field本身有多大无关。
• 4）认为“将大计算分解为小计算（即“去规模经济”），不会带来性能损失”，但事实上是：
  • 如很多zkVM，仅对size不超过约$2^{23}$的pieces才会做recursive SNARKs。
  • Lasso/Jolt Prover $P$开销中均固定有$N^{1/c}$，其中$N$为table size。
  • 对大计算的摊销效果 要比 小计算的 好。
  • Lookup arguments都是关于“规模经济（economies of scale）”的。

4. Lookup arguments as data parallel computation

之前有很多研究成果是将SNARKs看成是数据并行计算：

• 基于许多不同的输入$x_1,\cdots ,x_m$，计算相同的函数$f$。
• 可将其看成是a “polynomial” amount of data parallelism：
  • 若$f$的输入长度为$n$，则不同输入的数量为$m=poly(n)$。
• 强迫Prover $P$以特定的方式evaluate $f$：
  • 为计算$f$而执行特定的电路。

本文将lookup arguments看成是data parallel computation SNARKs：

• lookup table中存储了函数$f$的所有evaluations。【将$f$看成是CPU的某Primitive instruction。】
• lookup argument则为$f$的高度数据并行evaluation SNARK：
  • 令Prover $P$证明某committed vector：
    $((a_1,f(a_1)),\cdots ,(a_m,f(a_m)))$
    中包含了$f$对不同输入$a_1,\cdots ,a_m$的正确evaluations。
• 由于Lasso Prover $P$的开销为$O(c(m+N^{1/c}))$，仅当lookup次数$m$不会比table size $N$小太多时，Lasso的效率才会更高：
  • 即，$f$的执行次数，应为$f$ input size，的指数级。

5. 对zkVM的沉思

现有zkVM设计的优点有：

• 1）可利用现有（可供CPU使用的）编译器基础设施：
  • RISC-V、EVM
  • 可利用现有的开发者友好的工具链，避免从头开始构建所有轮子
• 2）仅需要运行一次front-end。
• 3）生成“uniform”电路：
  • 特定size的uniform电路的后端，要比，不使用uniformity的后端，快得多。

现有zkVM设计的缺点为：

• 1）导致更大的电路：以矩阵乘法运算为例，只需要加法和乘法运算：
  
• 2）形成更大的攻击面：将高级语言编写的计算程序，编译为，汇编语言，的整个过程，必须是bug free的。

6. 何为Lasso？

6.1 Lookup argument定义

以range check为例，lookup argument是指：

• 1）令$t=(0,1,2,3,\cdots ,2^{128}-1)$为具有$N$个table元素的向量。
• 2）令$a\in {\mathbf{F}}^m$为一组应包含在上述table的值列表。
• 3）Verifier $V$已知：$a$的承诺值$c{m}_a$。
• 4）Prover $P$声称：$a$中所有元素均在table $t$中。
  即Prover $P$声称其知道$c{m}_a$的opening $a$，使得：
  • 对于每个$i=0,\cdots ,m-1$，存在 j ∈ { 0 , 1 , ⋯   , N − 1 } j\in\{0,1,\cdots, N-1\} j∈{ 0,1,⋯,N−1}，使得$a_i=t_j$。
• 5）通常将这种lookup argument称为unindexed lookup argument。

而indexed lookup argument是指待证明元素中还附加了索引值，indexed lookup argument定义为：

• 1）令$t\in {\mathbf{F}}^n$为具有$N$个table元素的向量。
• 2）Prover $P$对向量$((a_1,b_1),\cdots ,(a_m,b_m))$进行承诺。
• 3）Prover $P$声称，对于$i=1,\cdots ,m$，有$a_i=t[b_i]$。【即$a_i$为value，$b_i$对应为table $t$的索引号，Prover $P$声称$a$中所有元素均存在于$t$中相应的index。】

6.2 Interactive Proofs：动机与模式

基于interactive proofs（IPs）的SNARKs：

• 1）Trivial proof：Prover $P$将witness $w$发送给Verifier $V$，Verifier $V$直接自己检查witness $w$是否满足所声称的属性。
• 2）Slightly less trivial proof：Prover $P$将witness $w$发送给Verifier $V$，然后使用interactive proofs（IPs）来证明witness $w$满足所声称的属性：
  • 可解决Verifier $V$的工作量，但proof不是succinct的。
• 3）实际的SNARK：Prover $P$对witness $w$做密码学commit：
  • 使用interactive proofs（IPs）来证明witness $w$满足所声称的属性。
  • 仅公开关于committed witness $w$的足够信息，供Verifier $V$在interactive proofs（IPs）做相应check。
  • 借助Fiat-Shamir，可将interactive 协议转换为non-interactive 协议。

6.3 SNARK主流设计历史回顾

SNARK主流设计历史回顾：

• 1）SNARKs设计理论演变路径为：Interactive Proofs（IPs）–》multi-prover interactive proofs（MIPs）–》PCPs–》SNARKs：
• 2）实用SNARKs方案：
  • 2.1）Linear PCP：为首个实用SNARKs。
  • 2.2）数年之后，才有源于IPs/MIPs/PCPs（really IOPs）的实用SNARKs。

6.3.1 源于Interactive Proofs（IPs） SNARKs优势

源于Interactive Proofs（IPs）的SNARKs，与，源于其它设计理论的SNARKs方案，的主要不同之处在于：

• Prover $P$具有最小的承诺开销。
• 关键技术为：sum-check protocol [LFKN 1990]：
  • 基于多变量多项式（如有16到100个变量）。
  • Force Prover $P$正确地实现计算过程中的中间值，但不需要对这些中间值进行commit。
  • 某些使用sum-check协议的SNARKs方案（如Spartan）的Prover $P$仍需对中间值进行commit。事实上这样的方案是源于MIPs的，而不是IPs：
    • 尽管如此，相比于基于单变量多项式构建的SNARKs，这些方案的Prover $P$会对 更少 的中间值进行commit。
    • 借助sum-check，Prover $P$无需对“quotient多项式”或“composition多项式”进行commit，也没有FFT运算等等。

6.3.2 基于sum-check SNARKs缺点

基于sum-check SNARKs方案的缺点为：

• 具有相对更大的Verifier $V$开销。
  • proof中包含logrithmically个 field elements，且，通过Fiat-Shamir，Verifier $V$需计算logrithmically次 hash evaluation。
  • 必须使用多变量多项式承诺，而不是单变量多项式承诺：从而无法 与 单变量KZG承诺方案中的Verifier $V$开销 媲美。【“log size proof” vs. “constant size proof”】
• 当今许多使用FRI多项式承诺方案的项目，其evaluation proof中包含了$O(\lambda {\log }^2(n))$个 hash evaluations：
  • 通过基于small fields，来实现更快的prover。

6.3.3. sum-check最小化commit开销极端示例

接下来将展示使用sum-check来使commit开销最小化的极端示例：

• 1）示例一：矩阵乘法[T. 2013]：
  许多算法通过对$n\times n$矩阵做乘法运算来获得感兴趣的结果，如：

  • 基于一组输入来评估某神经网络。
  • 计算某graph中的三角形数量、直径等。

  sum-check协议为这些问题提供了IP（Interactive Proof）解决方案，其中Prover $P$计算矩阵的乘积，并做$O(n^2)$次field运算来证明该乘积结果的正确性：

  • proof size为$O(\log n)$
  • 永远不会将 乘法运算中的矩阵 发送给Verifier，也不会对 乘法运算中的矩阵 进行commit。

• 2）示例二：GKR协议（[GKR 2008, CMT 2012, T. 2013, 等等]）：

  • 对circuit evaluation 做interactive proof。所谓circuit evaluation ，是指Verifier $V$也知道电路的输入。
  • 为SNARK for circuit satisfiability，其中Prover $P$仅对电路输入进行commit，但不对中间gate值进行commit。所谓circuit satisfiability，是指Verifier $V$不知道电路的输入。
    
    【而在Lasso/Jolt中，public input $x$对应为lookup table，其size可能为$2^{128}$。】

GKR协议的开销为：

• 1）GKR协议Verifier $V$端开销为：
  • 1.1）$O(d\log |C|)$次field运算，其中$d$为circuit depth，$|C|$为circuit size。
  • 1.2）＋ 计算 $\tilde{x}(r)$ 所需用时 ＋ "check an evaluation proof for $\tilde{w}(r)$"所需用时。
• 2）GKR协议Prover $P$端开销为：
  • 2.1）$O(|C|)$次field运算。
  • 2.2）＋ “为 $\tilde{w}(r)$ 生成 an evaluation proof” 所需用时。

6.4 GKR协议–》Lasso/Jolt

在Lasso/Jolt中，GKR协议中的public input $x$对应为整个lookup table：

• 但所有Jolt lookup tables均是structured的，因此Verifier $V$可 以logarithmic time来计算$\tilde{x}(r)$。
• 谁也不用对这些lookup tables进行commit，甚至Prover $P$也不需要。

基于GKR的SNARKs方案，通常具有 适中的 Prover速度：

• 由计算机程序，转换为电路，需使用大量的“untrusted advice”。
• 即使是采用基于GKR的SNARKs方案，Prover $P$也需要对所有这些“untrusted advice”进行commit。
• 且，电路模型是受限的（为low-depth arithmetic circuits）。

Lasso/Jolt 将 “6.3.3. sum-check最小化commit开销极端示例” 更通用化：

• 1）Lasso中确实使用了GKR协议，但仅用GKR协议来计算“grand products”：
  • 所谓“grand products”，是指：对$n$个（committed）values求乘积，其中$n$很大。
  • 在Lasso中，几乎所有的这$n$个values均为lookups自身：
    • 根据定义，没有任何lookup argument可避免该commit工作。
• 2）使用low-depth arithmetic circuits可胜任，对大量field elements做乘积运算。
  • 相应的电路为depth为$\log (n)$，由multiplication gates组成的binary tree。
  • 在[T. 2013]中为这样的binary tree做了优雅的IP（Interactive Proof）：
    • [Lee + Setty 2020]将proof size由 $O({\log }^2(n))$ reduce为 $O(\log (n)\log \log (n))$。
    • Prover $P$确实需要对$O(n/{\log }^{10}(n))$个field elements进行commit。

6.5 Basic-Lasso：技术细节

6.5.1 Memory Checking

Basic-Lasso与Memory Checking的关系为：

• 可将lookup table $t\in {\mathbf{F}}^N$看成是计算机内某内存（memory）。
• indexed lookup argument实现了对该内存（memory）的读操作：
  • Prover $P$对vector $((a_1,b_1),\cdots ,(a_m,b_m))$进行commit。
  • 对于所有的$i=1,\cdots ,m$，Prover $P$声称$a_i=t[b_i]$。

SNARKs擅长让Prover $P$证明对committed values运行了特定算法：

• 通常，相应算法以arithmetic circuit高效实现。
• 该算法仅执行加法和乘法运算：
  • 对于基于sum-check的SNARKs，若算法可高度并行化——circuit为low-depth的，这样是有益处的。

6.5.2 关键技术：Fingerprinting vectors

Basic-Lasso中使用了2个Fingerprinting vectors变种：

• 1）equality checking
• 2）permutation checking

6.5.2.1 equality checking

所谓equality checking，是指：

• Alice有向量$\mathbf{a}=(a_0,\cdots ,a_{n-1})\in {\mathbf{F}}^n$
• Bob有向量$\mathbf{b}=(b_0,\cdots ,b_{n-1})\in {\mathbf{F}}^n$
• Alice和Bob的目标为：通过交换尽可能少的field elements，来判断$\mathbf{a}=\mathbf{b}$是否成立。

Trivial解决方案为：

• Alice将$\mathbf{a}$发送个Bob，Bob自己来检查$\mathbf{a}=\mathbf{b}$是否成立。
• 相应的communication开销为：$n$个值。

Randomized equality checking方案为：

• 令$\mathbf{F}$为满足$|\mathbf{F}|\ge n^2$的任意有限域。
• 将$a_i,b_i$看成是$\mathbf{F}$有限域内元素。
• 令$p(x)={\sum }_{i=0}^{n-1}{a}_i{x}^i,q(x)={\sum }_{i=0}^{n-1}{b}_i{x}^i$。
• 具体协议实现为：
  • Alice选择随机值$r\in \mathbf{F}$，并发送$(r,p(r))$给Bob。
  • 若$p(r)=q(r)$，则Bob输出EQUAL，否则输出NOT-EQUAL。
  • 总的communication开销为：$2$个field elements。
• 将$p(r)$称为“vector $\mathbf{a}$ 在$r$的Reed-Solomon fingerprint”。

对以上Randomized equality checking方案的正确性分析：

• 1）Claim 1：若$\mathbf{a}=\mathbf{b}$，则Bob输出EQUAL的概率为1。原因在于：
  • 由于$\mathbf{a}=\mathbf{b}$，因此$p$和$q$为相同的多项式，对于所有的$r\in \mathbf{F}$，均有$p(r)=q(r)$。
• 2）Claim 2：若$\mathbf{a}\ne \mathbf{b}$，选择$r\in \mathbf{F}$而Bob输出NOT-EQUAL的概率至少为$1-\frac{1}{n}$。原因在于：
  • $p\ne q$为degree最多为$n$的单变量多项式，因此$p,q$最多有$n$个重合点，等价为：
    ${\mathrm{Pr}}_{r\in \mathbf{F}}[p(r)=q(r)]\le \frac{n}{|\mathbf{F}|}$

6.5.2.2 permutation checking

所谓permutation checking，是指：

• Alice有向量$\mathbf{a}=(a_0,\cdots ,a_{n-1})\in {\mathbf{F}}^n$
• Bob有向量$\mathbf{b}=(b_0,\cdots ,b_{n-1})\in {\mathbf{F}}^n$
• Alice和Bob的目标为：判断$\mathbf{a}$和$\mathbf{b}$中是否具有相同的元素，对元素顺序无要求。

如$\mathbf{a}=(0,1,8,9)$，$\mathbf{b}=(0,9,1,8)$，则二者为permutation关系。
而若$\mathbf{a}=(0,1,8,3)$，$\mathbf{b}=(0,9,1,8)$，则二者不是permutation关系。

Randomized permutation checking方案为：

• 令$\mathbf{F}$为满足$|\mathbf{F}|\ge n^2$的任意有限域。
• 将$a_i,b_i$看成是$\mathbf{F}$有限域内元素。
• 令$p(x)={\prod }_{i=0}^{n-1}(x-a_i),q(x)={\prod }_{i=0}^{n-1}(x-b_i)$。【与Randomized equality checking方案不同，各元素不再是多项式的系数，而是多项式的roots。】
• 具体协议实现为：
  • Alice选择随机值$r\in \mathbf{F}$，并发送$(r,p(r))$给Bob。
  • 若$p(r)=q(r)$，则Bob输出EQUAL，否则输出NOT-EQUAL。
  • 总的communication开销为：$2$个field elements。
• 将以上整个流程称为“permutation-invariant fingerprinting”。

6.5.3 通过Fingerprinting来做Memory-checking [BEGKN 1994]

Basic-Lasso中将lookup argument看成是Memory Checking：

• 可将lookup table $t\in {\mathbf{F}}^N$看成是计算机内某内存（memory）。
• indexed lookup argument实现了对该内存（memory）的读操作：
  • Prover $P$对vector $((a_1,b_1),\cdots ,(a_m,b_m))$进行commit。
  • 对于所有的$i=1,\cdots ,m$，Prover $P$声称$a_i=t[b_i]$。

这样就将构建lookup argument，转换为，实现一种高效的算法，以检查从某内存（memory）中读取的所有值都是正确的：

• 可将内存（memory）读取看成是顺序发生的：
  • 由“weak Verifier”来决定每个time step读取哪个memory cell，并将相应的读取请求发送给某untrusted Prover $P$。
  • Prover $P$给每个请求恢复相应的value，声称当前在该memory cell中存储的即为该值。
  • “weak Verifier”需检查所返回的所有值都是“correct（正确的）”。
• [BEGKN 1994] 中关注Verifier $V$的space复杂度：
  • 通过fingerprinting特定vectors，Verifier $V$来完成相应检查；
  • fingerprints可 以递增方式来计算，因此Verifier $V$仅需要存储$2$个field elements。
• 本文重点关注Verifier $V$可在某arithmetic circuit内高效实现！

为让内存读取更checkable，[BEGKN 1994]中对读取流程做了如下修改：

• 1）修改1：对于每个“memory cell” $j=1,\cdots ,N$，维护了一个计数器$c_j$：
  • 可将$c_j$看成是用于追踪记录cell $j$已被读取的次数。
• 2）修改2：每次对cell $b_i$做读取操作，返回的为(value, count) pair $(a,c)$，且Verifier $V$需请求将该cell “overwrite”为tuple $(a,c+1)$。【即每个读操作$R$，对应有一个写操作$W$】
• 3）修改3：当完成所有读取操作之后，Verifier $V$会对内存做最后一次请求（final pass），要求Prover $P$提供存储于所有cell的(value, count) pair。【最后一次，只有读操作$R$，不再附加有写操作】
  • 而这最后读取的$N$个cell set值，不会再附加有“overwrite”操作。

[BEGKN 1994]中指出：

• 当且仅当，对每个cell $j$的每次读操作$R$ 返回的(value, count) pair，均为该cell上一次写操作$W$写入的(value, count) pair值，则$R$和$W$为permutation关系。

对应的基本流程为：

• 1）刚初始化完之后，$W$中包含了$N$个tuples，而$R$为空。

• 2）每次读取操作，为向$R$中增加一个tuple，每次写操作，会向$W$中增加一个tuple：

  • 若Prover $P$是诚实的，则每次向$R$中增加的tuple，应与$W$中现有的某个tuple “match（匹配）”。
  • 且，每个写操作，向$W$中添加的为在$R$中不存在的新tuple。
  • 在对final pass时，$R$应“match（匹配）” $W$中所有内容。【若Prover $P$是诚实的，则此时$R$和$W$长度完全一样，且内容完全一样，只是顺序不同。】

  若Prover $P$返回的为“incorrect” (value, count) pair，则：

  • $R$中该tuple，在$W$中并不存在。
  • 且$W$中仍然有$N$个tuple 不存在于 $R$中。
  • 即$R$与$W$中不同tuple的个数（$R\Delta W$）变为了$N+1$。
  • 这种$R$与$W$之间的“mismatch”是永远不可纠正的：
    • 在final pass之前，对该内存的每个读操作均会立即跟随一个写操作（写入另一值），因此，这种读/写组合，不会让$|R\Delta W|$值减少的。
    • 而对内存的final pass之后，只会让$|R\Delta W|$值减少$N$。

即：

• 令Prover $P$返回的所有读操作值，组成$R$向量，其每个元素为(cell, value, count) tuple。
• 令$W$向量对应为写操作，其每个元素为(cell, value, count) tuple。
  • $W$中包含对内存的初始化写入值——即$(j,t[j],0):j=1,\cdots ,N$。

接下来是对$R$和$W$做permutation checking：

• 1）对每个(cell, value, count) tuple 做Reed-Solomon fingerprint：
  • Verifier $V$选择随机值$\gamma \in \mathbf{F}$，将$\gamma$发送给Prover $P$。
  • Prover $P$将$R$或$W$中的所有$(b,a,c)$ tuple替换为$b+\gamma a+{\gamma }^{2}c$。
• 2）这样，可将$R$和$W$由 具有$N+m$个元素，每个元素为3个field elements的向量，reduce为，具有$N+m$个元素，每个元素为1个field elements的向量$R^{\prime },W^{\prime }$。
  • 若无碰撞（即两个不同的tuple具有相同的fingerprint），则$R^{\prime }$和$W^{\prime }$为permutation关系，当且仅当$R$和$W$为permutation关系。
• 3）对$R^{\prime }$和$W^{\prime }$做permutation-invariant fingerprinting：
  • Verifier $V$选择随机值$r\in \mathbf{F}$，将$r$发送给Prover $P$。
  • Prover $P$让Verifier $V$信服：${\prod }_{i=0}^{N+m-1}(r-R_i^{\prime })={\prod }_{i=0}^{N+m-1}(r-W_i^{\prime })$。

6.6 Basic-Lasso：完整技术细节

Basic-Lasso中：

• $t\in {\mathbf{F}}^N$：为lookup table。
• $b\in {\mathbf{F}}^m$：为table indices向量。
• $a\in {\mathbf{F}}^m$：为looked value向量。
• $c\in {\mathbf{F}}^m$：为相应index被读取的次数组成的向量。
• Verifier $V$收到的为$Com(\tilde{a}),Com(\tilde{b})$。
• Prover $P$声称：对于所有的$i=1,\cdots ,m$，有$a_i=t[b_i]$。

然后应用GKR协议：

电路$C$输出1个field element，为${\prod }_{i=0}^{N+m-1}(r-R_i^{\prime })与{\prod }_{i=0}^{N+m-1}(r-W_i^{\prime })$之间的差值。
电路$C$为由multiplication gates组成的binary tree，multiplication gates的输入为$R^{\prime },W^{\prime }$，其中：

• $\widetilde{R^{\prime }}(z)=\tilde{b}(z)+\gamma \cdot \tilde{a}(z)+{\gamma }^2\cdot \tilde{c}(z)$
• $\widetilde{W^{\prime }}(z)$也为$\tilde{t}(z)、\tilde{b}(z)、\tilde{a}(z)、\tilde{c}(z)$的简单组合。

6.7 Generalized-Lasso概览

6.7.1 多变量多项式基本事实

Schwartz-Zippel Lemma是指：

• 若$p\ne q$，且$p,q$为degree最多为$d$的单变量多项式，则${\mathrm{Pr}}_{r\in \mathbf{F}}[p(r)=q(r)]\le \frac{n}{|\mathbf{F}|}$。
• 若$p\ne q$，且$p,q$为total degree最多为$d$的具有$l$个变量的多变量多项式，则${\mathrm{Pr}}_{r\in {\mathbf{F}}^l}[p(r)=q(r)]\le \frac{n}{|\mathbf{F}|}$。

extension定义：

• 已知函数 f : { 0 , 1 } l → F f:\{0,1\}^l\rightarrow \mathbf{F} f:{ 0,1}l→F，基于$\mathbf{F}$域的具有$l$个变量的多变量多项式$g$，若对于所有的 x ∈ { 0 , 1 } l x\in\{0,1\}^l x∈{ 0,1}l，有$f(x)=g(x)$，则称$g$为对$f$的extend。

multilinear extension定义：

• 任意函数 f : { 0 , 1 } l → F f:\{0,1\}^l\rightarrow \mathbf{F} f:{ 0,1}l→F，具有 唯一的 multilinear extension（MLE）$\tilde{f}$。
  • multilinear意味着：多项式单项内每个变量的degree最大不超过1。

如：

相应的multilinear extension为：

而下例中，由于$g$中单项单个变量的最大degree为2，因此其为non-linear extension of $f$：

6.7.2 sum-check protocol [LFKN90]

sum-check protocol [LFKN90]是指：

• Verifier $V$对，基于$\mathbf{F}$域的具有$l$个变量的多变量多项式$g$，进行oracle access。
• 目标是：计算：
  ∑ b 1 ∈ { 0 , 1 } ∑ b 2 ∈ { 0 , 1 } ⋯ ∑ b l ∈ { 0 , 1 } g ( b 1 , b 2 , ⋯   , b l ) \sum_{b_1\in\{0,1\}}\sum_{b_2\in\{0,1\}}\cdots\sum_{b_l\in\{0,1\}}g(b_1,b_2,\cdots,b_l) ∑b1​∈{ 0,1}​∑b2​∈{ 0,1}​⋯∑bl​∈{ 0,1}​g(b1​,b2​,⋯,bl​)

sum-check protocol的开销为：

• 总的communication开销为：$O(dl)$个field elements。
  • Prover $P$发送$l$个message，每个message对应为——degree最多为$d$的单变量多项式。
  • Verifier $V$发送$l-1$个message，每个message对应为1个field element。
• Verifier $V$的runtime为：
  $O(dl+\text{time required to evaluate}$ $g$ $\text{at one point})$

6.7.3 sum-check protocol应用案例

sum-check protocol应用案例，如，构建统计三角形数量的Interactive Proof（IP），Verifier具有linear time：

• 输入： A ∈ { 0 , 1 } n × n A\in \{0,1\}^{n\times n} A∈{ 0,1}n×n，表示某graph的相邻矩阵。
• desired输出为：${\sum }_{(i,j,k)\in [n{]}^3}{A}_{ij}{A}_{jk}{A}_{ki}$。
• 目前已知的，做矩阵乘法运算最快的算法，约为$n^{2.37}$。【并不实用】
• 借助sum-check protocol，使得Verifier time为$O(n)$，具体的设计思路为：
  • a）将$A$看成是某function mapping { 0 , 1 } log ⁡ n × { 0 , 1 } log ⁡ n → F \{0,1\}^{\log n}\times \{0,1\}^{\log n}\rightarrow \mathbf{F} { 0,1}logn×{ 0,1}logn→F。如：
    
  • b）将$\tilde{A}$看成是$A$的multilinear extension。
  • c）定义多项式$g(X,Y,Z)=\tilde{A}(X,Y)\tilde{A}(Y,Z)\tilde{A}(X,Z)$
  • d）对$g$多项式应用sum-check协议，来计算：
    ∑ ( a , b , c ) ∈ { 0 , 1 } 3 log ⁡ n g ( a , b , c ) \sum_{(a,b,c)\in\{0,1\}^{3\log n}}g(a,b,c) ∑(a,b,c)∈{ 0,1}3logn​g(a,b,c)
• 相应的开销为：
  • 总的communication开销为$O(\log n)$。
  • Verifier $V$的runtime为$O(n^2)$，主要工作量在于evaluating：
    $g(r_1,r_2,r_3)=\tilde{A}(r_1,r_2)\tilde{A}(r_2,r_3)\tilde{A}(r_1,r_3)$
  • Prover $P$的runtime为$O(n^3)$。

6.7.4 Generalized-Lasso协议

• 1）Verifier $V$知道：$\tilde{a}$的（多项式）承诺值，其中：
  • $\tilde{a}$为$a$的extension，
  • 可将$a$看成是某function mapping { 0 , 1 } m → F \{0,1\}^m\rightarrow \mathbf{F} { 0,1}m→F。
• 2）Prover $P$的natural witness为：list $j(0),j(1),\cdots ,j(m-1)$。
• 3）Verifier $V$需要check：
  对于 $i=0,\cdots ,m-1$，$(\ast )a_i=t[j(i)]$是否成立。【借鉴了Caulk思想。】
• 4）令$M$为$m\times N$矩阵，其第$i$行指定了$j(i)$ in unary。
  • $M$矩阵第$i$行在列$j(i)$值为1，其余位置均为0。【$M$为超级稀疏的矩阵。】
• 5）Checking $(\ast )$ 等价为 checking $Mt=a$。
  如：
  
  
• 6）令$b=Mt$，则：
  • Fact 1： b ~ ( r ) = ∑ j ∈ { 0 , 1 } log ⁡ N M ~ ( r , j ) t ~ ( j ) \tilde{b}(r)=\sum_{j\in\{0,1\}^{\log N}}\tilde{M}(r,j)\tilde{t}(j) b~(r)=∑j∈{ 0,1}logN​M~(r,j)t~(j)为formal polynomials。原因在于：
    • 该等式右侧为multilinear in $r$，且对所有的 r ∈ { 0 , 1 } m r\in\{0,1\}^m r∈{ 0,1}m输入均与$b$ agree。因此，其必然为$b$的unique multilinear extension。
  • Fact 2：根据Schwartz-Zippel，检查$Mt=a$ 等价为 对任意选择的$r\in {\mathbf{F}}^{\log m}$来检查$\tilde{b}(r)=\tilde{a}(r)$，的soundness error上线为$\log (m)/|\mathbf{F}|$。

为此，Generalized-Lasso协议为：

• Prover $P$发送对$\tilde{M}$的承诺值。
• Verifier $V$随机选择$r\in {\mathbf{F}}^{\log m}$。
• Prover $P$ 和 Verifier $V$ 运行sum-check protocol 来确认：
  a ~ ( r ) = ∑ j ∈ { 0 , 1 } log ⁡ N M ~ ( r , j ) t ~ ( j ) \tilde{a}(r)=\sum_{j\in\{0,1\}^{\log N}}\tilde{M}(r,j)\tilde{t}(j) a~(r)=∑j∈{ 0,1}logN​M~(r,j)t~(j)【右侧等价为Fact 1的$\tilde{b}(r)$】
• 在sum-check协议最后一步，Verifier $V$需要知道$\tilde{a}(r),\tilde{b}(r^{\prime }),\tilde{M}(r,r^{\prime })$，其中：
  • $r^{\prime }$为 Verifier $V$ 在sum-check协议中选择的随机field elements vector。
  • $\tilde{a}(r),\tilde{M}(r,r^{\prime })$由Prover $P$提供，因为$\tilde{a}$和$\tilde{M}$通过多项式承诺方案进行commit了。
  • 若lookup table是LDE-structured，则Verifier $V$可自行计算$\widetilde{r^{\prime }}$，用时为$O(\log N)$。
    如若$t=(0,1,2,\cdots ,2^{128}-1)$，则$\tilde{t}(r^{\prime })={\sum }_{k=0}^{127}{2}^k{r}_k^{\prime }$

其中，忽略的主要细节有

• 1）Prover $P$如何对$\tilde{M}$进行commit，并在稍后reveal one requested evaluation，相应的Prover $P$ runtime与$M$中的非零元素数量呈比例？：
  • 而不是与$M$中所有元素数呈比例。
  • 即希望的Prover $P$ runtime为$m$，而不是$m\cdot N$。
  • 为此需要名为sparse polynomial commitment scheme的多项式承诺方案：【即Lasso自身】
    • Basic-Lasso中已提供了构建sparse polynomial 多项式承诺方案 的主要技术。
    • 核心思想为：Prover $P$对$M$中的非零元素仅需commit：即为sparse多项式$\tilde{M}$的“dense”表示。
    • 当Verifier $V$请求$\tilde{M}(r)$时，Prover $P$证明其基于$M$中的非零元素，运行某（快速）算法正确计算了$\tilde{M}(r)$。
    • 该算法仅用于乘法，以及，对size为$N$的decomposable table的lookup。
• 2）即使$\tilde{M}(r,j)$和$\tilde{t}(j)$ extend vectors长度为$O(N)$，如何将sum-check Prover time实现为$O(m)$？：
  • 关键在于让$\tilde{M}(r,j)$为$m$-sparse：
    • j ∈ { 0 , 1 } log ⁡ N j\in\{0,1\}^{\log N} j∈{ 0,1}logN中的$m$个值之外的所有其它值均为0。
    • Prover仅需关注$j$值，忽略其它$N-m$个值。

参考资料

[1] 2023年8月Justin Thaler给a16z团队分享 视频 Lasso, Jolt, and the Lookup Singularity, Part II with Justin Thaler | a16z crypto research talks

Justin Thaler系列博客

• SNARK Design
• Rollup项目的SNARK景观
• SNARK原理示例
• SNARK性能及安全——Prover篇
• SNARK性能及安全——Verifier篇
• sum-check protocol in zkproof
• sum-check protocol深入研究
• Lasso、Jolt 以及 Lookup Singularity——Part 1

lookup系列博客

• PLOOKUP
• PLOOKUP代码解析
• Efficient polynomial commitment schemes for multiple points and polynomials学习笔记
• PLONK + PLOOKUP
• PlonKup: Reconciling PlonK with plookup
• PLONK: permutations over lagrange-bases for oecumenical noninteractive arguments of knowledge 学习笔记
• Plonk代码解析
• RapidUp: Multi-Domain Permutation Protocol for Lookup Tables学习笔记
• Lookup argument总览
• Halo2 学习笔记——设计之Proving system之Lookup argument（1）
• 多变量lookup argument
• cq：fast lookup argument
• Lookup Argument性能优化——Caulk
• 2023年 ZK Hack以及ZK Summit 亮点记
• Research Day 2023：Succinct ZKP最新进展
• Lasso、Jolt 以及 Lookup Singularity——Part 1