# 不完整的折叠指南：Nova、Sangria、SuperNova、HyperNova、Protostar

By [fen yun](https://paragraph.com/@11qqq) · 2023-08-11

---

_特别感谢_[_arnaucube_](https://twitter.com/arnaucube) _\*\*、\*_ Brecht [Devos](https://twitter.com/Brechtpd)、Barak、[Benedikt Bünz](https://twitter.com/benediktbuenz)、[Binyi Chen](https://twitter.com/Charles_Chen533)和[Ben Wan](https://twitter.com/odesium)的审阅。\*

### **长话短说**

整个 zk 行业正在努力的目标是 (i) 尽可能降低证明生成成本，同时 (ii) 保留尽可能小的证明，以及 (iii) 尽可能高效地进行验证。这可以通过证明者优化来实现，或者作为替代方案，可以压缩证明者证明的数据。

![](https://storage.googleapis.com/papyrus_images/7a83b7c9c2bf86d1421c1dcb979cac6e858f096f1fb8ad8eea791a88c6fe8bff.png)

在过去的几年里，zk 科学界在折叠方案技术方面做了大量工作。在本文中，我们探讨了折叠方案技术，该技术可用于在验证单个证明验证整个计算链时实现更有效的 IVC（增量可验证计算）方法。我们还简要解释了折叠方案的用途，并介绍了当前技术水平的演变。

### **内容**

1.  递归 SNARK：特征和约束
    
2.  Folding – 递归的另一种方法，以及 Nova –R1CS 的折叠应用程序
    
3.  桑格利亚汽酒——PLONKish 赛道的 Nova
    
4.  SuperNova——广义新星
    
5.  HyperNova – 使用总和检查和可定制约束系统 (CCS) 进行折叠
    
6.  ProtoStar – Nova（和 Sangria）效率保持泛化
    

![](https://storage.googleapis.com/papyrus_images/e5ed799f87cedd4214674d070d2e266c43d2c95ba93295e532458e614b90e226.png)

### **让我们从简单的电路构建方法开始**

在一种简单的方法中，人们构建了一个涵盖所有操作码和 EVM 更改的巨型电路。

_免责声明：要了解操作码和电路是什么，请查看PSE 的_[_这篇文章_](https://mirror.xyz/privacy-scaling-explorations.eth/AW854RXMqS3SU8WCA7Yz-LVnTXCOjpwhmwUq30UNi1Q)_，要了解 ZK-EVM 中不同电路如何相互连接，请查看PSE 的_[_另一篇文章。_](https://mirror.xyz/privacy-scaling-explorations.eth/shl8eMBiObd6_AUBikXZrjKD4fibI6xUZd7d9Yv5ezE)

这种方法的问题

*   证明器内存需求与 n（电路被调用的次数）成正比；
    
*   难以并行/分布式证明生成；
    
*   验证者时间也可能取决于 n；
    
*   证明时间与n成正比。
    

**1\. 递归和聚合：特征和约束**
-------------------

**递归 SNARK 意味着在**另一个 SNARK证明中验证一个SNARK 证明。递归允许 ZK-SNARK 证明者将更多知识压缩到他们的证明中，同时保持 SNARK 的简洁性。

**递归 SNARKs 应用**

**示例 1：人们** **不是生成知识证明，而是创建他们知道某个_证明的_证明。**

结果，我们有两个电路：

1.  内部电路（大）：证明者证明他们认识证人。在这个阶段，**证明生成很快**，但证明很大（证明大小为常数的情况除外）；
    
2.  外电路（小）：证明者证明他们知道证明。在这个阶段，证明生成速度较慢（但这并不重要，因为在大多数情况下电路比第一个小得多），但证明**很小**。
    

感谢递归 SNARK，我们得到了快速**证明生成**和\*_简短的_最终\*证明。\*\*然而，如果验证器电路（外部电路）比想要证明的初始陈述小得多，则这种方法有效。

![](https://storage.googleapis.com/papyrus_images/358814df7c8932ad699d781b12cce40a32b64cfeebb406a17e02ae7c7cfbbdc5.png)

**示例 2：使用证明聚合一次证明多个语句（例如，对于 ZK-Rollup，证明块中的所有交易都是有效的）。**

要为所有语句生成一个整体证明，需要等到他们拥有需要证明的_所有_语句（在汇总示例中，在块准备好被证明之前，应该填充尽可能多的交易）。相反，由于递归 SNARK，人们可以在得到第一个语句后开始生成_证明_。最后，生成证据的证明。

与 ZK-Rollup 示例一样，它可以按以下方式工作：

![](https://storage.googleapis.com/papyrus_images/f3155ad723bb2d5a9374aac55c5d7df70db71a6aac4ad2e03df5f3fdbdfd9c7c.png)

因此，在收到所有交易后，证明者仅生成一个最终的证明证明（聚合其他证明），这比为所有交易生成整体证明要快得多。

**示例 3：IVC – 增量可验证计算**

IVC 允许我们用相对较少的内存进行长时间计算的证明。

函数**F**（例如微处理器）被迭代多次。每一步都会生成一个新的证明：它证明_到目前为止的_计算是正确的。

### **IVC的核心理念**

在步骤**n**：

*   证明者计算一个新的状态**_s\_n_**
    

![](https://storage.googleapis.com/papyrus_images/8dfa4fe3403e282fe0fe6664eaff679996382027b4e338c2dfc9a5d3e2b3c780.png)

*   证明**_π\_n_**证明证明者有一个见证人\*\*\*(s\_n-1, w\_n, π\_n-1)**_，使得当前状态 (s\_n) 相对于先前状态 (s\_n-1) 是正确的。即_**F(s\_n-1, w\_n) = s\_n。\*\*\*并且先前状态（π\_n-1）的证明相对于先前状态（s\_n-1）是正确的。即，**_V(vp, (n-1, s\_0, s\_n-1), π\_n-1) = true_**。
    

![](https://storage.googleapis.com/papyrus_images/afd9c59f6d8c2b8a59720e4ac98560ab8ae0da9a4471c7f55f6aba0ddde437b0.png)

重要的是，在每一步结束时，只有_一个_最终输出——状态**s\_n**。证人的知识\*\*(w\_0, …, w\_n)**嵌入到**s\_n**中。并且在每一步中，都有一个证明**π**来证明直到当前步骤的每一步的计算都是正确完成的。也就是说，我们在步骤 1 处有**π\_1\*\* ，在步骤 2 处有**π\_2 ，在步骤 3 处有π\_3**，...，在步骤 n 处有**π\_n**。_验证者可以通过仅验证一个_证明**π\_n来检查当前步骤n**之前的所有步骤的计算是否正确完成。

**下腔静脉的应用**

*   将长计算分解为一系列小的相同步骤，从而显着降低证明者的内存需求；
    
*   生成简洁的证据来证明区块链的当前状态是正确的。也就是说，将整个区块链的有效性证明压缩为一个简洁的证明（例如，Mina 使用它向每个区块“注入”一个证明，证明区块链上从创世开始的所有先前交易都是有效的）；
    
*   **F**是延迟函数的一次或多次调用，与IVC一起构成可验证延迟函数（例如MinRoot）；
    
*   ZK-VM：**F**是 VM（例如 EVM、LLVM、WASM 等）的步骤（机器支持的任何操作码）；
    
*   zkBridge：**F**根据区块链共识规则等验证状态。
    

**递归的局限性**

然而，证明者需要为运行整个验证算法**V (vp, x, π)的电路C**构建证明。验证多项式承诺的评估证明的成本很高。

好的，递归允许我们做一些技巧，在其他证明中生成证明。这有助于减少证明生成时间和证明大小。但是如果我们可以压缩我们想要证明的陈述呢？

[https://twitter.com/fede\_intern/status/1668553291687444481?ref\_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1668588685162426368%7Ctwgr%5E32ba7300510ec52ba40b967c0dde859680cb5ed8%7Ctwcon%5Es3\_&ref\_url=https%3A%2F%2Ftaiko.mirror.xyz%2Ftk8LoE-rC2w0MJ4wCWwaJwbq8-Ih8DXnLUf7aJX1FbU](https://twitter.com/fede_intern/status/1668553291687444481?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1668588685162426368%7Ctwgr%5E32ba7300510ec52ba40b967c0dde859680cb5ed8%7Ctwcon%5Es3_&ref_url=https%3A%2F%2Ftaiko.mirror.xyz%2Ftk8LoE-rC2w0MJ4wCWwaJwbq8-Ih8DXnLUf7aJX1FbU)

**用于半结构化计算的 ZK-SNARK 的演变**

![](https://storage.googleapis.com/papyrus_images/5ec4f26b566194c1b245477d916b3c8e13f6639ad35240c4a8224d70d680721d.png)

_图表来源：PSE 的“CCS & HyperNova with Srinath - Folding Schemes FTW”_[_讲座。_](https://www.youtube.com/watch?v=pDFmANwwIoY)

**2\. Folding – 递归的替代方案，以及 Nova – R1CS 的折叠实例化**
-----------------------------------------------

_免责声明1：2020 年，Benedikt Bünz、 Alessandro Chiesa、William Lin、Pratyush Mishra和 Nicholas Spooner_发表了论文《Proof-Carrying Data without Succinct Arguments》 。_它实现了与下面描述的“关于折叠的酷事”相同的特性。然而，它的成本是 3 次标量乘法，而不是 2 次（用于折叠）。_

_免责声明 2：尽管在 Nova 中，折叠方案是针对 R1CS 实例化的，但它可以推广到其他约束系统。例如，_[_桑格利亚汽酒_](https://geometry.xyz/notebook/sangria-a-folding-scheme-for-plonk)_（Nicolas Mohnblatt）的 PLONKish 赛道就是这样做的。有关更多详细信息，请参阅第 3 节“Sangria – Nova for PLONKish 电路”。_

想法：进行预处理以压缩 SNARK 输入。

关于折叠的酷事：

*   不执行任何多项式除法或乘法（例如，通过需要大量内存且计算量大的 FFT）；
    
*   适用于_任何_类型的椭圆曲线（例如 secp、secq、Pasta 等）；
    
*   **F**用R1CS指定；
    
*   没有可信设置；
    
*   与递归开销相比，折叠预计比 Groth16、PLONK、Halo 等快 5-50 倍。证明时间由两个大小为\*\*O(C)**的多次幂运算决定，其中**C = | _F_ | \*\*;
    
*   验证器电路是常量大小（两个标量乘法）；
    
*   证明大小为\*\*O(log C)\*\*组元素（几 KB）。
    

长话短说：通过折叠，可以将两个实例“压缩”为一个，并添加它们被正确“压缩”的证据。

它满足完整性和知识健全性要求：

*   如果原始证人**w1**和**w2**是正确的，则新证人**w**也是正确的；
    
*   如果新见证人 w 对于折叠实例**x**是正确的，则可以提取初始实例**x1**和**x2**的原始见证人**w1**和**w2 。**
    

**“简而言之折叠”的高级概述**

![](https://storage.googleapis.com/papyrus_images/ab19a49bac9a564e81534a9c09069cf7be3e8758f6a70e636aa3bead2b8d3e8d.png)

最初，折叠是一种交互式协议，如上图所示，其中**T**是交叉项，这意味着索引为 1 和 2 的变量参与一项，而 r 是随机挑战。

可以使用 Fiat-Shamir 将协议转换为非交互式协议。然后证明者自行生成随机性，对**x1**、**x2**和**T**进行哈希处理，并附上随机性已正确生成的证明。

最初，**Nova 是为 R1CS 设计的**（请记住，存在三种常见的约束系统：[R1CS](https://learn.0xparc.org/materials/circom/additional-learning-resources/r1cs%20explainer/)、[PLONK](https://taiko.mirror.xyz/9kGUby8h_dyu-t8jcPkDADfbWUMJw3mlGxvZAZk9sV0)和[AIR](https://aszepieniec.github.io/stark-anatomy/stark.html)）。

对于[R1CS](https://learn.0xparc.org/materials/circom/additional-learning-resources/r1cs%20explainer/)程序**A、B、C**和公共输入**x**（其中**A、B、C** – 三个**m\*m**大小的矩阵），如果**z = (x, w)使得**(Az) ○ ( Bz) = Cz，其中**○**是[哈达玛](https://stemandmusic.in/maths/mvt-algebra/matrixHP.php)积。

### **为了构建 R1CS 的折叠方案，我们有**

*   R1CS实例：R1CS程序**A、B、C**和公共输入**x**；
    
*   公共输入**x1**和见证人**z1 = (x1, w1)** ;
    
*   公共输入**x2**和见证人**z2 = (x2, w2)**；
    
*   对于**z1**和**z2**，我们期望 ( **Az) ○ (Bz) = Cz**。
    

如果我们直接说（只是弃牌）：

*   使用具有随机性的线性组合**r** : **x = x1 + r \* x2** ;
    
*   计算**z = z1 + r \* z2 = (x1 + r \* x2, w1 + r \* w2)** ;
    
*   计算\*\*(Az) ○ (Bz)\*\* ;
    
*   但是，我们将得到(Az) ○ (Bz) = **Cz1 + r ^2 \* Cz2 + E ，而不是理想的 (Az) ○ (Bz) = Cz** ，其中Cz = Cz1 + r \* Cz2 ，其中**E**包括所有一些交叉-项和E如下：
    
*     
    

![](https://storage.googleapis.com/papyrus_images/86b18103fda5ad340526072202f43b4a614f7acfcfb83e0fef8a922941f6a1ff.png)

### **为了克服这个问题，可以使用Relaxed R1CS：**

**为了构建松弛**R1CS的折叠方案，我们有

*   R1CS实例：R1CS程序**A、B、C**和公共输入\*\*(x,u,E)**，其中标量**c**和向量**E\*\*是噪声参数；
    
*   公共输入\*\*(x1, c1, E1)**和见证者**z1 = (x1, w1)\*\*；
    
*   公共输入\*\*(x2, c2, E2)**和见证者**z2 = (x2, w2)\*\*；
    
*   对于**z1**和**z2**，我们期望\*\*(Az) ○ (Bz) = u(Cz) + E\*\*。
    

如果我们直接说（只是弃牌）：

*   **使用随机性r**的线性组合：(i) **x = x1 + r \* x2**，(ii) **u = u1 + r \* u2**，(iii) **E = E1 + rT + r^2 \* E2**（其中**T**是交叉学期）;
    
*   计算**z = z1 + r \* z2 = (x1 + r \* x2, w1 + r \* w2)** ;
    
*   计算\*\*(Az) ○ (Bz)\*\* ;
    
*   现在\*\*(Az) ○ (Bz) =Cu(Cz) + E**为真，这意味着 w 是宽松 R1CS 实例**(x, u, E) 的有效见证人；\*\*
    
*   **然而， E**的大小与总计算的大小有关：也就是说，**E可能比x**大得多。所以，对于验证者来说，**E**太大而无法处理它。
    

**为了解决这个问题，可以使用承诺的宽松 R1CS：即使用对 E 的小承诺，comm(E)，而不是使用大的 E。它解决了问题，因为 E 取决于总计算的大小，对 E 的承诺则不然。**

为了构建一个\*\*致力于、\*\*轻松的 R1CS 折叠方案，我们有

*   R1CS 实例：R1CS 程序**A、B、C**和公共输入\*\*(x, u, comm(E))**，其中**comm(E)**是使用同态承诺方案完成的对**E\*\*的承诺；
    
*   公共输入\*\*(x1, u1, comm(E1))**和见证**(z1, E1, rE1)**，其中**rE**是用于**comm(E)\*\*的随机性；
    
*   公共输入\*\*(x2, u2, comm(E2))**和见证**(z2, E2, rE2)\*\*；
    
*   我们期望**z1**和**z2**都满足\*\*(Az) ○ (Bz) = u(Cz) + E\*\*，并且**comm(E)是使用**r表示**E1、E2、rE1**和**rE2对E**的承诺。
    

如果我们直接说（只是弃牌）：

*   **使用随机性r**的线性组合：(i) **x = x1 + r \* x2**，(ii) **u = u1 + r \* u2**，(iii) **comm(E) = comm(E1) + r \* comm(T) + r ^2 \* comm(E2)**（其中我们还使用对**T** **的**同态承诺，并具有一定的随机性**rT**）；
    
*   计算 (i) **z = z1 + r \* z2 = (x1 + r \* x2, w1 + r \* w2)** , (ii) **E = E1 + rT + r^2 \* E2** ,(iii) **rE = rE1 + r \* rT + r^2 \* rE2** ;
    
*   计算\*\*(Az) ○ (Bz)\*\* ;
    
*   **(Az) ○ (Bz) = u(Cz) + E**成立。
    

_要详细了解 (Az)_ **_○_** _(Bz) 计算，请查看_[_幻灯片_](https://zk-learning.org/assets/lecture10.pdf)_，要真正深入了解 Nova（以及完整性和知识可靠性的证明），请查看原始_[_Nova 论文_](https://eprint.iacr.org/2021/370.pdf)_。_

折叠首先在 Nova 中实现，这给 Nova 证明系统带来了巨大的优势。

**不同现代验证系统的比较**

![](https://storage.googleapis.com/papyrus_images/fcaa00d65096fa790b5ac479f7b28c6c8645b3185aa2594ff74082df701992d9.png)

### **折叠方案应用**

**使用承诺的宽松 R1CS 修改 IVC**

我们将函数**F**扩充为**F'**，添加检查以确保上一步的折叠是否正确完成。

粗略地说：Nova 递归开销比采用最先进（截至 2022 年 7 月）可信设置 SNARK 的基于 SNARK 的 IVC 低 10 倍，比不带可信设置的 SNARK 小 100 倍。

然而，这是一个交互式协议。为了使其成为非交互式的，可以使用 Fiat-Shamir。

*   证明者自己生成一个随机挑战。随机挑战是两个折叠实例的散列和对交叉项的承诺；
    
*   证明者还生成随机挑战已正确生成的证明；
    
*   但是，验证者没有证明者用于生成随机挑战的输入。它拥有的一切——折叠的最后结果。
    
*   这就是为什么证明者还应该证明（i）它为获取随机挑战生成的输入而进行的所有折叠（例如消息折叠、噪声参数折叠、交叉项折叠等）均已正确完成，（ii）折叠实例正确链接在一起，即步骤 i 的输出是步骤 i + 1 的输入；
    
*   这是通过将初始 R1CS 程序**A、B、C**增强为**A'、B'、C'来验证 (i) 证人对于正在折叠的实例的正确性以及 (ii) 折叠是否正确完成来完成的。该程序采用三个实例：x\_i、x\_1→i、x\_1→i+1**，并检查 (i) **x\_1→i+1是x\_i**和x\_1→i的正确折叠，并且 (ii) **x\_i**是有效实例；
    
*   事实上，它检查函数**F的计算是否正确，并且还在G**组中执行两次乘法（一次检查乘积**r \* x**和一次**r \* com(T)**）。在“正常”递归中，证明者需要 (i) 评估函数**F**和 (ii)**运行整个 SNARK 验证电路；**
    
*   **在 Nova 中，运行整个验证电路被G**组中的两次乘法+ 一些简单的散列代替（散列很便宜）。
    
*     
    

这比递归 SNARK 更快（约 10 倍）并且更便宜。我们只有 20k 约束——这很便宜！

此外，当用 Nova 生成证明时，证明的大小与递归计算的**一步**成正比。

**使用经过折叠方案修改的 IVC 的**一些用例

*   VDF – 可验证的延迟函数。对于 VDF，函数**F**是一些延迟函数，需要进行一些重要的顺序计算。例如，计算有限域内的立方根。
    
*   并行化（例如，不同实体之间或不同 CPU 之间或一个 CPU 中不同内核之间的分布式证明）。
    
*   图灵完备的 SNARK 语言（例如 Lurk）的后端，其中函数**F**执行程序的一个步骤。
    
*   Rollups，其中函数**F**是状态转换函数——它将之前的 Merkle Root 和一些交易作为输入，执行交易，并输出更新的 Merkle Root。
    

### **核心新星挑战**

*   证明的大小为**O(|C|)**，它线性取决于电路的大小。
    

Nova[实验](https://github.com/microsoft/Nova)由微软研究团队实施。

**3\. 桑格利亚汽酒——PLONKish 赛道的 Nova**
---------------------------------

好的，在 Nova 中，折叠方案是针对 R1CS 实例化的，但是其他约束系统呢？Sangria（由 Geometry 的 Nicolas Mohnblatt 建议）表明 Nova 的折叠方案可以应用于任何二次约束系统，特别是 PLONKish 电路。

对 PLONKish 电路应用折叠

*   Verifier工作在电路深度恒定；
    
*   常数比 Nova 更糟糕（这是更灵活算术化的代价）。
    

### **对 PLONK 进行简短、高层次的回顾：**

*   固定大小的网格；
    
*     
    

![](https://storage.googleapis.com/papyrus_images/97c91eafd6c53d890cb24c33212e14808a05686fd34763eee8b0a273e9a512eb.png)

*   单元格中充满了数字；
    

![](https://storage.googleapis.com/papyrus_images/2dcef357b91067ace407d3c0e6ea9398a524a2395a05fcdf250ea321874e9632.png)

*   我们需要遵循一套规则。该组规则包括（i）复制约束：具有相同颜色的单元格应具有相同的值；
    

![](https://storage.googleapis.com/papyrus_images/b3bd12f4ed63c41db0608e2525014b9ad11efc2e63f7d5760cec40f47ccbebe0.png)

(ii) 门方程：每一行i应满足以下方程：

![](https://storage.googleapis.com/papyrus_images/34d19c3bfbbd821ec611317f6ae6d0264358aeeb8360d8f7e5fec7a3d2d58939.png)

选择器和规则定义电路。一旦我们修复了选择器和规则，电路就修复了。

朴素随机线性组合应用：

*   保留复制约束（这可以从完美的完整性中通过代数推导出来，请查看[桑格利亚汽酒技术说明](https://github.com/geometryresearch/technical_notes/blob/main/sangria_folding_plonk.pdf)以了解更多详细信息）；
    
*   但由于非线性，门方程不成立。
    

为了解决这个问题，我们对门方程使用（如原始 Nova 中那样）松弛

*   见证**W = (w\_a, w\_b, w\_c)加噪声向量**e；
    
*   实例：公共输入**X = (x\_a, x\_b, x\_c)**、标量**u**和承诺**comm(w\_a)**、**comm(w\_b)**、**comm(w\_c)**、**comm(e)**。
    
*   松弛门方程——我们现在有一个齐次函数：
    

![](https://storage.googleapis.com/papyrus_images/5525185ac7679b7e09f922d8ec9584b1a585efe831f52708d755eb4419fc80ff.png)

**第一阶段：折叠**

*   **trace' + r \* trace'' = Final\_trace**（与上图完全相同）；
    
*   **u' + r \* u'' = u。**
    

![](https://storage.googleapis.com/papyrus_images/0944daecc193bdbd15c6d44e98297b25e324c1ac89a471611347928edb5695ba.png)

**第2阶段：将折叠结果代入松弛门方程**

*   **门(trace') + r \* t + r^2 \* 门(trace'') = 门(final\_trace)**
    

然而，**t相当大（如何在上面的等式中看到几行）因此有点难以操作，因此我们使用定义e**的技巧来使其更容易（并且只需摆脱**t**）：

*   **e' - r \* t + r^2 \* e'' = e。**
    

**协议**

*   Prover 计算交叉项**t**并提交给**t**；
    
*   Prover发送\*\*comm(t)\*\*给验证者；
    
*   验证者发送一些随机性；
    
*   证明者和验证者都进行线性组合： 证明者和验证者输出折叠实例：**X' + r \* X'' = X u' + r \* u'' = u com(w\_a) = com(w\_a') + r \* com(w\_a'') com(w\_b) = com(w\_b') + r \* com(w\_b'') com(w\_c) = com(w\_c') + + r \* com(w\_c'') com(e') - r \* com(t) + r^2 \* com(e'') = com(e)**
    

证明者输出折叠见证：**W' + r \* W'' = We e' - r \* t + r^2 \* e'' = e r\_a' + r \* r\_a'' = = r\_a r\_b' + r \* r\_b'' = r\_b r\_c' + r \* r\_c'' = r\_c r\_e' + r \* r\_t + r^2 \* r\_e'' = r\_e**

对于验证者来说，为了能够处理承诺，它应该使用加法同态承诺方案。

_有关 Relaxed PLONK 折叠方案的详细说明，请查看Geometry 或_[_Sangria Technical Note_](https://github.com/geometryresearch/technical_notes/blob/main/sangria_folding_plonk.pdf)_中 Nicolas Mohnblatt 的_[_这篇注释_](https://geometry.xyz/notebook/sangria-a-folding-scheme-for-plonk) _。_

**桑格利亚汽酒表演**

*   验证者对承诺进行四次添加（椭圆曲线点添加）；
    
*   事实上，我们可以通过提交额外的列来处理更宽的电路（这意味着每个门有超过两根线进入和超过一根线出来）。验证者需要对每个跟踪列执行一个额外的加点；
    
*   我们还可以处理更高级别的定制大门。每一个额外的学位都需要证明者的消息中包含一个额外的承诺，而验证者将为每个学位执行一个额外的加分。它还将改变我们处理噪声项的方式。d 级门将通过**u**至**u^d**的幂来放松。新噪声的折叠方程将是
    

![](https://storage.googleapis.com/papyrus_images/681cc6c79dac54a3959395a762b5df14684c6258008b4324b011d903302414f4.png)

Nova 电路中的 12k 约束（总共 20k 约束中）是最昂贵的点添加。所以问题是：更宽的电路和定制门的好处是否会超过额外加点的成本（验证者将强加的）？

**4\. SuperNova——广义Nova**
-------------------------

好的，在 Nova 中，一个函数**F**可以一次又一次地应用。但是如果每一步都有不同的功能怎么办？这就是 SuperNova 让我们能够做到的！

此外，虽然 Nova 证明的大小为**O(|C|)**，即与电路的大小线性相关，但在 SuperNova 中，证明程序步骤的成本仅与表示**所请求指令的电路大小成正比。**

SuperNova 是 Nova 对半结构化电路的推广。

SuperNova 的酷炫之处

*   每个步骤适用于_任何_可能的函数\*\*{F\_1、F\_2、F\_3 等…}\*\*；
    
*   证明生成_不必_遵循顺序路径（可以使用二叉树优化）。
    

SuperNova 下引入了**非均匀 IVC**（IVC 的泛化）。

我们有

*   **k + 1 个**非确定性函数**F\_1、F\_2、…、F\_k 的**集合，这些函数是编码不同指令的电路，以及一个特殊函数**φ**，可帮助选择要执行的指令之一（**φ**是选择器电路）；
    
*   初始输入**s\_0。**
    

目标是

*   证明**s\_n是应用电路C\_j** n 次的输出，其中在步骤**i**处，**j = φ(w\_i-1, s\_i-1)。**
    

![](https://storage.googleapis.com/papyrus_images/e5ea4be48c3cf1f37d80c9ae3c508307364cd70631badfc8a8d55b95f67d079d.png)

要深入了解 SuperNova，请查看原始[论文](https://eprint.iacr.org/2022/1758)。

将 SuperNova 与具有通用电路的递归 ZK-SNARK 和具有修剪电路的 ZK-SNARK 进行比较：

![](https://storage.googleapis.com/papyrus_images/3e7f53ee1fcafd65bfb47a0622e80fd904229501407a66b15804a5177c850149.png)

*   在修剪电路中，不使用通用电路，而是选择一个已执行的电路，因此，只需为执行的内容付费（而不是为整个电路执行付费）；
    
*   所谓开销，我们指的是见证人大小、公共 IO（交互式 Oracle）大小、约束数量、NP 检查器时间（NP 检查器查看见证人和约束系统并检查其是否可满足）、证明时间等的额外增长。
    
*   在上表中，递归开销是指在使用递归的情况下，某些原语效率不是很高。例如，必须使用 Merkle 树或基于多集的哈希函数的内存。两者都会导致每个内存操作至少有数百个约束。而对于非递归 SNARK，我们可以使用例如访问内存成本低得多的排列。然而，对于递归 SNARK，如果每条指令执行至少 10k 个门，则可以减轻这种递归开销。
    

Jules 的SuperNova 实验[实施。](https://github.com/jules/supernova)

**5\. HyperNova – 使用总和检查和可定制约束系统（CCS）进行折叠**
-------------------------------------------

我们将在下一章（HyperNova）的解释中使用和检查协议。为了保持同一页面，让我们简要描述一下总和检查是什么。

### **和检查协议的简要说明**

_非正式直觉：我们可以将求和协议视为一种工具，它将多个点的多项式评估转变为一个点的评估。_

形式直觉：

有关详细解释，请参阅 Justin Thaler 所著的《Proofs, Arguments, and Zero-Knowledge》一书，第 4.1 节“The Sum-Check Protocol”。

*   **验证者可以通过预言机访问字段F**上的k 变量多项式**g**；
    
*   **验证者的目标是计算k 个**变量\*\*\[b\_1, …, b\_k\]**上多项式**g\*\*评估的总和；
    
*   天真地，验证者只需向预言机询问**b**的每个值的多项式**g**评估，然后将结果相加即可。需要**2^k次**预言机评估和**2^k**次字段添加；
    

![](https://storage.googleapis.com/papyrus_images/24e39674a78ba59e65684d4155b29bad346166e79307059994ffce403c3860c1.png)

*   使用和校验协议，验证者将大部分工作委托给证明者，而**验证者本身只检查 k 个证明者消息，然后在最后进行 1 g 多项式评估（oracle 查询）；**
    
*   在阶段 0，证明者发送验证者声明的答案**c\_1**。总和检查协议必须检查
    

![](https://storage.googleapis.com/papyrus_images/2c6c8b9e109b24a0756d052487028831d0498fbc17d0d95a6f3b81b74b90eefd.png)

*   在下一轮中，证明者向验证者发送一个单变量多项式。例如，在第一轮中，证明者向验证者发送多项式**s\_1(x\_1)**，该多项式等于
    

![](https://storage.googleapis.com/papyrus_images/5bb4ab79801d8c41a664fbab749728ae0901aa660417238a3b3fa34dd42ac7f3.png)

为了指定多项式，证明者发送 3-4 个系数（3-4 个字段元素）；

*   验证者想要检查是否确实 (i) **s\_1(x\_1) = H\_1(x\_1) ，(ii) 它与真实答案c\_1**（在 0 阶段发送）一致。因此，验证者在随机点**r\_1**处检查(i) **c\_1 = s\_1(0) + s\_1(1)**、(ii) **s\_1 = H\_1**。\*\*s\_1(r\_1)\*\*可以直接从证明者的第一条消息计算，但_不能从_H\_1 \*\*(r\_1)\*\*计算；
    
*   验证者需要检查
    

![](https://storage.googleapis.com/papyrus_images/0ba4b16bfc15f194d150a70b646e13530980a7ea99905e7f9a1247198b2e5cd9.png)

为了计算它，证明者和验证者可以递归地应用和校验协议并通过该协议逐轮进行。在每一轮中， g 的另一个变量绑定到随机选择的元素**r\_1**。他们一轮又一轮地这样做，直到在第**k**轮中 g 的最终变量绑定到随机元素**r\_k**；

*   在第 k 轮中，证明者发送声称等于**H\_k = g(r\_1, …, r\_k) 的单变量多项式s\_k(x\_k)**；
    
*   验证者检查**s\_k-1(r\_k-1) = s\_k(0) + s\_k(1)**；
    
*   然后，验证者需要检查的最终语句是**s\_k(r\_k) = g(r\_1, …, r\_k)**。此检查需要验证者执行一次 oracle 查询（可以自行执行）。
    

### **CCS**

**CCS**是一个约束系统，它在没有开销的情况下概括了 Plonkish、R1CS 和 AIR。

最初为 R1CS 描述的 SNARK 很容易扩展到 CCS（因此是 PLONKish）：

*   斯巴达 (R1CS) → 超级斯巴达 (CCS)
    
*   马林鱼 (R1CS) → 超级马林鱼 (CCS)
    

然而，最初为 PLONKish（Plonk、HyperPlonk 等）描述的 SNARK 无法在没有开销的情况下处理 CCS（甚至 R1CS）。高层原因是CCS和R1CS都具有线性组合，而PLONKish证明系统受到有限且特定类型的线性约束的限制。

**CCS说明**

*   为了指定电路，CCS 有**t 个**矩阵**M\_1, M\_2, …, M\_t**；
    
*   为了允许自定义约束，它有**q**个多重集**S\_1, S\_2, …, S\_q**；
    
*   公共输入：**x**；
    
*   证人**W**使得**Z = (W, x, 1)。**
    

如果 Hadamard 乘积之和为零，则电路满足，即

![](https://storage.googleapis.com/papyrus_images/dca04c5b203dfaf6a2aa4eefdd4b1eec9ea6e0a704649a8bc246ea33323eedf0.png)

可以说 R1CS 是 CCS 的一种特例，其中

*   电路说明：**M\_1=A，M\_2=B，M\_3=-C；**
    
*   **S\_1 = {1, 2}, S\_2 = {3};**
    
*   公共输入：**x；**
    
*   证人 W 使得**Z = (W, x, 1)；**
    
*   **Az ○ Bz = Cz。**
    

### **承诺CCS (CCCS)**

要将两个 CCS 合二为一，我们将使用 CCCS（承诺 CCS），其中 C = comm(w)也在实例中。

然而，如果我们尝试进行 Nova 式松弛，交叉项的数量将与约束的程度成正比。这效率不高。

因此，我们可以将其中一个 CCCS 线性化以获得 LCCCS，而不是折叠两个 CCCS。然后折叠 CCCS x LCCCS → LCCCS（结果也将是线性化的 CCCS）。

线性 CCCS 意味着约束是线性的，因此多重集的大小为 1。这足以构建 IVC，但不是 NP 完全的。

### **线性化承诺 CCS (LCCCS)**

**CCS 包括**

*   **t 个**矩阵**M\_1, M\_2, …, M\_t**；
    
*   **q**多重集**S\_1, S\_2, …, S\_q**；
    
*   公共输入：**x**；
    
*   承诺**C = comm(W)**；
    
*   标量**u** ;
    
*   随机挑战**r** ;
    
*   压缩矩阵所有行的标量\*\*(v\_1, v\_2, …, v\_t) ：\*\*
    

![](https://storage.googleapis.com/papyrus_images/bb776ee3eeba9bdf2498006883bc63481968a771bf08801f2efe4b7d90afd11c.png)

*   见证向量**W**使得**Z = (W, x, u)**。
    

**高级 CCS 折叠图**

![](https://storage.googleapis.com/papyrus_images/51432c60322a97f07b22e5b3dba5c9622837c4104e53a3b44caa8907731f2935.png)

**步骤 1：CCCS x LCCCS → LCCCS** **折叠：使用一次和校验协议调用，通过相同的随机挑战将 CCCS 简化为 LCCCS**

*   这是一个交互协议；
    
*   两个折叠实例应具有相同的结构：相同的矩阵 M和多重集 S；
    
*   验证器以 LCCCS ( **C', u', x', r', v\_1', …, v\_t') 和 CCCS (C'', x'')开始，进行线性组合，并输出两个 LCCCS，**(C', u', x', r, σ\_1', …, σ\_t')和\*\*(C', u', x', r, θ\_1', …, θ\_t')**具有**相同的随机挑战 r；\*\*
    
*   验证器输入和输出**W'、** **W''**。
    

**步骤 2：** **对于 LCCCS x LCCCS → LCCCS** **折叠** **– 所有检查都是线性约束**

*   验证者向证明者发送随机挑战**γ （随机挑战对于所有i**都是相同的）；
    
*   证明者采用**W', W''**，进行线性组合_W' + γ \* W'' = W_并输出**W**；
    
*   验证者采用\*\*(C', u', x', r, v\_1', …, v\_t')\*\* , **(C'', u'', x'', r, v\_1'', ..., v\_t'')并使得线性组合_C' + γ \* C'' = C u_ ' + _γ \* u'' = u_ x' + _γ \* x'' = x v\_i'_ + _γ \* v\_i'' = v\_i_并输出**(C, u, x , r, v\_1, …, v\_t)。
    

\*\*\[ _(C, u, x, r, v\_1, …, v\_t), W_ \]\*\*的正确性通过线性保持：

![](https://storage.googleapis.com/papyrus_images/a1981f3644e6238f37ce23bd2747debf31ed79aa3fe1981a00ec979f376245a9.png)

### **超新星**

**HyperNova**是一种证明者高效且递归的 ZK-SNARK，用于证明增量计算，其中每个步骤都用提交的 CCS 表示。

HyperNova 使用 SuperSpartan 的早期版本为可定制约束构建新的折叠方案。关键思想是设计一个多项式，对有关高度约束的声明以及一些先前的声明进行编码。当总和检查应用于该多项式时，所得到的权利要求采用适合折叠的形式，而不需要任何交叉项。

HyperNova 可以通过两种方式构建：(i) 直接方法：直接构建在 CCS 的非交互式多重折叠方案上，(ii) 另一种方法将多重折叠方案与 Nova 结合使用作为黑匣子。

有关 HyperNova 协议的详细描述，请查看原始[论文](https://eprint.iacr.org/2023/573)。

**超新星成本**

*   证明者成本：1 MSM 提交见证+1 总和检查；
    
*   验证者成本（递归电路）：1 个标量乘法 + 对数个哈希值
    

HyperNova由[arnaucube](https://twitter.com/arnaucube)和[asn实验性](https://twitter.com/asn_d6)[实现](https://twitter.com/asn_d6/status/1667238765650124811?s=46&t=CYJXAP9_pltHaKRPUPc3jw)。

**nlookup：Nova 的**[**查找参数**](https://medium.com/@ingonyama/a-brief-history-of-lookup-arguments-a4eeeeca2749)

假设有一个大小为**n的表T**。考虑CCS 实例中的m 个变量**v\_1, …, v\_m ，我们希望强制这些值包含在T**中。

*   **查找：将T**存储为 Merkle 树，电路将其作为公共输入获取承诺。**然后，为了证明T**中存在某个值，证明者可以向电路提供 Merkle 包含证明作为非确定性建议，并且电路验证 Merkle 包含证明。它需要电路内部进行**O(m \* log(n)) 次哈希计算。**
    
*   p **Lookup**：约束数量为**O(max(m, n))，如果**n ≈ m则有效，但不适用于递归，其中特定递归步骤可能执行**m << n**查找操作；
    
*   **nlookup**：对于大小为**n个条目的表的m**次查找，nlookup 需要\*\*O(m \* log(n))**乘法和电路内的**O(log(n))哈希运算（具有小常数），并且证明者执行O( n)\*\*有限域运算。特别是，证明者不承诺任何额外的多项式。这是使用 Nova 和 HyperNova 高效表达有限状态机的完美工具。有关 nlookup 的详细描述，请查看[HyperNova 论文](https://eprint.iacr.org/2023/573.pdf)的第 7 节。
    

**6\. ProtoStar – Nova（和 Sangria）保效率泛化**
========================================

ProtoStar IVC 结合了高效折叠方案的通用方法和用于表达关系的简单特殊声音协议\*，允许递归电路支持（i）高阶门，（ii）任意大的查找表，（iii）任意多个操作码在只有 3 个组操作的 VM 中。

_免责声明：堆积和折叠是指底层类似的技术。由于不同作者大致在同一时间探讨相似现象的不同论文，出现了定义差异。_

*   ProtoStar 的目标大致上与 HyperNova 的目标类似：与 Nova（及其泛化 - Sangria）一样，证明者复杂性和递归电路大小都与门的程度成正比，ProtoStar和 HyperNova 的目标是将其最小化（理想情况下，使其成为常数）。然而，与 HyperNova 不同的是，在 ProtoStar 中，(i) 支持查找的开销几乎可以忽略不计，(ii) 不需要和检查协议。
    

![](https://storage.googleapis.com/papyrus_images/9119e2815b6a7b49079b5a65968b176afefab98db2abb4064a29073fe503d284.png)

_图表来源：ProtoStar_[_论文_](https://eprint.iacr.org/2023/620.pdf)_。_

*   编译器仅需要向量承诺，因此不需要可信设置、配对或 FFT。
    
*   每个累积/IVC 步骤中的证明者在支持的电路数量上是对数的，并且与查找中的表大小无关（与Nova 的 d \* log(n) 相比）。
    
*   查找效率更高，因为使用对数导数参数而不是乘积参数。因此，可以在许多地方放置零系数。递归电路由3组标量乘法和d个字段元素的散列主导，其中d是最高门的度数；
    
*   无需额外的 MSM 成本即可实现高阶门。无需使用多个门，而是可以将它们与随机元素 b（验证者挑战）的幂相加，最终只有一个 d+1 级的门。d+1 次的门可以处理，因为它只是一个多项式（更多细节请查看“通用 ProtoStar 折叠方法”（下一节）的第四步）。然而，我们仍然需要 d 个交叉项，但是我们可以使用字段元素作为一维向量的简单承诺方案，而不是使用承诺。这些交叉项的处理成本要低得多；
    
*   在验证器电路尺寸方面，ProtoStar 比 HyperNova 做得更好：如果发生非本地现场操作，在没有查找支持的情况下，必要的非本地现场操作模拟可能会相当昂贵。Protostar 具有廉价的查找支持（ProtoStar 中的 O(d) 与 HyperNova 中的 O(d\*log(N)），因此非本地字段运算电路可以更高效。但是，如果使用 SNARK 友好的哈希函数，则差异微不足道。
    
*   ProtoStar 中的技术可以推广到 PCD（Proof-Carrying Data），即不仅可以证明计算链，还可以在不牺牲效率的情况下证明计算的整个树/ [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph)（有向无环图）。
    
*   它支持高效的电路分支。也就是说，电路始终与整组操作码成比例。也就是说，创建具有多个分支的电路，这些分支（i）由选择器打开和关闭，以及（ii）以“关闭”分支的方式组织，在证明过程中不会花费任何成本；
    
*   它可以与[Wilson](https://twitter.com/mercysjest)最近提出的 IVC 编译器一起使用，以进一步提高效率。
    

### **ProtoStar 折叠通用配方**

![](https://storage.googleapis.com/papyrus_images/2bed86a6379d7e508ded716130e656af1c31cec76205aa03396b58ee05480a58.png)

### **1.为关系R建立多轮特殊声音协议\* Π。**

\***关于特殊声音协议的旁注**

与IVC相比，特殊声音协议更容易构造，因为它\*\*（i）\*\* **不需要简洁，（ii）可以交互，（iii）可以表示复杂的关系（例如，查找关系）**。

k-special-sound协议可以从k轮通信中提取有效的见证。

考虑 1-special-sound 协议的示例：

![](https://storage.googleapis.com/papyrus_images/1fb07d04ec3b4333bc8bbb7f3e45817f2053a4b45c116716fd7bb8def2953167.png)

_资料来源： PSE与 Binyi Chen 举办的“深入研究 Protostar 论文和协议”_[_研讨会_](https://www.youtube.com/watch?v=tt00TLFJPpc)

### **2\. 使用关系R的_压缩验证器_将协议Π转换为另一个交互协议CV\[Π\] 。**

![](https://storage.googleapis.com/papyrus_images/693a626b5807e2d89707ad9c34e303c82ad4f31918c6dc9cf304b810e0a8355b.png)

### **3.使用 Fiat-Shamir将此协议转换为非交互式参数NARK(CV\[Π\]) 。**

### **4\. 构建 NARK(CV\[Π\]) 验证者检查的折叠方案。**

*   我们有两张支票，一张证明支票和一张折叠支票，我们很乐意将它们折叠成一张支票；
    
*   证明者的实例 x 包括承诺 C、随机挑战 r 和 u = 1。折叠的实例 x 包括承诺 C、随机挑战 r、松弛 u 和噪声向量 E；
    
*   证明者和折叠的见证人 w 包括证明者消息 m；
    
*   累积校验是验证者计算的齐次方程，而证明者的NARK校验有0到d不同度数的元素，其中d是每次校验的最大度数。
    
*   目标是将两项检查合并为一个方程式。我们可以使用多项式插值来做到这一点：
    

![](https://storage.googleapis.com/papyrus_images/147e7ff9c8b8535d871d7242a6e0cbe8877bd9aae51c7f5713664fc6c8901f44.png)

然而，在这种方法下，许多组操作取决于每个检查 d 的最大度。我们希望他们独立。

*   压缩验证检查：使用随机线性组合将多个验证检查 L 压缩为一个约束。然而，这种检查的程度最终要大得多，d+L。此外，支票中的条款不再是同质的。所以，折叠不能再应用了。
    
*   为了解决同质性问题，验证者可以用另一个变量替换所有系数，而不是使用一些不同程度的系数，这样检查程度将为 d+1 并且检查将是同质的。证明者最后将发送一个具有不同幂次的初始系数的数组。然而，在这种技术下，验证者需要检查所有这些初始系数。因此，O(l^1/2) 额外的组操作被添加到证明者工作中，并且 O(l^1/2) deg-2 正确性检查被添加到验证者工作中，其中 l 是初始验证者检查的数量。
    

**遵循ProtoStar累积/折叠方案，Group操作的数量与验证者检查的程度无关。**

有关 ProtoStar 的详细描述，请查看原始[论文](https://eprint.iacr.org/2023/620.pdf)。

### **其他令人兴奋的、使用折叠的相关内容未在本文中介绍，以供进一步探索：**

*   [Origami](https://hackmd.io/@aardvark/rkHqa3NZ2) – 一种用于 Halo2 查找参数的显式折叠方案，作者：[Yan Zhu](https://twitter.com/krzhang)和[aardvark](https://twitter.com/aard_k_vark)；
    
*   [ParaNova –](https://zkresear.ch/t/towards-a-nova-based-zk-vm/105#parallelizing-nova-11) [oskarth](https://twitter.com/oskarth)并行化 Nova ；
    
*   [MoonMoon – 通过使用](https://zkresear.ch/t/folding-endgame/106)[Lev Soukhanov](https://twitter.com/levs57)的 RSA 组中的 Pedersen 承诺，向 Nova 添加排列参数并在整数系数上使用 Nova ；
    
*   ProtoGalaxy – 高效的 ProtoStar 式的多个实例折叠：[Liam](https://twitter.com/arnaucube) Eagen 和[Ariel Gabizon的](https://twitter.com/rel_zeta_tech)[论文](https://twitter.com/rel_zeta_tech/status/1680898330669268995?s=20)以及arnaucube的概念验证[实现](https://github.com/arnaucube/protogalaxy-poc)；
    
*   [David Wong](https://twitter.com/cryptodavidw)的一篇 Nova 攻击解释[文章](https://www.zksecurity.xyz/blog/posts/nova-attack/)《当年的零知识攻击可能刚刚发生，或者 Nova 是如何被攻破的》。
    

### **结论以及下一步是什么？**

因此，HyperNova 和 ProtoStar 可能不是最终游戏。现有 zk 协议的折叠实现仍处于早期阶段，并且正在进行中。要跟踪折叠实现的进展情况，请检查 lurk lab 的[github 存储库](https://github.com/lurk-lab/awesome-folding)，该存储库汇总了所有折叠新闻，包括新鲜出炉的实现。Folding 和所有这些很棒的 Nova 都是由微软研究院的 Srinath Setty 推出的，请关注[他的 Twitter](https://twitter.com/srinathtv)，了解接下来会发生什么。Zeroknowledge.fm （查看其 zkStudyClub）和EF 的[PSE小组（查看其](https://appliedzkp.org/)[YouTube](https://www.youtube.com/@privacyscalingexplorations/streams)并关注其即将推出的研究活动）正在进行有关折叠及其实现的大量教育工作[。](https://www.youtube.com/@zeroknowledgefm)[不和谐服务器](https://discord.com/invite/sF5CT5rzrR)）。

资料来源：

*   “递归 zkSNARKs：探索新领域”[文章](https://0xparc.org/blog/groth16-recursion)，作者：0xPARC
    
*   “ZKP MOOC 讲座 10：递归 SNARKs”[讲座](https://www.youtube.com/watch?v=0LW-qeVe6QI)和[幻灯片](https://cs251.stanford.edu/lectures/lecture18.pdf)，作者：Dan Boneh
    
*   “Nova：折叠方案中的递归零知识论证”[论文](https://eprint.iacr.org/2021/370.pdf)，作者：Abhiram Kothapalli、Srinath Setty、Ioanna Tzialla
    
*   “模块十四：Nova 速成课程”与 Justin Drake 的ZK 白板[课程，作者：](https://www.youtube.com/watch?v=SwonTtOQzAk&t=8s) [zeroknowledge.fm](http://zeroknowledge.fm/)
    
*   [Twitter 帖子](https://twitter.com/0xevevm/status/1654146098024333312?s=46&t=feUQea47p71EZHYQVTPEqw)总结了 IVC 和折叠方案的关键见解，作者：@0xevvm
    
*   “Nova：来自折叠方案的递归零知识论证”[讲座](https://www.youtube.com/watch?v=mY-LWXKsBLc&t=1s)，由 Protocol Labs 与 Srinath Setty 共同主持
    
*   Srinath Setty 的“超新星”[讲座，作者：](https://www.youtube.com/watch?v=ilrvqajkrYY&list=PLj80z0cJm8QHm_9BdZ1BqcGbgE-BEn-3Y) [zeroknowledge.fm](http://zeroknowledge.fm/)
    
*   “SuperNova：证明无需通用电路的通用机器执行”[论文](https://eprint.iacr.org/2022/1758)，作者：Abhiram Kothapalli、Srinath Setty
    
*   PSE 小组与 Srinath Setty 进行的“CCS 和 HyperNova - 折叠方案 FTW”[讲座](https://www.youtube.com/watch?v=pDFmANwwIoY)
    
*   “HyperNova：可定制约束系统的递归参数”[论文](https://eprint.iacr.org/2023/573)，作者：Abhiram Kothapalli、Srinath Setty
    
*   Benedikt Bünz 介绍 ProtoStar 的[Twitter](https://twitter.com/benediktbuenz/status/1653067349023682560?s=46)帖子
    
*   “Protostar: Generic Efficient Accumulation/Folding for Special-sound Protocols”[论文](https://eprint.iacr.org/2023/620.pdf)，作者：Benedikt Bünz、Binyi Chen
    
*   levochka.eth 总结 ProtoStar 的[Twitter](https://twitter.com/levs57/status/1662566279683743746)帖子
    
*   [Zeroknowledge.fm](http://zeroknowledge.fm/) [播客](https://zeroknowledge.fm/280-2/)，第 280 集：Benedikt Bünz和 Binyi Chen 的 ProtoStar。
    
*   [PSE 与 Binyi Chen 举办的](https://www.youtube.com/watch?v=tt00TLFJPpc)“深入研究 Protostar 论文和协议”研讨会。
    

### **加入我们💗**

探索我们的[招聘网站](https://taikoxyz.notion.site/Taiko-Jobs-828fd7232d2c4150a11e10c8baa910a2)上的空缺职位。

### **关注我们🥁**

从 Taiko 获取最新信息：

*   网站：https:  [//taiko.xyz](https://taiko.xyz/)。
    
*   不和谐：  https: [//discord.gg/taikoxyz](https://discord.gg/taikoxyz)。
    
*   GitHub：  https: [//github.com/taikoxyz](https://github.com/taikoxyz)。
    
*   推特：https:  [//twitter.com/taikoxyz](https://twitter.com/taikoxyz)。
    
*   社区论坛：[https](https://community.taiko.xyz/) ://community.tai​​ko.xyz 。
    

### **贡献🤓**

在 GitHub 上为 Taiko 做出贡献并获得 GitPOAP！您还将成为我们自述文件的贡献者。开始使用[贡献手册](https://taiko.xyz/docs/manuals/contributing-manual)。

---

*Originally published on [fen yun](https://paragraph.com/@11qqq/nova-sangria-supernova-hypernova-protostar)*