MIT-6-5630-密码学高级笔记-全-

MIT 6.5630 密码学高级笔记（全）

001：交互式证明与和校验协议（第一部分）

概述

在本节课中，我们将要学习密码学与理论计算机科学中的一个核心概念：交互式证明系统。我们将从经典的NP证明概念出发，探讨如何通过引入随机性和交互性来构建更强大的证明系统。我们将重点介绍一个极其重要的协议——和校验协议，并分析其工作原理与性质。

从NP到交互式证明

上一节我们介绍了课程的整体框架。本节中，我们来看看证明系统的基础模型。

在计算机科学中，NP类刻画了所有那些“存在一个简短证明，并且该证明能被多项式时间验证器高效验证”的语言。具体来说，NP是所有满足以下条件的语言集合：存在一个多项式时间验证器V，对于语言L中的任意输入x，都存在一个“见证”w（即证明），使得V(x, w)接受。

然而，NP的表达能力是有限的。为了获得更强大的证明系统，我们需要引入两个关键的新特性：交互性和随机性。

  • 交互性：证明者（Prover）和验证者（Verifier）可以进行多轮对话，而不仅仅是证明者向验证者发送一个静态的证明。
  • 随机性：验证者可以使用随机硬币（Random Coins），其决策可以基于概率。

这两点共同定义了交互式证明（Interactive Proof， IP）。如果验证者是确定性的，那么证明者可以预先计算出整个对话过程并作为静态证明发送，这就退化成了NP。因此，随机性是交互式证明力量的关键来源之一。

随机性的力量：一个例子

在深入交互式证明的形式化定义之前，我们先看一个例子，展示仅使用随机性（无需交互）如何帮助我们更高效地验证计算。

假设我们想验证三个n×n矩阵A, B, C是否满足 C = A × B。直接计算矩阵乘法需要O(n^ω)时间（ω ≈ 2.373）。但是，我们可以设计一个随机化的验证算法，其运行时间仅为O(n²)。

以下是该随机化算法：

  1. 验证者随机选择一个向量 r ∈ 𝔽ⁿ（𝔽是一个足够大的有限域）。
  2. 验证者计算 A × (B × r) 和 C × r。
  3. 验证者检查 A × (B × r) == C × r 是否成立。如果成立则接受，否则拒绝。

这个算法的核心思想是：将矩阵相等问题转化为向量相等问题。如果C确实等于A×B，那么对于任何r，等式都成立（完备性）。如果C不等于A×B，那么根据Schwartz-Zippel引理（或其单变量特例），对于随机选择的r，等式成立的概率最多是 1/|𝔽|（可靠性）。通过选择足够大的域，我们可以使错误概率任意小。

这个例子属于MA（Merlin-Arthur）证明系统模型，即证明者发送一个证明，验证者进行随机化验证。我们尚不清楚MA是否真比NP更强大，但这个例子展示了随机性在验证中的潜在效用。

交互式证明的形式化定义

现在，我们正式定义交互式证明系统。

一个针对语言L的交互式证明系统，包含一个计算能力无限（或至少非常强大）的证明者P，和一个概率多项式时间的验证者V。它们进行多轮交互，最终验证者输出“接受”或“拒绝”。

该系统必须满足以下两个性质：

  1. 完备性（Completeness）：如果陈述为真（x ∈ L），那么诚实的证明者P能以至少c的概率说服验证者V接受。通常c接近1（例如2/3）。

    • Pr[〈P, V〉(x) = 接受] ≥ c

  2. 可靠性/健全性（Soundness）：如果陈述为假（x ∉ L），那么任何（计算能力无限的）欺骗性证明者P*，最多只能以至多s的概率说服验证者V接受。通常s接近0（例如1/3）。

    • Pr[〈P*, V〉(x) = 接受] ≤ s

这里的概率空间是验证者的随机硬币。常数c和s的典型选择是2/3和1/3。通过独立重复运行协议多次并采用多数决，我们可以将完备性概率放大到接近1，同时将可靠性误差降低到接近0（例如2^{-k}）。

和校验协议：一个核心的交互式证明

交互式证明到底有多强大？一个里程碑式的结果（Shamir, 1992）表明，IP = PSPACE，即交互式证明可以验证所有多项式空间可计算的语言。这被认为远比NP类更强大。

为了理解其威力，我们学习一个基础性的协议——和校验协议（Sum-Check Protocol）。这个协议是构建许多高级证明系统的基石。

问题描述

假设存在一个定义在有限域𝔽上的m变量多项式g，每个变量的度数最高为d。验证者V拥有对g的预言机访问（即可以请求计算g在任意点的值）。证明者P想要向V证明以下求和等式的值：
∑_{(h₁, ..., hₘ) ∈ Hᵐ} g(h₁, ..., hₘ) = β
其中H是𝔽的一个子集（例如{0, 1}），β是𝔽中的一个声称的和值。

直接计算这个求和需要O(|H|ᵐ)次求值，当m很大时这是不可行的。和校验协议提供了一个高效的交互式证明方法。

协议过程

协议通过m轮交互，逐步“剥离”求和中的每一个变量。

  1. 第1轮：
    • 证明者P发送一个单变量多项式s₁(X₁)，声称它等于：
      s₁(X₁) = ∑_{(h₂, ..., hₘ) ∈ Hᵐ⁻¹} g(X₁, h₂, ..., hₘ)
    • 验证者V检查：
      • s₁(X₁)的次数是否≤ d。
      • ∑_{h₁ ∈ H} s₁(h₁) == β 是否成立。
        如果任何检查失败，V立即拒绝。

  1. 第2到m轮（归纳步骤）：

    • 假设前i-1轮中，V随机选择了值r₁, ..., r_{i-1} ∈ 𝔽。
    • 在第i轮，P发送一个单变量多项式sᵢ(Xᵢ)，声称它等于：
      sᵢ(Xᵢ) = ∑_{(h_{i+1}, ..., hₘ) ∈ Hᵐ⁻ⁱ} g(r₁, ..., r_{i-1}, Xᵢ, h_{i+1}, ..., hₘ)
    • 验证者V检查：
      • sᵢ(Xᵢ)的次数是否≤ d。
      • ∑_{hᵢ ∈ H} sᵢ(hᵢ) == s_{i-1}(r_{i-1}) 是否成立。
        如果任何检查失败，V立即拒绝。
    • 如果检查通过，V随机选择一个值 rᵢ ∈ 𝔽，并发送给P。

  2. 最终验证：

    • 在第m轮之后，V随机选择了r₁, ..., rₘ。
    • V使用其对g的预言机访问，直接计算 g(r₁, ..., rₘ) 的值。
    • V检查 g(r₁, ..., rₘ) == sₘ(rₘ) 是否成立。如果成立则接受，否则拒绝。

协议分析

以下是该协议的关键参数：

  • 轮数：m轮。
  • 通信复杂度：O(m * d)个域元素（因为每轮发送一个d次多项式）。
  • 验证者时间复杂度：O(m * d * |H|)次域操作（主要用于计算多项式在H上的求和），加上一次最终的g求值。
  • 证明者时间复杂度：大致需要O(|H|ᵐ)次运算来计算所有必要的中间求和（这是问题的固有难度）。

完备性：如果初始求和确实等于β，且证明者诚实地执行协议，那么所有检查都会通过，验证者以概率1接受。

可靠性：如果初始求和不等于β，那么任何欺骗性的证明者P必须至少在某一轮“撒谎”。假设在第i轮，P发送的多项式sᵢ不是正确的多项式。当验证者随机选择rᵢ时，sᵢ(rᵢ)等于正确值的概率，最多是d / |𝔽|（根据Schwartz-Zippel引理，两个不同的d次多项式在随机点上相等的概率）。通过在所有m轮上应用联合界，整个协议被欺骗成功的概率上界为 m * d / |𝔽|。通过选择足够大的域𝔽，我们可以使这个错误概率任意小。

为什么多项式如此重要？

你可能会问，为什么这个协议（以及许多高级证明系统）都围绕多项式展开？原因有二：

  1. 纠错能力：低次多项式具有强大的纠错/唯一解码特性。两个不同的d次多项式在大多数点上值都不同（仅在至多d个点上可能相同）。这使得验证者可以通过在随机点上抽查来高效地检测证明者的欺骗行为。
  2. 表达能力：通过一种称为低次扩展（Low-Degree Extension, LDE） 的技术，我们可以将许多计算问题（如布尔电路执行轨迹）编码为低次多项式。这样一来，关于计算正确性的复杂声明，就可以转化为关于多项式求和的声明，进而应用和校验协议。

总结

本节课中我们一起学习了交互式证明系统的基本概念。我们从经典的NP证明出发，引入了交互性和随机性，定义了交互式证明（IP），并了解了其潜在威力（IP = PSPACE）。随后，我们深入探讨了密码学和证明系统中一个里程碑式的协议——和校验协议。我们详细描述了该协议如何通过多轮交互，让验证者高效地验证一个关于多变量多项式在大集合上求和的声明，并分析了其完备性、可靠性以及复杂度。和校验协议是构建众多现代简洁证明系统的核心组件，在后续课程中，我们将看到它如何被应用于构造更复杂的协议，并最终与密码学工具结合，实现非常简洁的非交互式证明。

002：交互式证明与和校验协议（第二部分）

在本节课中，我们将继续深入探讨交互式证明系统，并学习和校验协议的具体应用。我们将看到如何利用和校验协议为复杂问题（如#SAT和三角形计数）构建高效的交互式证明，并引入“双重高效”证明的概念。

上一节我们介绍了和校验协议的基本框架，本节中我们来看看该协议的一些关键性质及其应用。

和校验协议的性质

和校验协议具有一个非常实用的性质：它是一个公开掷币协议。

  • 公开掷币协议：在这种协议中，验证者的消息是公开的、真正随机的。在每一轮中，验证者选择随机数（例如，长度为 log |F| 的比特串），并将其公开发送给证明者。这些随机数定义了域中的一个元素。
  • 重要性：公开掷币协议非常有用，因为在本课程后续内容中，我们将看到如何利用密码学来消除这种交互。验证者消息的完全随机性将在此发挥关键作用。

随机性的作用

在交互式证明中，随机性的分配至关重要。

  • 验证者需要随机性：验证者必须使用随机性来防止证明者作弊。如果证明者提前知道验证者将要查询的点（例如，变量 r1），他就可以精心构造一个假的多项式，使其在该点上的值与真实多项式一致，从而通过验证。验证者的随机性正是用来对抗这种恶意行为的。
  • 证明者通常不需要随机性：对于证明者而言，随机性通常没有帮助。因为我们可以固定证明者的最佳策略（将其视为一个非均匀的电路），而验证者是诚实的，其行为不会改变。因此，证明者可以被视为确定性的。

和校验协议为何可靠？——一个几何解释

我们可以从几何角度理解和校验协议为何是可靠的。

想象一个M维的小立方体 H^M，证明者声称某个低次多项式在这个立方体上所有点的求和值是 β。如果证明者作弊（即求和值不正确），那么在第一个维度 H1 的某个点上，他给出的部分和 g1 必定是错误的。
验证者随机选择一个点 r1 进行查询。由于 g1 是错误的，而真实多项式是低次的，根据施瓦茨-齐佩尔引理，g1(r1) 与真实部分和在 r1 处的值相等的概率很低。
此时，问题被约化为在剩下的 M-1 个维度上，证明关于 r1 的部分和是否正确。我们重复这个过程，逐维深入，直到最终在随机点 (r1, r2, ..., rM) 上检查单个点的值。通过这种“层层深入”的方式，验证者能以高概率发现证明者的任何欺骗行为。

上一节我们介绍了和校验协议及其原理，本节中我们来看看它的一个经典应用：为#SAT问题构建交互式证明。

应用示例：#SAT问题的交互式证明

SAT是一个计算布尔公式满足赋值数量的难题。我们将展示如何利用和校验协议为#SAT构建一个交互式证明系统。核心思想是算术化。

问题定义

给定一个布尔公式 φ（可以视为二叉树，其中叶子节点是变量或其否定，内部节点是AND或OR门），#SAT问题是计算有多少个对 n 个变量的 {0,1} 赋值能使 φ 输出1。

算术化

为了应用和校验协议，我们需要将布尔公式 φ 转化为一个定义在有限域 F 上的多项式 f̃。转换规则如下：

  1. AND门：AND(x, y) 转换为乘法 x * y。
  2. OR门：OR(x, y) 转换为 x + y - x*y。
  3. NOT门：NOT(x) 转换为 1 - x。

在 {0,1} 取值上，这些算术运算与原始布尔运算完全一致。因此，对于所有 x ∈ {0,1}^n，有 f̃(x) = φ(x)。

转化为和校验问题

现在，证明 φ 恰好有 K 个满足赋值，等价于证明以下求和等式：
∑_{x ∈ {0,1}^n} f̃(x) = K
这正是和校验协议可以处理的形式！变量数 m = n。

关键：多项式的次数

我们需要确保多项式 f̃ 的次数 d 不会太大，以保证验证者高效运行。
断言：对于公式 φ，其算术化版本 f̃ 中，所有变量的次数之和至多为公式的大小 S（即叶子节点数）。
证明思路：通过对公式结构进行归纳。当 φ 是单个门时显然成立。对于 φ = φ1 AND φ2，f̃ = f̃1 * f̃2，变量 xi 的次数是其在 f̃1 和 f̃2 中次数之和。根据归纳假设，f̃1 和 f̃2 的次数和分别不超过 S1 和 S2，且 S = S1 + S2，因此总次数和不超过 S。OR门的情况类似。

因此，每个变量的次数 d 最多为 S，而 S 是输入规模的多项式。

协议执行与效率

  • 通信与验证复杂度：和校验协议的通信量和验证者运行时间是 O(n * d * log|F|)，即输入规模的多项式。
  • 完备性与可靠性：完备性为1。可靠性误差为 (n * d) / |F|。通过选择一个足够大的域 F（使 |F| >> n * S），我们可以使误差足够小，并可重复协议以进一步降低误差。
  • 证明者复杂度：证明者需要计算整个求和，这至少需要 O(2^n) 时间，对于#SAT这类难题是不可避免的。

这个例子展示了和校验协议如何将一个看似非代数的问题，通过算术化技巧，转化为可处理的低次多项式求和问题。

SAT的例子虽然精彩，但似乎是为和校验“量身定制”的。接下来，我们将探索和校验更强大的应用，并引入双重高效交互式证明的概念。

双重高效交互式证明

在之前的协议中，我们只要求验证者高效（多项式时间），而证明者可以是全能的。但在实际应用中，证明者也是资源受限的。

双重高效交互式证明要求：

  • 证明者高效：诚实的证明者运行时间应与判定语言所需的时间 T(n) 相差不多（例如，多项式开销）。
  • 验证者超高效：验证者运行时间应远小于 T(n)，理想情况下是近线性时间 O~(n)。

这适用于 P 类中的问题，目标是让验证者以远快于直接计算的速度，确信某个计算结果的正确性。

应用示例：图中三角形计数

我们以“计算图中三角形的数量”为例，展示如何构建一个双重高效的交互式证明。这是一个 P 问题（朴素算法需 O(n^3)），我们希望验证者能以近线性时间完成验证。

问题建模

设图 G 有 n 个顶点，其邻接矩阵可以用一个函数 A 表示：
A(u, v) = 1 如果边 (u, v) 存在，否则为 0。
这里，我们将顶点用长度为 log n 的二进制串表示，因此 A: {0,1}^{log n} × {0,1}^{log n} -> {0,1}。

图中三角形的数量 K 可以表示为：
K = (1/6) * ∑_{i,j,k ∈ {0,1}^{log n}} A(i,j) * A(j,k) * A(k,i)
（因子 1/6 用于消除顶点排列对同一三角形的重复计数）。

挑战与思路

上述求和式看起来像和校验，但存在两个问题：

  1. 函数 A 是二值的，没有代数结构。
  2. 求和是在 {0,1} 上进行的，而非一个域。

解决方案是使用低次扩展技术。

低次扩展

定理（低次扩展）：对于任意有限域 F（满足 H ⊆ F）和任意函数 f: H^m -> F，存在一个多项式 f̃: F^m -> F，满足：

  1. 扩展性：对于所有 x ∈ H^m，有 f̃(x) = f(x)。
  2. 低次性：f̃ 在每个变量上的次数至多为 |H| - 1。

直观理解：

  • 在单变量情况下（m=1），给定 |H| 个点上的取值，我们可以构造一个次数不超过 |H|-1 的多项式来精确拟合这些点。但此时次数可能很高（O(n)）。
  • 在多变量情况下，我们可以通过增加变量维度 m 来显著降低每个变量上的次数。例如，为了表示一个长度为 N 的向量，我们可以选择 H 和 m，使得 |H|^m = N，但让 |H| 很小（如 |H| = log N），那么每个变量的次数就只有 O(log N)。验证者的工作量将依赖于 m 和 |H|，而不是 N。

应用于三角形计数

  1. 构造低次扩展：对邻接函数 A: H^m -> {0,1}（其中 |H|^m = n），构造其低次扩展多项式 Ã: F^m × F^m -> F，在每个变量上次数为 O(|H|) = O(log n)。
  2. 定义目标多项式：定义三元多项式
    g(i, j, k) = Ã(i,j) * Ã(j,k) * Ã(k,i)
    其中 i, j, k ∈ F^m。由于 Ã 是低次的，g 的总次数也是 O(log n)。
  3. 应用和校验：证明者需要证明：
    ∑_{i,j,k ∈ H^m} g(i, j, k) = K' （其中 K' = 6K，在域 F 中计算）。
    这正是一个定义在 3m 个变量上的和校验问题，且多项式次数很低。
  4. 效率分析：
    • 证明者：需要计算 g 在 H^(3m)（即 n^3 个点）上的求和。这需要 O(n^3) 时间，与问题本身的计算复杂度同阶。
    • 验证者：运行和校验协议，其时间主要取决于变量数 3m = O(log n) 和次数 d = O(log n)，因此是多项式对数时间的，远小于 O(n^3)。

这就为三角形计数问题构建了一个双重高效的交互式证明！证明者工作量和直接计算相当，而验证者则快得多。

本节课中我们一起学习了：

  1. 和校验协议的公开掷币性质及其随机性的关键作用。
  2. 如何通过算术化技术，利用和校验协议为 #SAT问题构建交互式证明。
  3. 双重高效交互式证明的概念，即要求证明者和验证者都高效。
  4. 如何利用低次扩展技术，将非代数问题（如图中的三角形计数）转化为低次多项式求和问题，进而应用和校验协议，获得双重高效的交互式证明。

下一节课，我们将深入探讨低次扩展定理的证明，并进一步将其推广到为更一般的低深度电路计算构建双重高效证明。

003：双高效交互式证明，第一部分

概述

在本节课中，我们将学习双高效交互式证明的核心概念，特别是低次扩展定理及其应用。我们将从回顾和校验协议开始，然后深入探讨低次扩展定理，并展示如何利用它和和校验协议为低深度电路构建双高效交互式证明。

回顾：和校验协议与双高效交互式证明

上一节我们介绍了交互式证明的概念，并展示了和校验协议。和校验协议是一种方法，用于证明一个多元多项式在一个小集合（例如布尔超立方体）上的和等于某个值。虽然计算这个和本身可能非常耗时（例如需要计算 H^M 次），但通过交互式证明，验证者可以在假设能高效计算该多项式在域中任意随机点上的值的前提下，非常高效地进行验证。

和校验协议是证明系统的基石，几乎每个证明系统都会用到它。它是一个非常优美的协议，我们将在整个课程中反复使用它。

接着，我们开始探讨双高效交互式证明的概念。在双高效交互式证明中，我们不仅关心验证者的运行时间，也关心证明者的运行时间。证明者虽然比验证者更强大，但我们不希望其计算开销过于巨大。

我们以计算图中三角形数量为例，开始展示如何构建双高效交互式证明，这通常通过低次扩展技术实现。

低次扩展定理

本节中，我们来看看低次扩展定理。这个定理在某种意义上赋予了和校验协议强大的能力。实际上，低次扩展定理与和校验协议相结合，几乎可以推导出一切。

低次扩展定理 表述如下：
设 H 是任意集合（例如 {0,1}），M 是一个正整数。对于任意函数 f: H^M -> {0,1}（可以将其视为定义在超立方体上的一组比特序列），以及任意包含集合 H 的有限域 F，存在一个唯一的多项式 f̃: F^M -> F，满足以下两个条件：

  1. 扩展性：对于超立方体 H^M 中的所有点，f̃ 的值与 f 完全相同。即，∀ (h1,...,hM) ∈ H^M, f̃(h1,...,hM) = f(h1,...,hM)。
  2. 低次数：f̃ 在每个变量上的次数最多为 |H| - 1。

公式描述：
f̃ 可以显式地构造为：
f̃(z1,...,zM) = Σ_{(h1,...,hM) ∈ H^M} f(h1,...,hM) * Π_{i=1}^{M} χ_{hi}(zi)
其中，对于每个 hi ∈ H，χ_{hi}(zi) 是一个单变量多项式，满足在 H 上，当 zi = hi 时值为1，否则为0，并且其次数为 |H|-1。

直观理解：
你可以想象在某个超立方体（可以是布尔超立方体或更大的立方体）上有一组任意的比特序列。该定理指出，你可以将这个序列唯一地扩展为定义在整个大域 F^M 上的一个多项式，使得该多项式在原始超立方体上的值与原始序列完全一致，并且这个多项式在每个变量上的次数都很低（最多 |H|-1）。

特殊情况：
当 H = {0,1} 时，|H|-1 = 1。此时得到的扩展多项式在每个变量上都是线性的，因此被称为多线性扩展。

重要性：
这个定理的强大之处在于，它允许我们将任意、可能无结构的比特序列，转换成一个具有丰富代数结构的低次多项式。低次多项式具有很多良好的性质，例如，我们可以对其应用和校验等协议。

定理证明概要

存在性与构造：
上述给出的 f̃ 的显式公式即是一个构造。可以验证，它在 H^M 上与 f 一致，并且每个变量 zi 的次数来自 χ_{hi}(zi)，即 |H|-1。

唯一性：
唯一性可以通过反证法和拉格朗日插值定理的唯一性来证明。假设存在两个不同的低次扩展多项式，它们的差 G 是一个在 H^M 上为零但不是零多项式的低次多项式。通过逐坐标归纳，利用单变量情形的唯一性，可以推导出矛盾，从而证明唯一性。

关于计算效率的说明：
需要注意的是，按照上述公式直接计算 f̃ 在某个点上的值，需要对整个超立方体 H^M 进行求和，这通常是低效的（时间复杂度为 O(|H|^M)）。然而，在许多应用中，我们并不需要显式地计算整个多项式，而是利用其代数性质。对于某些具有特殊结构（例如来自浅层算术电路）的 f，可能存在更高效的计算其低次扩展的方法。

应用：三角形计数的双高效交互式证明（重温）

现在，让我们回到三角形计数的例子，看看如何结合低次扩展与和校验来构建双高效交互式证明。

目标：
证明者希望向验证者证明，在一个 n 个顶点的图 G 中，三角形的数量恰好是某个值 β。验证者只能运行 O(n^2) 时间（即大致读取图的大小），而证明者的计算也应尽可能高效。

步骤：

  1. 编码图为多项式：将图的邻接矩阵编码为一个函数 f: {0,1}^{log n} × {0,1}^{log n} -> {0,1}，其中 f(u,v)=1 当且仅当存在边 (u,v)。这是一个定义在布尔超立方体上的函数。
  2. 低次扩展：计算 f 的多线性扩展 f̃。这不会改变 f 在布尔超立方体上的值。
  3. 将计数问题表达为和：图中三角形的数量可以表示为：
    β = (1/6) * Σ_{i,j,k ∈ V} f̃(i,j) * f̃(j,k) * f̃(i,k)
    这里 i, j, k 是顶点编号（log n 位字符串）。忽略常数因子 1/6，我们需要证明的和是 Σ_{i,j,k} f̃(i,j) * f̃(j,k) * f̃(i,k)。
  4. 应用和校验协议：上述和式定义了一个关于 3 log n 个变量的多项式（每个 f̃ 是多线性的，乘积后每个变量次数为2）。证明者声称这个和等于 β。双方可以运行和校验协议。
    • 验证者效率：在和校验协议的最后，验证者需要计算多项式在随机点 (r1, r2, r3) 上的值，即计算 f̃(r1, r2) * f̃(r2, r3) * f̃(r1, r3)。由于 f̃ 是邻接矩阵的扩展，验证者可以通过查询原始的 f（即检查邻接关系）并利用低次扩展公式（虽然低效，但在此例中由于 |H|^M = n^2，验证者可以承受）或更聪明的方法来计算 f̃ 在随机点上的值。总体验证时间约为 O(n^2)。
    • 证明者效率：证明者需要执行和校验协议中的计算，其复杂度与变量数和求和域大小相关，约为 poly(n)，对于多项式时间证明者是可行的。
    • 通信复杂度：和校验协议的轮数和通信量为 O(log n)。

小结：
这个例子展示了即使面对像邻接矩阵这样本身没有代数结构的对象，我们也可以通过低次扩展为其“注入”代数结构，进而利用和校验协议来构建关于其全局属性（如三角形计数）的高效证明系统。

迈向通用构造：GKR协议简介

上一节我们看到了一个具体问题的双高效证明。本节中，我们将探讨一个更通用的强大构造：GKR协议。该协议可以为任何低深度电路的计算提供双高效交互式证明。

目标：
对于一个规模为 S（门数量）、深度为 D（D 较小）的布尔电路 C，以及输入 x，证明者希望向验证者证明 C(x) = 1。验证者的运行时间应约为 D * polylog(S)，而证明者的运行时间约为 poly(S)。

重要前提：
为了使验证者高效，电路 C 必须具有简洁的表示（例如，是对数空间均匀的），即存在一个 O(log S) 空间的图灵机可以生成该电路的描述。否则，仅读取电路就需要 O(S) 时间。

GKR协议核心思想

协议的核心思想是逐层归约。

  1. 电路预处理：
    • 分层：假设电路是分层的，即第 i 层的门只连接到第 i+1 层的门。可以通过添加虚拟门使任意电路满足此条件。
    • 算术化：将电路中的布尔门（AND, OR）转换为算术域 F 上的加法门和乘法门。
  2. 为每一层编码：
    • 证明者计算电路中每一层所有门在输入 x 下的取值。设第 i 层的取值构成一个函数 V_i: H^M -> {0,1}，其中 |H|^M ≈ S，每个门有一个在 H^M 中的唯一标签。
    • 证明者为每一层计算其低次扩展 Ṽ_i。
  3. 交互式归约：
    • 协议从输出层（第0层）开始。证明者声称 Ṽ_0(z_0) = 1（对于某个特定的 z_0，代表输出门）。
    • 验证者并不直接相信。协议将进行 D 轮子协议，每一轮将一个关于第 i 层的声称，归约到关于第 i+1 层的一到两个声称。
    • 归约的关键等式：利用电路的连线关系，V_i 中一个门 p 的值可以表示为第 i+1 层中某些门值的函数（加法或乘法）。通过低次扩展，可以将关于 Ṽ_i(z_i) 的声称，转化为一个关于 Ṽ_{i+1} 在多个点上的值的求和形式。
    • 应用和校验：上述求和形式正好是和校验协议可以处理的。双方运行和校验协议，将“Ṽ_i(z_i) = 某值”的声称，转化为验证者需要检查“某个包含 Ṽ_{i+1} 的复杂多项式在随机点 (r1, r2, r3) 上的值等于某值”。
    • 提取新声称：为了完成检查，验证者需要知道 Ṽ_{i+1}(r1) 和 Ṽ_{i+1}(r2) 的值。他要求证明者提供这些值。如果最初的声称是假的，那么通过和校验的声音性，最终验证者要检查的等式很可能是假的。如果证明者提供真实的 Ṽ_{i+1} 值，验证者计算后会发现问题，从而拒绝。因此，作弊的证明者很可能被迫提供假的 Ṽ_{i+1} 值。这样，我们就将一层的一个假声称，归约到了下一层的一到两个假声称。
  4. 最终检查：
    • 经过 D 轮归约，我们到达输入层（第 D 层）。此时验证者需要检查关于 Ṽ_D（即输入 x 的低次扩展）在某些点上的声称。
    • 由于输入 x 是公开的，验证者可以自己高效地计算 Ṽ_D 在任何点上的值（因为输入层的低次扩展可以直接由 x 计算）。验证者进行本地检查，如果所有归约过程中得到的声称都通过检查，且最终的输入层声称也正确，则接受证明。

协议效率：

  • 验证时间：每轮归约主要是一个和校验协议，验证者需要计算电路连线函数的低次扩展（add_i 和 mult_i）在随机点上的值，以及最后检查输入层。对于均匀电路，这些计算可以在 polylog(S) 时间内完成。总共 D 轮，因此总验证时间为 D * polylog(S)。
  • 证明者时间：证明者需要计算每一层的低次扩展，并执行和校验中的计算，总时间约为 poly(S)。
  • 通信复杂度：每轮和校验通信 polylog(S)，共 D 轮，总通信为 D * polylog(S)。

待解决的问题：
在上述描述中，我们假设验证者能够高效计算电路连线函数的低次扩展 add_i 和 mult_i。这对于均匀电路是可能的，但需要额外的机制。我们将在下一节课中详细讨论如何解决这个问题，从而完成GKR协议的完整描述。

总结

本节课中我们一起学习了双高效交互式证明的核心基础。

  1. 我们首先回顾了强大的和校验协议。
  2. 接着，我们深入探讨了低次扩展定理，它能够将任意比特序列唯一地扩展为低次多项式，从而为应用和校验等代数工具铺平道路。
  3. 我们通过三角形计数的例子，演示了如何结合低次扩展与和校验来为特定问题构建双高效证明。
  4. 最后，我们介绍了GKR协议的宏伟蓝图。该协议利用低次扩展和和校验，通过逐层归约，为任何低深度、均匀电路的计算结果构建了双高效交互式证明。验证者时间仅与电路深度呈线性关系，而与电路规模呈对数多项式关系，这为实现高度可扩展的验证奠定了基础。

在下一讲中，我们将完成GKR协议的细节，特别是解决验证者如何高效计算电路连线函数低次扩展的问题，并进一步探讨其应用和变种。

004：双高效交互式证明（第二部分）

在本节课中，我们将继续学习GKR协议，深入探讨如何将单点验证问题转化为多点验证问题，并分析协议的安全性、复杂度以及具体实现细节。

协议核心思路回顾

上一节我们介绍了如何利用和校验协议将电路某一层的单点验证问题，转化为对下一层两个点的验证问题。本节中，我们来看看如何处理由此产生的两个验证问题。

我们面临的核心问题是：验证者声称电路第 i 层扩展多项式在点 Z_i* 的值为 V_i*。通过和校验协议，我们将其转化为需要验证第 i+1 层扩展多项式在两个随机点 Z1 和 Z2 上的值 V_{i+1,1} 和 V_{i+1,2}。

验证者无法独立计算这些值，因此需要证明者提供。如果证明者诚实，验证者将能发现初始声明的错误；如果证明者作弊，则他必须提供错误的 V_{i+1,1} 或 V_{i+1,2} 值，否则会被和校验协议当场揭穿。这就将一个关于第 i 层的错误声明，转化为了关于第 i+1 层的（至少）一个错误声明。

从两个声明到更多声明？一个巧妙的观察

一个自然的担忧是：从一个声明变成两个，是否会像滚雪球一样，在下一层变成四个，再下一层变成八个，导致声明数量指数级增长？

答案是否定的。这里的关键在于 并行执行 和 复用随机数。

以下是GKR协议的处理方式：

  1. 对于第 i 层产生的两个声明（分别关于点 Z1 和 Z2），我们并行地执行两个和校验协议。
  2. 至关重要的是，这两个并行的和校验协议使用 完全相同 的随机数序列 (r0, r1, r2, ...)。
  3. 每个和校验协议最终都会要求验证者检查一个形如 F_{i+1}(Z*, r0, r1, r2) 的值。由于随机数相同，验证者需要检查的两个点分别是 F_{i+1}(Z1, r0, r1, r2) 和 F_{i+1}(Z2, r0, r1, r2)。
  4. 要计算这两个值，验证者唯一不知道的是第 i+2 层扩展多项式在点 Z1 和 Z2 的值。因此，他只需向证明者索要这两个值。

通过这种方式，我们从第 i 层的两个声明，又得到了第 i+1 层的两个声明。声明数量始终保持为两个，而不会增长。

GKR协议流程总结

综上所述，完整的GKR协议可以概括为以下步骤：

  1. 初始化：证明者声称电路输出（第0层）为某个值 V_0*。
  2. 迭代和校验：对于每一层 i（从0到深度 d-1）：
    • 验证者与证明者并行执行两个和校验协议（使用相同的随机数），以验证从第 i 层到第 i+1 层的两个声明。
    • 每个和校验协议最终将验证任务简化为检查一个形如 F_{i+1}(Z, r) 的值。
    • 为了完成检查，验证者要求证明者提供第 i+2 层扩展多项式在特定点 Z1 和 Z2 的值。
  3. 最终验证：到达最底层（输入层）后，验证者获得了关于输入层扩展多项式在两个点 Z_{d,1} 和 Z_{d,2} 的声明值 V_{d,1} 和 V_{d,2}。
    • 验证者可以自行高效计算低次扩展多项式在这两个点的真实值，因为输入层数据 (x1, ..., xn) 是已知的，且计算仅涉及 n 个项的加权和。
    • 验证者比较计算出的真实值与证明者提供的声明值。如果匹配，则接受证明；否则拒绝。

协议复杂度分析

以下是GKR协议各方的复杂度：

  • 通信复杂度：共有 d 层，每层进行两次和校验。每次和校验的通信量为 O(m * log|F|)，其中 m ≈ log S / log log S（变量数），d ≈ log S（深度）。因此总通信复杂度为 d * polylog(S) = polylog(S)。
  • 验证者时间复杂度：验证者主要工作是参与 d 次和校验，以及在最后计算两次输入层的低次扩展。每次和校验验证者只需做少量工作，最终计算复杂度为 O(n * polylog(S))，其中 n 为输入大小。通常 n << S，因此验证者总时间为 polylog(S)。
  • 证明者时间复杂度：证明者需要为每层计算和校验中的多项式，这需要对所有门进行求和，时间复杂度为 poly(S)。

协议安全性（健全性）证明

我们简要分析GKR协议的健全性。假设存在一个作弊的证明者 P* 能够以概率 ε 让验证者接受一个错误的声明。

我们定义“坏事件” B_i：在第 i-1 层，至少有一个声明是假的；但在执行完第 i 层的和校验后，第 i 层的两个声明都变成了真的。

如果作弊成功，那么从初始的假声明到最终验证者自行验证为真的声明之间，必然至少发生了一次 B_i 事件。因此，作弊成功的概率 ε 不超过所有 B_i 事件发生概率之和。

现在分析单个 B_i 事件的概率。以 B_{i,1} 为例，它表示第 i-1 层的第一个声明是假的，但经过第 i 层的第一个和校验后，第 i 层的对应声明变成了真的。这恰好意味着证明者在第一个和校验协议中作弊成功。根据和校验协议本身的健全性，在随机挑战下，作弊成功的概率至多为 (deg * m) / |F|，其中 deg 为多项式次数，m 为变量数。

因此，每个 B_{i,b} 的概率上界为 polylog(S) / |F|。通过并集界限，总作弊概率 ε 的上界约为 (d * polylog(S)) / |F|。只要我们选取足够大的有限域 F（其大小 |F| 为 poly(S) 量级），就可以使 ε 变得可忽略不计。

关于并行使用相同随机数的安全性：安全性分析中我们对两个和校验协议分别应用了健全性界限，并通过并集界限合并风险。即使两个协议的结果存在关联，只要其中一个协议被成功作弊，就足以触发坏事件，因此并集界限足以覆盖这种风险。

协议的关键属性与扩展讨论

GKR协议以“黑盒”方式使用和校验协议，它只要求和校验协议满足一个关键属性：协议最终将验证任务简化为由验证者选择随机点，并检查原函数在该点的值。

关于扇入（fan-in）：我们的讨论假设电路扇入为2。对于更大扇入 k 的电路，和校验协议会将一个声明转化为 k 个声明。只要 k 是 polylog(S) 量级，协议依然有效，通信复杂度会乘以 k，但整体仍可能保持在对数级别。更大的扇入意味着更浅的电路深度，需要在深度和每层宽度之间进行权衡。

本节课中我们一起学习了GKR协议如何通过并行和校验将验证问题逐层下推，并始终保持恒定的声明数量。我们分析了协议的详细流程、计算与通信复杂度，并探讨了其健全性证明的核心思想。GKR协议巧妙地结合了低次扩展与和校验，实现了验证者时间与通信量均为亚线性的高效交互式证明。

005：GKR协议续篇及其推论 🧠

在本节课中，我们将继续深入探讨GKR协议，学习如何解决协议中的关键问题，并了解其一个重要的应用：为多项式空间（PSPACE）计算构建高效的交互式证明系统。

概述：GKR协议回顾

上一节我们介绍了GKR协议的核心思想：证明者（Prover）可以将一个深度为d、规模为S的电路C的计算委托给验证者（Verifier）。协议通过将电路每一层的门值进行低次扩展，并利用求和检查协议（Sum-Check Protocol）将关于高层输出的声明，逐步归约到关于底层输入的声明。最终，验证者可以自行检查输入层的低次扩展值。

然而，我们遗留了两个关键问题：

  1. 验证者如何高效地计算加法门和乘法门（add/mult）的低次扩展？之前我们假设验证者拥有这些函数的预言机（oracle）访问权限。
  2. 当电路的描述C本身很大时，如何保持验证者的高效性？

本节中，我们将首先解决这两个问题，然后展示GKR协议的一个强大推论。

问题一：如何获取门函数的低次扩展？ 🔧

在原始的GKR协议中，验证者需要知道加法门和乘法门函数的低次扩展。直接计算这些函数的规范低次扩展（Canonical Low-Degree Extension）可能非常复杂。

以下是两种可能的解决方案：

方案A：递归委托
我们可以将add/mult门电路本身视为一个需要被验证的计算，并递归地对其应用GKR协议。这是原始GKR论文中的方法。

方案B：使用更简单的电路进行计算（本节课采用的方法）
我们用一个更易于描述的电路来替代原始电路C，这个新电路的add/mult门函数更容易计算。

引入通用电路（Universal Circuit）

核心思想是构造一个通用电路 U。这个电路以原始电路C的描述和输入x作为其输入，并模拟C在x上的计算，最终输出C(x)。

U(description_of_C, x) = C(x)

这个通用电路U的关键优势在于，它的add/mult门功能比原始电路C的对应功能更容易描述。具体来说，对于U中的任何一个门，判断它是加法门还是乘法门，可以通过一个规模仅为polylog(S) 的布尔公式来完成。

这意味着验证者可以自行高效地计算这些布尔公式在特定点上的值，从而绕过了直接计算复杂低次扩展的难题。

算术化布尔公式

然而，GKR协议需要的是在大域上的多项式，而不是布尔值。因此，我们需要将判断门类型的布尔公式进行算术化。

以下是算术化的步骤：

  1. 编码输入：将来自大域H的门索引（例如p, ω1, ω2）通过低次多项式编码为一串比特（0/1）。
  2. 算术化：将布尔公式中的AND门替换为乘法（a * b），将OR门替换为a + b - a*b。
  3. 得到多项式：最终我们得到一个多项式，其次数约为(公式深度) * |H|。这个多项式虽然不是add/mult函数的规范低次扩展，但它与规范扩展在超立方体H^m上取值相同，并且其次数足够低，可以用于后续的求和检查协议。

通过这种方式，验证者就获得了计算add/mult“类低次扩展”值的能力。

问题二：如何处理大型电路描述？ 📦

当我们使用通用电路U时，输入变成了(description_of_C, x)。如果C的描述非常庞大（例如规模为S），那么验证者在最终检查输入层时，需要计算规模为S的向量的低次扩展，这将是低效的。

解决方案依赖于电路C是对数空间均匀的这一假设。这意味着存在一个图灵机M，它仅使用O(log S)的空间，就能在给定索引时输出电路C中任意门的描述。

我们可以将这个图灵机M本身转换成一个电路，并把它作为我们最终要委托的计算电路C'的一部分。

C'(short_description_of_C, x) = U(M(short_description_of_C), x) = C(x)

现在，整个委托电路的输入仅仅是C的简短描述（长度为O(log S)）和原始输入x。验证者需要处理的输入规模大大减小。

关键：保持电路深度为对数级

一个技术挑战是：将运行时间可能为2^S的对数空间图灵机M转换成电路时，如何避免电路深度达到O(S)？

这里的技巧是利用配置图（Configuration Graph）和矩阵幂运算。

  1. 将图灵机M在空间S上的所有可能配置视为节点。
  2. 构造一个邻接矩阵A，其中A[i][j]=1当且仅当配置i能在一步内转移到配置j。这个矩阵A很容易被一个小电路计算。
  3. 计算A^T（T是时间上限，例如2^S）。A^T[i][j]表示从配置i出发，经过恰好T步能否到达配置j。
  4. 计算A^T可以通过重复平方（A -> A^2 -> A^4 -> ... -> A^T）来实现，这只需要O(log T)层的矩阵乘法。

最终，我们得到一个规模为poly(S)、深度仅为O(log S)的电路C'，它完美适用于GKR协议。

推论：GKR为PSPACE提供高效交互式证明 🚀

本节课最后，我们探讨GKR协议的一个深刻推论。我们知道IP = PSPACE（Shamir, 1992），即所有多项式空间可判定的语言都存在交互式证明。然而，早期的证明构造中，证明者的运行时间可能高达2^(S^2)，远大于单纯计算所需的时间2^S。

利用我们刚刚构建的GKR协议，我们可以为任何多项式空间计算（由空间界限为S的图灵机M定义）获得一个证明者运行时间接近最优的交互式证明系统。

构造思路如下：

  1. 给定一个空间界限为S的图灵机M和输入x，我们按照上述方法，构造一个模拟M(x)计算、深度为O(log S)、规模为poly(S)的电路C'。
  2. 对此电路C'运行GKR协议。
  3. 根据GKR协议的性质：
    • 证明者运行时间为poly(S)。
    • 验证者运行时间为d * polylog(S) + O(n * polylog(S))，其中d = O(log S)，因此验证者也是高效的。

这个结果表明，对于多项式空间计算，我们确实存在证明者时间与计算时间相近（均为2^O(S)量级）的高效交互式证明系统，这比早期结果有了显著改进。

总结

本节课中我们一起学习了：

  1. 解决门函数计算：通过引入通用电路和算术化小型布尔公式，使验证者能够自行高效计算add/mult门的类低次扩展值。
  2. 处理大型输入：通过对数空间均匀性假设，将庞大的电路描述压缩，并利用配置图和矩阵幂技巧，构造出深度仅为对数级的等效电路。
  3. 强大推论：将上述技术应用于多项式空间计算，基于GKR协议构建了证明者时间接近最优的交互式证明系统，展示了GKR协议的理论威力。

这些技术不仅完善了GKR协议本身，也为我们理解高效计算验证的可能性提供了重要工具。

006：通过GKR和交互式论证构建PCP，第一部分

在本节课中，我们将学习一个非常有趣的新概念——概率可检查证明。我们将定义这个概念，并展示如何从GKR协议构造它。课程的第二部分将首次引入密码学，探讨一种新的可靠性概念——计算可靠性论证。

概述：什么是概率可检查证明？

概率可检查证明旨在将传统的证明转换为一种新的形式。传统证明中，验证者需要读取整个证明并进行计算。PCP的目标是生成一个可能更长的证明，但验证者只需随机查询其中极少数的几个位置，就能以高概率判断证明的有效性。

具体来说，对于语言L中的一个实例x，存在一个证明π。验证者V可以随机选择查询π中的几个比特，然后运行一个仅依赖于这些比特的验证电路。如果x在语言L中，则存在π使V以概率至少C接受；如果x不在L中，则对于任何π，V接受的概率至多为S。理想情况下，我们希望C=1，S=0。

目前已知的构造非常强大：可以将任何证明转换为一个PCP，使得验证者只需读取3个比特就能以一定的概率（例如7/8）被说服。本节课我们将构造一个查询复杂度为 polylog(n) 的PCP。

从GKR协议构造PCP

我们将展示如何利用之前学过的GKR交互式证明协议来构造PCP。其核心思想是将GKR协议中“证明者”的所有可能应答策略完全展开并编码到PCP字符串中。

回顾GKR协议

首先，我们快速回顾GKR协议。我们有一个验证电路C，其输入为见证w。电路是分层且深度D较小的（例如polylog(n)）。在GKR中：

  1. 对于电路的每一层i，我们计算该层所有导线值的低次扩展 \(\tilde{V}_i\)。
  2. 协议由2D个和校验协议组成，从输出层开始，逐层向下验证，直到输入层。
  3. 每个和校验协议将验证层i上某点 \(\tilde{V}_i(z)\) 的声称值，归结为验证层i-1上两个点的值。

PCP的构造

现在，我们构造PCP证明π。证明者拥有见证w，并希望证明x ∈ L。

PCP包含以下部分：

  1. 电路各层的低次扩展：对于每一层i（从输入层0到输出层D），以及域F^m中的每一个点z，计算并包含值 \(\tilde{V}_i(z)\)。这确保了验证者可以查询任何点的扩展值，而无需自己计算。
  2. 所有可能的和校验协议转录：对于每一层i、每一个点z，以及和校验协议中验证者所有可能的随机选择 \(r_1, ..., r_{3m}\)（其中m是维度），证明者预先计算并包含证明者在相应轮次中应发送的所有应答（即单变量多项式）。这形成了一个巨大的树状结构，但由于参数设置（F的大小为polylog(n)，m约为log n / log log n），整个树的大小仍然是多项式级别的。

验证者的操作：
验证者V模拟与GKR证明者的交互，但“证明者”的策略已经编码在PCP π中。

  1. V首先查询输出层 \(\tilde{V}_D\) 在特定点的值，确认其为1（接受状态）。
  2. 接着，V像在GKR协议中一样，为第一个和校验协议生成随机数 \(r_1, ..., r_{3m}\)。
  3. V根据这些随机数，查询PCP中对应的应答（即多项式）。
  4. 在每轮和校验后，V会得到对下一层某点 \(\tilde{V}_{i-1}(z‘)\) 的声称值。V可以查询PCP中存储的 \(\tilde{V}_{i-1}(z‘)\) 来验证一致性。
  5. 重复此过程，经过2D个和校验后，最终到达输入层。V需要验证输入层的低次扩展 \(\tilde{V}_0\)（即见证w的扩展）是否正确。由于V本身知道实例x，他可以通过计算x和w的联合低次扩展的某个点来进行检查（这需要查询PCP中 \(\tilde{V}_0\) 的少数点并自行计算）。

可靠性与复杂度分析

完备性： 如果证明者诚实构造PCP（基于有效的见证w），那么GKR协议的所有步骤都会通过，验证者总是接受。因此完备性为1。

可靠性： 如果一个实例x不在语言L中，那么任何PCP π都必须尝试“欺骗”。要成功欺骗验证者，就必须在2D个和校验协议中的至少一个上成功作弊。每个和校验协议的可靠性误差约为 (3m * |H|) / |F|。通过联合界，总的可靠性误差上界为 2D * (3m * |H|) / |F|。通过设置域F的大小 |F| 远大于 D * m * |H|（这仍然是polylog(n)量级），我们可以将可靠性误差降至1/2或更小。

查询复杂度： 验证者需要进行2D个和校验，每个和校验需要读取O(m)个应答，每个应答是一个低次多项式，需要读取多个域元素来评估。总的查询比特数是 polylog(n)。

随机性复杂度： 验证者为每个和校验生成 O(m * log|F|) 比特的随机数，总共也是 polylog(n) 比特。

关于低次测试的说明

一个关键点是，验证者必须确保PCP中提供的 \(\tilde{V}_i\) 确实是某个低次多项式的值，而不仅仅是任意值。在标准的PCP构造中，这需要一个独立的“低次测试”。然而，在我们从GKR衍生的构造中，GKR协议本身间接地充当了低次测试。因为如果 \(\tilde{V}_i\) 不是低次的，那么在后续的和校验协议中，证明者将很难保持一致性并被发现的概率很高。因此，我们不需要在PCP验证中显式地加入额外的低次测试步骤。

总结

本节课中，我们一起学习了概率可检查证明这一强大概念。我们看到了如何将GKR交互式证明协议“非交互化”和“编译”成一个PCP字符串。通过巧妙的参数设置（选择适当的域大小和维度），我们构造出的PCP具有以下性质：

  • 完备性为1。
  • 可靠性可降至1/2（通过重复可进一步降低）。
  • 验证者只需进行 polylog(n) 次查询，使用 polylog(n) 比特的随机数。
  • 证明者可以高效地从有效见证w生成PCP π。

这个构造展示了和校验协议以及GKR协议的基础性作用，它们不仅是简洁交互式证明的核心，也是构建高级密码学原语（如PCP）的基石。在下一部分，我们将探讨如何利用PCP进入密码学领域，并引入基于计算安全性的论证系统。

007：通过GKR和交互式论证的PCP，第二部分

在本节课中，我们将继续探讨如何利用GKR协议和交互式论证来构造概率可检查证明。我们将重点关注如何确保PCP见证是低次多项式，并介绍计算性可靠证明（即论证）的概念，这是通向简洁非交互式证明的关键一步。

确保见证接近低次多项式

上一节我们介绍了如何利用GKR协议和和校验协议构造一个PCP。现在，我们需要确保证明者放置在PCP中的见证 W 是一个低次多项式。具体来说，我们希望 W 是每个坐标上次数不超过 H-1 的低次多项式扩展。

然而，验证者无法直接检查整个 W 是否是低次多项式，因为查询次数有限。因此，我们转而检查 W 是否接近某个低次多项式。

我们期望的保证是：经过测试后，以高概率存在一个低次多项式 W̃，使得对于随机选择的点 z，W(z) = W̃(z) 的概率大于 1 - ε。这意味着两个函数在大多数点上一致。

低次多项式测试方法

为了进行这种“接近性”测试，我们采用一种常见的低次测试方法。

以下是测试步骤：

  1. 验证者随机选择 F^m 中的一条直线 L。
  2. 证明者需要在这条直线上给出 W 的限制。
  3. 验证者检查该限制是否是一个次数不超过 m * (H-1) 的多项式。如果不是，则立即拒绝。
  4. 如果测试通过，则意味着在随机直线上，W 与某个低次多项式一致。

需要论证的是，如果 W 在随机直线上与低次多项式一致，那么它在整个空间上也以高概率接近某个低次多项式。这是一个需要深入分析的结论。

测试的意义

如果测试通过，我们就得到了一个接近低次多项式的 W。此时，我们可以使用那个真正的低次多项式 W̃ 作为有效的见证。即使 W 和 W̃ 在少数点上不一致，由于验证者只查询随机点，它查询到不一致点的概率很小，因此不影响整体验证的正确性。

从信息论到密码学：计算性可靠证明

到目前为止，我们讨论的证明系统都属于信息论范畴，其安全性不依赖于任何计算假设。然而，这些系统存在局限性，例如PCP证明体积庞大，而交互式证明又无法做到非交互和简洁。

为了突破这些限制，我们引入密码学工具，将模型改为计算性可靠证明，也称为论证。

论证与证明的区别

论证与交互式证明的唯一区别在于可靠性条件。

  • 完备性：与之前相同。如果陈述为真，诚实的证明者总能说服验证者。
  • 计算可靠性：仅针对计算能力有界的证明者。对于任何在输入长度 n 和安全参数 λ 下运行时间为 poly(λ) 的证明者 P*，如果陈述为假 (x ∉ L)，那么 P* 能成功欺骗验证者接受的概率是可忽略的（即小于任何 1/poly(λ)）。

直观上，我们不再关心那些需要超多项式（如指数级）时间才能构造的作弊证明，因为在实际中这样的攻击者不存在。通过限制攻击者的计算能力，我们可以利用密码学原语来构建更强大、更实用的证明系统。

Kilian-Micali定理

一个奠基性的结果是Kilian和Micali在92和94年提出的定理，它展示了如何结合PCP和密码学来构造简洁的论证。

定理：假设存在抗碰撞哈希函数，那么对于任何NP语言，都存在一个4消息的论证系统，满足：

  • 证明者运行时间为 poly(n, λ)。
  • 验证者运行时间为 poly(λ) 加上PCP验证者的运行时间。
  • 完备性为1。
  • 对于任何规模为 poly(λ) 的证明者 P*，可靠性是可忽略的。

这个定理的核心思想是：

  1. 证明者生成完整的PCP证明 π，但并不直接发送它（因为太大）。
  2. 证明者计算 π 的哈希承诺 c = Hash(π)，并将短小的 c 发送给验证者。
  3. 验证者像普通PCP验证者一样，随机选择要查询的位置 i1, i2, ..., ik。
  4. 证明者不返回整个 π，而是返回这些位置上的比特值 (b1, b2, ..., bk)，并附上这些值对应于承诺 c 的“局部打开证明”。
  5. 验证者验证局部打开证明的有效性，并检查这些比特值是否能使PCP验证算法接受。

通过密码学承诺，证明者被“锁定”在了一个特定的PCP证明 π 上。局部打开特性使得验证者可以在不获取整个 π 的情况下，检查其个别位置的值。这样，我们就将一个庞大的PCP压缩成了一个简短的交互式论证。

关于安全参数与运行时间的讨论

在计算性模型中，安全参数 λ 至关重要。通常我们假设，任何运行时间在 poly(λ) 内的敌手都无法破解所使用的密码学原语（如抗碰撞哈希）。

这引发了一个微妙的问题：为了使论证简洁，我们通常希望通信复杂度是 polylog(n)。如果令 λ ≈ polylog(n)，那么根据可靠性定义，敌手的运行时间上限 poly(λ) ≈ poly(polylog(n)) 可能甚至小于输入长度 n，导致敌手都无法读完输入 x。

这在实际中如何理解？我们可以这样认为：我们定义了一个“计算世界”，在这个世界里，任何实体的运行时间都被限制在 poly(λ) 以内。对于超出这个规模的输入 x，不仅攻击者无法处理，诚实的证明者也无法处理（除非他有更多时间，但我们的安全模型不涉及这种情况）。因此，该理论主要适用于输入规模与安全参数相匹配的场景，或者我们需要更强的密码学假设（例如，假设 2^λ 时间内无法破解）来支持更大的输入规模。

抗碰撞哈希函数

Kilian-Micali构造中需要的一个关键密码学原语是抗碰撞哈希函数族。

一个哈希函数族 H 包含两个算法：

  • 生成算法 Gen(1^λ)：输入安全参数 λ，输出一个哈希密钥 hk。
  • 求值算法 Eval(hk, x)：输入密钥 hk 和任意字符串 x，输出一个固定长度（例如 λ 比特）的哈希值 v。

抗碰撞性要求：对于任何规模为 poly(λ) 的敌手 A，在给定随机生成的哈希密钥 hk 后，A 能找到一对不同的消息 (x, x‘) 使得 Eval(hk, x) = Eval(hk, x’) 的概率是可忽略的。

为什么需要密钥 hk？ 这是为了在非均匀敌手模型下（敌手可以包含任意建议）形式化安全定义。如果使用固定的哈希函数，敌手的建议中可能就包含一个碰撞对。通过引入随机生成的密钥，我们要求敌手对于随机选择的哈希函数难以找到碰撞。

为了用于上述论证系统，我们实际上需要具有局部打开功能的哈希函数（也称为向量承诺）。它允许证明者承诺一个长字符串后，能够高效地生成并验证某个特定位置比特值的证明。标准抗碰撞哈希函数可以用于构造这类承诺方案。

总结与展望

本节课中我们一起学习了：

  1. 低次多项式测试：通过检查函数在随机直线上的限制是否为低次多项式，来判定该函数是否整体上接近某个低次多项式。这是确保PCP见证有效的关键步骤。
  2. 计算性可靠证明（论证）：通过限制敌手的计算能力，并引入密码学假设，我们可以绕过信息论证明中的一些不可能性结果，目标是构建更实用的简洁证明系统。
  3. Kilian-Micali构造：该定理展示了如何将庞大的PCP与抗碰撞哈希函数结合，构造出一个简洁的4消息交互式论证系统，其中验证者效率极高。
  4. 抗碰撞哈希函数：作为核心密码学工具，它允许对长消息进行简短承诺，并保证在计算上难以找到碰撞。

我们目前得到的仍然是交互式论证。在下节课中，我们将深入探讨如何实现非交互式的简洁论证，这需要引入“公共参考字符串”等概念，并向最终的简洁非交互式知识论证目标迈进。

008：Kilian-Micali协议，第一部分

概述

在本节课中，我们将学习如何利用概率可检查证明和密码学原语，构造简洁的交互式论证系统。我们将首先回顾PCP的构造思路，然后介绍一种支持局部打开的碰撞抵抗哈希函数，并展示如何将它们结合，构建出著名的Kilian-Micali协议。

回顾：从GKR协议到PCP

上一节我们介绍了如何利用GKR协议构造概率可检查证明。本节中，我们来看看其核心思路和需要解决的问题。

给定一个NP语言，例如3SAT，我们有一个见证或证明。PCP的目标是将这个证明扩展得更长，但验证时只需读取其中少数几个位置。我们通过模拟GKR协议来构造PCP。

具体来说，给定一个3SAT实例，我们构造一个检查见证是否满足的电路。这个电路深度很低。然后，我们“在脑海中”运行GKR协议。证明者需要为验证者所有可能的问题写下答案，形成一个巨大的树状结构。然而，由于GKR协议中证明者的消息仅依赖于验证者最近的少数消息，这个展开的树实际上只有多项式大小。

PCP包含见证的低次扩展，以及针对所有可能验证者询问的答案。验证时，验证者模拟GKR验证者，随机选择问题并检查PCP中对应的答案，最后还需要检查输入（即见证的低次扩展）在一个随机点上的值。

这里存在一个问题：如果恶意证明者提供的不是某个向量的低次扩展，而是一个高次多项式，那么安全性可能被破坏。因此，验证者需要额外进行一个“低次测试”，以确保提供的函数接近某个低次多项式。这部分内容将在作业中涉及。

PCP虽然庞大，但验证只需读取polylog(n)个位置，是指数级的改进。然而，PCP需要提前提交给验证者，验证者再对其进行查询，这一点对安全性至关重要。如果证明者能根据查询动态选择答案，整个系统就会崩溃。

从PCP到简洁论证：引入密码学

上一节我们得到了一个庞大的PCP，但验证者可能无法存储它。本节中，我们来看看如何利用密码学技术来“压缩”这个证明。

我们使用密码学，特别是碰撞抵抗哈希函数，来压缩这个庞大的证明。但一旦引入密码学，我们就无法保证对抗计算能力无界的敌手的安全性，因此需要将证明系统的概念放宽为计算可靠的证明系统，即交互式论证。

一个针对语言L的交互式论证是一个在证明者和验证者之间的协议。完备性要求：如果x在L中且证明者持有有效见证，则验证者以概率1接受。可靠性（计算可靠性）则要求：对于任何在安全参数λ下规模为多项式的作弊证明者P，对于任何x（可能不在L中），P说服验证者接受的概率是可忽略的。

这里的安全参数λ通常与实例大小n有关。为了使定义有意义，我们可能需要更强的密码学假设（例如亚指数级硬度），以允许λ比n小得多（例如polylog(n)），同时保证对抗运行时间为poly(n)的敌手的安全性。

我们的目标是：为所有NP语言构造一个简洁的交互式论证。我们希望通信复杂度仅随安全参数λ增长，而不是随实例大小n增长。

核心工具：支持局部打开的碰撞抵抗哈希函数

为了构造上述协议，我们需要一个关键的密码学原语：支持局部打开的碰撞抵抗哈希函数。它由以下算法构成：

  1. 生成(Gen)：输入1^λ，输出哈希密钥hk。
  2. 求值(Eval)：输入哈希密钥hk和任意字符串x ∈ {0,1}^*，输出哈希值v ∈ {0,1}^λ。
  3. 打开(Open)：输入哈希密钥hk、字符串x、索引i（1 ≤ i ≤ |x|），输出一个比特b = x_i和一个打开证据ρ。
  4. 验证(Verify)：输入哈希密钥hk、哈希值v、索引i、比特b、打开证据ρ，输出0或1（接受或拒绝）。

它需要满足以下性质：

  • 正确性：对于所有由Gen生成的hk，所有x（满足|x| ≤ 2^λ），所有索引i，有 Verify(hk, Eval(hk, x), i, x_i, Open(hk, x, i)) = 1。
  • 碰撞抵抗性（局部打开版本）：对于任何在时间T(λ)内的敌手A，以下概率可忽略：敌手在获得随机hk后，能输出(v, i, ρ0, ρ1)，使得对于b ∈ {0,1}，都有 Verify(hk, v, i, b, ρb) = 1。这意味着，对于给定的哈希值v和索引i，敌手无法同时为比特0和1生成有效的打开证据。

Kilian-Micali 协议构造

现在，我们利用PCP和支持局部打开的碰撞抵抗哈希函数来构造简洁的交互式论证，即Kilian-Micali协议。假设我们有一个针对NP语言（如3SAT）的PCP系统，其完备性为1，可靠性为可忽略函数。

协议步骤：

  1. 公共输入：安全参数1^λ，问题实例x（例如一个3SAT公式）。证明者P私有输入：见证w。
  2. 第一轮（验证者 → 证明者）：验证者运行Gen(1^λ)生成哈希密钥hk，并发送给证明者。
  3. 第二轮（证明者 → 验证者）：
    • 证明者使用见证w生成对应的PCP字符串π。
    • 证明者计算哈希值 v = Eval(hk, π)。
    • 证明者将v发送给验证者。
  4. 第三轮（验证者 → 证明者）：验证者运行PCP验证算法（针对实例x），生成一组要查询的索引I = (i1, i2, ..., iL)，其中L是查询次数。验证者将I发送给证明者。
  5. 第四轮（证明者 → 验证者）：
    • 对于每个查询索引ij，证明者从PCP字符串π中取出对应的比特 b_j = π[ij]。
    • 证明者计算打开证据 ρ_j = Open(hk, π, ij)。
    • 证明者将所有的(b_j, ρ_j)对发送给验证者。
  6. 验证：验证者执行两项检查：
    • PCP验证：使用实例x和收到的比特(b1, ..., bL)，运行PCP验证算法，检查是否接受。
    • 哈希打开验证：对于每个j，运行 Verify(hk, v, ij, b_j, ρ_j)，检查是否全部接受。
      当且仅当两项检查都通过时，验证者才接受。

协议分析：

  • 完备性：如果证明者诚实，且x在语言中并拥有有效见证w，那么构造的PCP π将通过PCP验证。同时，根据哈希函数的正确性，所有打开证据也会被验证通过。因此，验证者以概率1接受。
  • 简洁性：验证者发送的消息是hk（大小poly(λ)）和索引集合I（大小poly(λ)）。证明者发送的消息是哈希值v（大小λ）和打开证据对（总大小poly(λ)）。因此，通信复杂度为poly(λ)。如果设置λ = polylog(n)，则通信复杂度为polylog(n)，实现了简洁性。
  • 可靠性（直观）：如果一个作弊证明者对于不在语言中的x能以不可忽略的概率ε让验证者接受，那么我们可以利用它来破坏哈希函数的碰撞抵抗性。核心思想是：多次“回滚”并询问作弊证明者。如果它能在不同次询问中为同一个位置i打开成不同的比特（0和1），我们就直接找到了哈希函数的碰撞。如果它总是为同一位置打开相同的比特，那么这些响应实际上定义了一个（部分定义的）PCP字符串。由于作弊证明者成功概率为ε，这个PCP字符串被PCP验证者接受的概率也约为ε，这与PCP系统的可靠性（接受假陈述的概率可忽略）相矛盾。因此，作弊证明者成功意味着必然能以高效的方式找到哈希碰撞，这与我们的密码学假设矛盾。

关于可靠性证明，有一个技术细节：上述直观证明需要构造整个PCP字符串，其时间可能与实例大小n相关。如果哈希函数的安全性只针对时间T(λ) < n的敌手，则会产生问题。后续有更精巧的证明（如Barak和Goldreich的工作）避免了显式构造整个PCP，使证明更加严谨。

总结

本节课我们一起学习了构建简洁交互式论证的核心框架——Kilian-Micali协议。

  1. 我们首先回顾了如何从GKR协议构造PCP，并指出了其中低次测试的必要性。
  2. 我们引入了计算可靠性的概念，即交互式论证，以适应密码学假设。
  3. 我们定义了一个关键的密码学构件：支持局部打开的碰撞抵抗哈希函数，它允许验证者仅检查庞大字符串的少量比特。
  4. 最后，我们展示了如何将PCP与该哈希函数结合，构造出Kilian-Micali协议，实现了通信复杂度仅依赖于安全参数的简洁论证，并概述了其安全性的证明思路。

下一节课，我们将探讨如何进一步优化这个协议，并可能消除交互性。

009：Kilian-Micali协议，第二部分

在本节课中，我们将继续探讨Kilian-Micali协议，并深入理解其背后的密码学构造。我们将首先解释交互式证明与论证在术语上的微妙区别，然后简要介绍Barak-Goldreich的通用论证思想，最后重点学习如何基于离散对数问题构造一个具有局部打开功能的抗碰撞哈希函数。

交互式证明与论证：术语差异的缘由

上一节我们介绍了交互式证明和论证的基本概念。现在我们来探讨一个术语上的重要区别：为什么在交互式证明中我们谈论“一半”的可靠性，而在论证中我们直接要求“可忽略”的可靠性？

问题的核心在于并行重复的放大效果。对于交互式证明，如果你并行重复协议 λ 次，可靠性会呈指数级下降，从 1/2 变为 1/2^λ，这符合我们的直觉。

然而，对于论证，情况并非总是如此。一旦我们进入密码学的领域，事情就变得有些微妙。并非所有论证在并行重复 λ 次后，可靠性都会从 1/2 下降到 1/2^λ。虽然存在反例，但这些反例都是人为构造的、不自然的论证。对于任何“自然”的论证，可靠性很可能在并行重复后呈指数级下降，但我们不能总是依赖这一点。

我们可以进行顺序重复。如果你顺序地执行交互式论证 λ 次，并且仅当所有次都接受时才最终接受，那么可靠性确实会呈指数级下降。但代价是，轮数复杂度从常数 K 增加到了非常数 λ。因此，这种放大并非“免费”的。这就是为什么在论证的语境中，我们直接要求可靠性是可忽略的，而不是像证明中那样先设定一个常数再放大。

Barak-Goldreich 通用论证的高层思想

在深入构造哈希函数之前，我们先简要了解一下Barak-Goldreich的“通用论证”的核心思想，这为我们后续的高效构造提供了灵感。

他们的证明试图更高效地找到哈希函数的碰撞。回顾之前的证明思路：如果没有碰撞，我们就尝试构造一个完整的PCP（概率可检查证明），从而得出矛盾。但这需要运行与PCP大小成正比的时间。

Barak-Goldreich的方法则更为巧妙。他们不是一次性处理整个PCP，而是逐个索引（index）地进行分析。假设PCP的长度为 M，他们关注PCP在某个特定位置 I 上的行为。

以下是他们的核心思路：

  1. 提出问题：对于一个固定的索引 I，多次运行验证过程（确保查询集合包含 I）。观察作弊证明者在所有正确回答的轮次中，对于位置 I 的答案是否始终是同一个比特。
  2. 定义“好”与“坏”索引：
    • 如果一个索引 I 上，作弊证明者几乎总是给出相同答案（即行为一致），则称该索引为“好”的。
    • 如果一个索引 I 上，作弊证明者以不可忽略的概率给出不同答案（即行为不一致），则称该索引为“坏”的。
  3. 关键论证：他们证明，必须有相当数量的索引是“坏”的。如果几乎所有索引都是“好”的，那么就可以利用这些“好”索引（行为一致的部分）来重构出一个有效的PCP，从而导致协议以高概率被接受，这与作弊证明者最初成功的假设矛盾。
  4. 利用“坏”索引寻找碰撞：一旦确立了存在足够多的“坏”索引，攻击者只需随机选择一个索引 I，然后生成两个包含 I 的随机查询集合，并运行作弊证明者两次。由于 I 是“坏”的，它以不可忽略的概率会在两次运行中对 I 给出不同答案，这就直接导致了哈希函数碰撞的发现。

这种方法的高明之处在于，攻击者的运行时间独立于原始PCP的大小 N，而仅与安全参数 λ 相关。正是这种与问题实例大小无关的特性，使得该论证被称为“通用”的。

构建哈希函数：从离散对数问题出发

现在，让我们开始构建我们所需的哈希函数。我们的目标是构造一个满足以下条件的哈希函数族：

  1. 定义域为任意长的比特串 {0,1}*。
  2. 值域为固定长的比特串 {0,1}^λ。
  3. 具有局部打开功能。
  4. 满足抗碰撞性。

我们将分两步走：首先构建一个简单的、不具备局部打开功能且定义域受限的抗碰撞哈希函数；然后通过一个通用变换（Merkle树）将其扩展为我们最终想要的形态。

第一步：基础抗碰撞哈希函数

我们基于离散对数问题的困难性来构造一个简单的哈希函数。

离散对数假设：
存在一个阶（元素个数）约为 2^λ 的群 G。给定一个生成元 g 和一个随机群元素 h = g^x，对于任何多项式时间的敌手，找到指数 x 的概率是可忽略的。
用公式表示：
Pr[ A(g, h=g^x) = x ] ≤ negl(λ)
其中，x 是从群阶的范围内随机选取的。

一个典型的例子是：令 p 为一个安全素数（p = 2q + 1，其中 q 也是素数），群 G 为模 p 的二次剩余子群。这个群的阶就是 q。

哈希函数构造：

  • 密钥生成 Gen(1^λ)：随机选取一个群元素 h ← G。哈希密钥 hk 就是 h。
  • 求值 Eval(hk, x)：这里输入 x 被限制为来自 Z_q × Z_q（可以理解为两个 λ 比特串）。将 x 解析为 (x0, x1)。
    • 计算并输出 y = g^(x0) * h^(x1)。
    • 注意，y 也是群 G 中的一个元素。我们可以将其编码为 λ 比特的字符串（例如，在二次剩余群的例子中，取模 p 下的最小平方根）。因此，这个函数将 2λ 比特的输入映射到了 λ 比特的输出。

为什么它是抗碰撞的？
我们可以通过归约来证明。假设存在一个敌手 B 能够找到该哈希函数的碰撞，那么我们可以构造一个敌手 A 来破解离散对数问题。

  1. A 收到离散对数挑战 (g, h)，其中 h = g^x，x 未知。
  2. A 将 h 作为哈希密钥 hk 发送给碰撞寻找者 B。
  3. B 成功输出一个碰撞：两对不同的 (x0, x1) ≠ (x0‘, x1’)，使得 g^(x0) * h^(x1) = g^(x0‘) * h^(x1’)。
  4. A 利用这个等式计算 x：
    • 将等式变形为：g^(x0 - x0‘) = h^(x1’ - x1)。
    • 这意味着 h = g^((x0 - x0‘) / (x1’ - x1))，其中除法是在模群阶 q 的意义下进行的。
    • 因此，离散对数 x = (x0 - x0‘) * (x1’ - x1)^(-1) mod q。
    • 由于是碰撞，(x1‘ - x1) ≠ 0，且在素数阶群中该值可逆，所以计算有效。

这样，A 就利用 B 找到了离散对数 x，这与离散对数假设矛盾。因此，这样的碰撞寻找者 B 不可能存在，该哈希函数是抗碰撞的。

当前构造的不足：

  1. 定义域受限，仅为 Z_q × Z_q（约 2λ 比特）。
  2. 没有局部打开功能。

第二步：通过 Merkle 树实现域扩展与局部打开

为了克服上述不足，我们使用 Merkle 哈希树，这是一个巧妙而简单的想法。我们将使用第一步中的哈希函数 H: {0,1}^(2λ) -> {0,1}^λ 作为构建块。

总体思路：
将长输入分割成多个 λ 比特的块。然后像二叉树一样，反复应用基础哈希函数 H，将两个子节点的哈希值合并计算其父节点的哈希值，最终得到一个树根（root）哈希值。

具体构造：

  • 密钥生成：与基础哈希函数相同，Gen(1^λ) 输出 hk。
  • 求值 Eval(hk, x)：
    1. 填充：对输入 x 进行填充，确保其长度是 λ * 2^L（即块数是 2 的幂）。一种标准方法是附加一个“1”比特，然后附加足够多的“0”比特以达到目标长度。
    2. 构建 Merkle 树：
      • 将填充后的消息分成 λ 比特的块，作为树的叶子节点。
      • 对于每一对兄弟节点（哈希值 a 和 b），计算其父节点的哈希值：parent = H(hk, a || b)。
      • 递归地进行此过程，直到计算出唯一的根节点哈希值 root。
    3. 输出：输出最终的哈希值 (root, depth)，其中 depth = L 是树的深度。包含深度对于防止某些类型的碰撞攻击至关重要（例如，将单个节点的哈希值谎称为整个树的根）。
  • 打开 Open(hk, x, i)：
    • 假设我们想打开第 i 个数据块（叶子节点）。
    • 打开证据 π 由从该叶子节点到根节点的路径上，所有兄弟节点的哈希值组成。
    • 例如，要打开图中绿色的叶子节点，证据包括图中标出的所有绿色方块（其路径上的兄弟节点的哈希值）。
  • 验证 Verify(hk, root, depth, i, block_i, π)：
    • 验证者拥有 block_i（声称的第 i 块数据）和证据 π（一串兄弟哈希值）。
    • 验证者利用 block_i 和 π 中的第一个兄弟哈希值，计算其父节点哈希值。
    • 然后，用计算出的父节点哈希值与 π 中的下一个兄弟哈希值，计算再上一级的父节点哈希值。
    • 重复此过程，直到计算出根哈希值。
    • 如果计算出的根哈希值与给定的 root 一致，并且计算过程中涉及的深度与给定的 depth 一致，则验证通过。

为什么扩展后的构造仍是抗碰撞的？
直观上，如果在 Merkle 树中找到碰撞（两个不同的输入产生相同的 (root, depth) 对），那么沿着这两棵树从根向下比较，必定能在某个节点上找到基础哈希函数 H 的一个碰撞。这是一个归约论证，我们将在下次课中详细展开。局部打开的安全性也源于此：如果能对同一个根和位置打开两个不同的块，也意味着找到了基础哈希函数的碰撞。

总结

本节课中我们一起学习了：

  1. 交互式论证与证明的细微差别：重点在于并行重复对可靠性放大的有效性在论证中并非总是成立，因此我们直接要求可忽略的可靠性。
  2. Barak-Goldreich 通用论证的核心洞见：通过逐个索引分析PCP证明者的行为，高效地将哈希函数碰撞寻找问题归约到“坏”索引的存在性上，从而实现了与实例大小无关的攻击时间。
  3. 基于离散对数的哈希函数构造：我们首先构建了一个定义域受限的基础抗碰撞哈希函数 H(x0, x1) = g^(x0) * h^(x1)，其安全性归约于离散对数问题的困难性。
  4. 利用 Merkle 树进行扩展：我们展示了如何使用基础哈希函数 H 构建 Merkle 树，从而将定义域扩展到任意长度，并同时获得了局部打开功能。最终构造的输出包含根哈希值和树深度，其安全性最终仍依赖于基础哈希函数 H 的抗碰撞性。

通过这一系列步骤，我们为理解 Kilian-Micali 协议中所需的密码学组件奠定了坚实的基础。在下节课中，我们将完成 Merkle 树安全性的归约证明，并最终将这些部分组合起来。

010：Fiat-Shamir 范式与零知识证明（第一部分）

概述

在本节课中，我们将要学习如何将交互式论证转换为非交互式论证。首先，我们将回顾并完成对 Merkle 哈希构造的讨论，证明其碰撞抗性。接着，我们将介绍 Fiat-Shamir 范式，这是一种消除交互的通用方法。为了分析其安全性，我们将引入随机预言机模型，并探讨其在实际应用中的意义。最后，我们将通过一个具体的零知识证明协议示例，来理解这些概念的实际应用。

Merkle 哈希的碰撞抗性证明

上一节我们介绍了 Merkle 哈希的构造，它能够将任意长度的输入压缩成一个固定大小的摘要，并支持局部打开验证。本节中，我们来证明这个构造是碰撞抗性的。

碰撞抗性定义

一个哈希函数是碰撞抗性的，意味着对于任何多项式时间的敌手，给定哈希密钥 hk，他找到两个不同的输入 x 和 x' 使得 Eval(hk, x) = Eval(hk, x') 的概率是可忽略的。

证明思路

假设存在一个敌手 A 能够以不可忽略的概率 ε 找到 Merkle 哈希的碰撞。我们将利用 A 来构造另一个敌手 B，B 能够以相同的概率 ε 找到底层哈希函数的碰撞，这与底层哈希函数的碰撞抗性假设矛盾。

构造敌手 B：

  1. B 接收到底层哈希函数的密钥 hk。
  2. B 运行敌手 A，A 输出一个 Merkle 哈希值（根 root 和深度 d）、一个索引 i 以及两个有效的打开证明 π0 和 π1，分别证明第 i 位是 0 和 1。
  3. 由于两个打开证明都被验证算法接受，我们知道在叶子层（第 0 层），π0 和 π1 对应的数据块 z0_0 和 z1_0 是不同的（因为一个声称是 0，另一个是 1）。
  4. 同时，在根层（第 d 层），π0 和 π1 对应的值 z0_d 和 z1_d 是相同的（都是 root）。
  5. 因此，必然存在一个层级 j，使得在 j 层，z0_j ≠ z1_j，但在 j+1 层，z0_{j+1} = z1_{j+1}。
  6. 根据 Merkle 树的构造，z0_{j+1} 是 z0_j 及其兄弟节点的哈希值，z1_{j+1} 是 z1_j 及其兄弟节点的哈希值。既然 z0_{j+1} = z1_{j+1}，而 z0_j ≠ z1_j，那么 (z0_j, sibling) 和 (z1_j, sibling) 就构成了底层哈希函数的一个碰撞。
  7. B 输出这对碰撞。

由于 B 的成功概率与 A 相同，如果 A 能以不可忽略的概率找到 Merkle 哈希的碰撞，那么 B 也能以相同的概率找到底层哈希函数的碰撞，这与假设矛盾。因此，Merkle 哈希是碰撞抗性的。

消除交互：Fiat-Shamir 范式

我们已经有了一个简洁的交互式论证（如 Kilian-Micali 协议）。然而，交互式证明在实际应用中并不方便，例如，它无法向所有人同时证明一个陈述。本节中，我们来看看如何利用 Fiat-Shamir 范式来消除交互。

Fiat-Shamir 范式原理

Fiat-Shamir 范式适用于公开掷币的交互式协议。在这种协议中，验证者的消息完全是随机的。

假设我们有一个三轮的公开掷币交互协议：

  1. 证明者发送消息 α。
  2. 验证者发送随机挑战 β。
  3. 证明者发送应答 γ。

Fiat-Shamir 范式将其转换为非交互式协议的方法如下：

  1. 各方预先商定一个哈希密钥 hk（例如，由一个可信机构发布一个标准哈希函数）。
  2. 证明者计算第一轮消息 α。
  3. 证明者模拟验证者的挑战：β = Hash(hk, (x, α))，其中 x 是要证明的陈述。
  4. 证明者计算应答 γ。
  5. 证明者将最终的证明 π = (α, γ) 发送给验证者。
  6. 验证者收到 π 后，自行计算 β' = Hash(hk, (x, α))，然后运行原验证算法检查 (α, β', γ) 是否有效。

其核心思想是：用哈希函数对当前“转录本”（即到目前为止的所有消息）的哈希值，来替代验证者原本应随机生成的挑战。

安全性考量

这个范式非常简洁高效，在实践中被广泛使用。然而，其安全性并非无条件成立。我们需要问：这个哈希函数需要具备什么性质，才能保证转换后的非交互协议是可靠的？

原交互协议的安全性依赖于验证者挑战 β 的随机性。在 Fiat-Shamir 转换中，β 由哈希函数产生。因此，直观上，我们需要哈希函数的输出“看起来是随机的”，并且证明者无法预测或操控这个输出。

不幸的是，存在一些精心构造的（不自然的）交互协议和哈希函数族，使得无论使用哪个哈希函数，应用 Fiat-Shamir 范式后协议都会变得不安全。这些反例表明，我们无法为 Fiat-Shamir 范式找到一个适用于所有协议的通用安全性证明。

尽管如此，对于大多数“自然”的协议（包括 Kilian-Micali 协议）和实践中使用的标准哈希函数（如 SHA-256），Fiat-Shamir 范式被认为是安全且被广泛采用的。

随机预言机模型

为了在理论上分析 Fiat-Shamir 范式的安全性，密码学家引入了随机预言机模型。这是一种理想化的计算模型。

模型定义

在随机预言机模型中，我们假设所有参与者都可以访问一个完全随机的函数 H。这个函数：

  • 对于任何输入，输出一个真正均匀随机的值。
  • 对于相同的输入，总是返回相同的输出（即它是确定性的）。
  • 只能通过“查询”来访问，无法窥探其内部状态。

在这个模型中应用 Fiat-Shamir 范式时，我们使用这个随机预言机 H 来代替具体的哈希函数计算挑战，即 β = H(x, α)。

模型的意义

随机预言机模型提供了一个“最佳可能”的哈希函数环境。如果 Fiat-Shamir 转换在随机预言机模型下被证明是安全的，那么我们可以合理地期望，当使用一个设计良好的、密码学安全的哈希函数实例化时，该转换在实际中也是安全的。

然而，需要明确的是，随机预言机模型是一个理想模型。现实中不存在真正的随机预言机，任何具体的哈希函数都是一个确定的、可被描述的算法。因此，在随机预言机模型下证明的安全，并不能直接等价于标准模型下的安全。尽管如此，它仍然是分析和设计密码方案的一个非常强大且有用的工具。

一个案例：哈密顿环的零知识证明

为了更具体地理解交互协议以及 Fiat-Shamir 范式的应用，让我们看一个经典的零知识证明协议示例：证明一个图 G 包含哈密顿环。

协议描述（交互式）

该协议由 Blum 提出，是一个三轮公开掷币协议。

共同输入：图 G（包含 n 个顶点）。
证明者目标：向验证者证明 G 包含一个哈密顿环，但不泄露环的具体信息。

协议步骤：

  1. 证明者：
    • 随机选择一个顶点排列 π。
    • 计算排列后的图 π(G)。
    • 构造一个 n x n 的承诺矩阵 C。C 中仅在构成哈密顿环的边上放置承诺值 1，其他位置放置承诺值 0。承诺方案保证在打开前，验证者不知道承诺的内容。
    • 将承诺矩阵 C 发送给验证者。
  2. 验证者：
    • 随机选择一个挑战比特 b ∈ {0, 1}，发送给证明者。
  3. 证明者根据 b 进行应答：
    • 如果 b = 0：证明者打开所有承诺，展示整个矩阵 C。验证者检查 C 是否恰好包含一个简单的环（且每个顶点度数为2）。
    • 如果 b = 1：证明者发送排列 π，并仅打开 C 中对应于 π(G) 中不存在的边的那些位置的承诺。验证者检查所有这些被打开的承诺值是否为 0，并验证 π 是否是一个有效的排列。

协议分析

  • 完备性：如果证明者诚实且 G 有哈密顿环，他总能通过验证。
  • 可靠性（Soundness）：如果 G 没有哈密顿环，一个作弊的证明者无法同时应对 b=0 和 b=1 的挑战。
    • 要过 b=0 这关，他必须承诺一个完整的环。
    • 要过 b=1 这关，他承诺的环必须全部落在 π(G) 的边集内。
    • 由于 G 无哈密顿环，π(G) 也没有。因此，任何环都至少包含一条 π(G) 中不存在的边。当 b=1 时，验证者要求打开这些非边的承诺，作弊者将暴露承诺值 1（应为 0）而被拒绝。
    • 因此，作弊者成功欺骗的概率最多为 1/2。通过顺序重复该协议 k 次，可将欺骗概率降至 2^{-k}。
  • 零知识性：直观上，无论验证者选择 b=0 还是 b=1，他从应答中看到的要么是一个随机的环（与 G 无关），要么是一个随机排列和一堆 0 值，这些都可以由验证者自行模拟生成，不泄露关于原图哈密顿环的任何信息。

应用 Fiat-Shamir 范式

我们可以将上述三轮交互协议转换为非交互式：

  1. 证明者计算承诺矩阵 C（相当于 α）。
  2. 证明者使用随机预言机（或一个哈希函数）计算挑战：b = H(G, C)。
  3. 证明者根据 b 的值生成相应的应答 γ（要么打开全部承诺，要么发送 π 并打开部分承诺）。
  4. 证明者发送非交互证明 π_nizk = (C, γ)。
  5. 验证者收到后，重新计算 b' = H(G, C)，然后验证 γ 对于挑战 b' 是否有效。

这个非交互式协议在随机预言机模型下可以被证明是安全的。

总结

本节课中我们一起学习了几个核心内容：

  1. 完成了 Merkle 哈希的安全性证明，理解了如何通过归约法证明其碰撞抗性依赖于底层哈希函数。
  2. 引入了 Fiat-Shamir 范式，掌握了将公开掷币交互式协议转换为非交互式协议的一般方法。
  3. 认识了随机预言机模型，理解了它作为分析哈希函数理想行为的理论工具的价值和局限性。
  4. 通过哈密顿环的零知识证明协议，具体观察了一个交互式协议的结构、安全性属性以及如何对其应用 Fiat-Shamir 转换。

这些概念是现代密码学，特别是零知识证明和 succinct 论证领域的基石。在下一节课中，我们将继续探讨 Fiat-Shamir 范式在标准模型下的安全性，并深入零知识证明的更多性质。

011：Fiat-Shamir范式与零知识证明（第二部分）

在本节课中，我们将继续探讨Fiat-Shamir范式在随机预言机模型中的安全性。我们将分析一个具有可忽略性完备性的交互式协议，在应用Fiat-Shamir转换后，其安全性如何依赖于协议的轮数。我们还将简要介绍“逐轮完备性”的概念，并探讨零知识证明与Fiat-Shamir范式安全性之间的有趣联系。

回顾：Fiat-Shamir与零知识证明

上一节我们介绍了如何将一个交互式零知识证明协议（例如哈密顿环证明）转换为非交互式证明。我们注意到，该协议的单次运行具有1/2的完备性误差。为了获得可忽略的误差，我们可以将其顺序重复λ次。

现在，让我们看看如果对其应用Fiat-Shamir范式会发生什么。我们将在随机预言机模型中进行分析，因为直觉上，如果验证者发送的是随机比特，那么用哈希函数模拟这个随机比特也应该保持安全性。

然而，事实并非总是如此。让我们通过一个例子来看看作弊者如何在随机预言机模型中轻易作弊。

在随机预言机模型中作弊

假设图G没有哈密顿环。作弊证明者P*可以执行以下操作：

  1. 猜测哈希函数的输出比特b（例如，猜测b=0）。
  2. 根据猜测的b来准备承诺：
    • 如果猜测b=0，则承诺一个随机的环（因为会被要求打开环）。
    • 如果猜测b=1，则承诺全零（因为会被要求打开所有边，显示0）。
  3. 将输入x和承诺α送入哈希函数H，得到输出比特b'。
  4. 检查b'是否等于猜测的b。
    • 如果相等，则成功生成有效的证明。
    • 如果不相等，则回到第1步，用新的随机猜测重试。

关键在于：在交互式协议中，证明者只有一次尝试机会。但在随机预言机模型中，作弊者可以反复查询哈希函数（随机预言机），直到猜对为止。由于平均只需尝试2次，作弊者就能高效地生成一个看似有效的证明。

因此，我们学到：即使原协议具有可忽略的完备性误差，在随机预言机模型中直接应用Fiat-Shamir也可能是不安全的，因为作弊者可以利用预言机进行多次尝试。

Fiat-Shamir安全性的正式定理

那么，Fiat-Shamir范式何时在随机预言机模型中安全呢？以下是核心定理：

定理：在随机预言机模型中，Fiat-Shamir范式是安全的（即保持完备性），如果底层的公开掷币交互式协议满足：

  1. 具有可忽略的完备性误差。
  2. 具有常数轮数。

这个定理不是“当且仅当”。存在一些多轮协议（例如GKR协议），由于其具有“逐轮完备性”，也能安全地应用Fiat-Shamir。但今天我们主要关注常数轮协议。

定理证明（以三轮协议为例）

让我们证明为什么对于具有可忽略误差的三轮公开掷币协议，Fiat-Shamir在随机预言机模型中是安全的。

设定：

  • 设原协议为三轮：证明者发送α，验证者回复随机比特β，证明者最后发送γ，验证者决定接受或拒绝。
  • 假设应用Fiat-Shamir后，存在一个多项式时间的作弊证明者P*，对于某个不在语言中的x，能以不可忽略的概率ε欺骗验证者。

目标：利用P*构造一个作弊者P**，使其能在原交互式协议中以不可忽略的概率作弊，这与原协议具有可忽略完备性误差的假设矛盾。

证明思路：

  1. P*在运行中会向随机预言机H发起多项式次查询（设最多Q次）。记这些查询为(x, α1), (x, α2), ..., (x, αQ)。
  2. 观察：如果P*成功输出一个被接受的转录本(α, β, γ)，但其中的α不在它查询过的{αi}之中，那么它等于在没有询问H的情况下猜中了β = H(x, α)。这种情况发生的概率至多是2^{-|β|}（例如，β是单比特则为1/2），是可忽略的。
  3. 因此，P*的成功几乎总是依赖于它查询过的某个α_i。
  4. 现在构造交互式协议作弊者P**：
    • P**随机猜测一个索引 i ∈ {1, ..., Q}。
    • P**开始运行P*，并为其模拟随机预言机H：
      • 当P*查询(x, α_j)时，如果 j ≠ i，则P**返回一个随机的β_j。
      • 当P*查询(x, α_i)时（即猜中的那次），P**将暂停，并将α_i作为自己的第一条消息发送给外部验证者V，并从V那里收到真实的随机比特β。
      • P**将这个真实的β作为对查询(x, α_i)的回复返回给P*。
    • P**继续模拟，直到P*输出一个转录本(α, β, γ)。
    • 如果α = α_i（即猜中了P*成功所依赖的那个查询），那么P就将γ作为自己的最后一条消息发送给V。否则，P失败。
  5. 成功概率分析：
    • P*成功的概率为ε。
    • 在P*成功的情况下，其转录本中的α以压倒性概率是某个α_i。
    • P**随机猜中这个特定i的概率至少是1/Q。
    • 因此，P**在原交互式协议中成功的概率至少是ε/Q - negl。
    • 由于ε是不可忽略的，Q是多项式的，所以ε/Q也是不可忽略的。这与原协议具有可忽略完备性误差的假设矛盾。

扩展到多轮：对于具有C轮（C为常数）的协议，证明思路类似。作弊者P**需要在每一轮都猜中P*成功所依赖的预言机查询索引。成功概率会衰减为大约ε / Q^C。只要原协议的完备性误差远小于1/Q^C，矛盾依然成立。

从随机预言机模型到标准模型

上述证明严重依赖于随机预言机模型，特别是我们可以“看到”作弊者所有的预言机查询。一个自然的问题是：是否存在一个具体的哈希函数族，使得Fiat-Shamir范式在标准模型下也是安全的？

对于Kilian-Micali证明系统（一个四轮、具有可忽略误差的协议），在随机预言机模型中是安全的。但在标准模型中，情况更为复杂。

存在一些协议（如基于某些承诺方案的哈密顿环证明的并行重复版本），它们在随机预言机模型中是安全的，但对于任何具体的哈希函数族，在标准模型下都不安全。这表明随机预言机模型是一个有用的启发式工具和“健全性检查”，但它并不能保证标准模型下的安全性。

尽管如此，在实践中，经过随机预言机模型安全性分析的结构被广泛使用，且尚未出现因模型本身缺陷而导致的实际攻击。实际中的安全漏洞更多源于实现错误、随机数生成不佳等问题，而非密码学原语本身的突破。

并行重复与零知识证明的冲突

最后，我们探讨一个有趣的现象：零知识证明与Fiat-Shamir范式安全性之间的冲突。

回顾我们的哈密顿环零知识证明。如果将其顺序重复λ次，它仍然是零知识的。模拟器可以逐轮模拟：猜测验证者的挑战β，如果猜错就回滚重试。

但是，如果将其并行重复λ次（即同时发送λ个承诺，然后接收λ个挑战比特，再同时打开），情况就不同了。一个恶意的验证者V*可以使用一个哈希函数H来计算他的挑战比特β：β = H(所有λ个承诺)。

问题：模拟器如何模拟这个对话？模拟器需要一次性猜对所有λ个挑战比特，或者能够找到一个承诺集合，使得其哈希结果恰好是某个预期的挑战向量。这看起来非常困难。

事实上，对于这个特定的协议（基于特定承诺方案），一个2019年的突破性结果证明：其并行重复版本在应用Fiat-Shamir后，在标准模型下可以是安全的（基于某些密码学假设）。而这意味着它不可能是零知识的。

简要论证：

  1. 假设该并行重复协议是零知识的，则存在一个模拟器Sim，对于语言中的任何输入x，都能生成与真实交互不可区分的转录本，该转录本会被验证者接受。
  2. 考虑一个使用安全Fiat-Shamir哈希函数H的验证者V*。他的挑战就是H(承诺)。
  3. 根据零知识性质，Sim必须能够为语言中的x模拟出与V*交互的视图，并输出一个被接受的转录本(α, β, γ)，其中β = H(α)。
  4. 现在，如果Sim也能为某个不在语言中的x'（或者随机x）输出一个被接受的转录本，那么Sim就打破了Fiat-Shamir的安全性（因为它产生了伪造的证明）。
  5. 由于Sim是多项式时间的，它无法区分x是否在语言中（否则就解决了NP问题）。因此，如果Sim能为在语言中的x成功模拟，那么它也必须能为某些不在语言中的x产生被接受的输出，从而破坏安全性。
  6. 由此可知，如果Fiat-Shamir对于该协议是安全的（即不存在这样的作弊Sim），那么该协议就不可能是（并行的）零知识。

这个结论揭示了非交互式证明系统（通过Fiat-Shamir获得）与零知识性质之间内在的张力。

总结

本节课中，我们一起学习了：

  1. Fiat-Shamir在随机预言机模型中的安全性条件：要求底层交互式协议具有可忽略的完备性误差和常数轮数。我们通过反证法概述了其证明。
  2. 标准模型下的安全性：随机预言机模型下的安全性不能直接推出标准模型下的安全性，存在反例。但它是一个重要的实践指南。
  3. 并行重复、Fiat-Shamir与零知识的联系：对于一个特定的零知识协议，其并行重复版本应用Fiat-Shamir后可能获得标准模型下的安全性，而这份安全性恰恰排除了它成为零知识证明的可能性。这展示了密码学中不同安全属性之间深刻而有时令人惊讶的相互作用。

下一讲，我们将更深入地探讨如何证明特定协议在Fiat-Shamir转换下的具体安全性。

012：标准模型中 Fiat-Shamir 范式可靠性证明（第一部分）🔐

在本节课中，我们将要学习如何证明 Fiat-Shamir 范式在标准模型中的可靠性。我们将从一个具体的零知识证明协议入手，探讨如何通过巧妙的构造，使其在应用 Fiat-Shamir 变换后依然保持安全性。

课程概述与回顾

上一节我们介绍了 Fiat-Shamir 范式，它通过用哈希函数替代验证者的随机挑战，将交互式证明转化为非交互式证明。然而，一个核心问题是：当使用具体的哈希函数（而非随机预言机）时，这种变换是否依然可靠？

我们之前已经证明，对于 Kim-Micali 协议，在随机预言机模型下应用 Fiat-Shamir 范式是可靠的。但在实际应用中，我们需要在标准模型（即使用具体可计算的哈希函数）下证明其可靠性。这是一个长期存在的开放性问题，因为 Fiat-Shamir 范式在实践中被广泛使用，理解其安全性至关重要。

核心协议：并行重复的汉密尔顿回路零知识证明

为了进行证明，我们首先需要回顾一个具体的交互式零知识证明协议。该协议用于证明一个图 G 包含汉密尔顿回路（一个 NP 完全问题）。这是一个三消息协议：

  1. 证明者选择一个随机置换 π，并提交置换后的图 π(G) 以及其中的汉密尔顿回路（如果存在）。
  2. 验证者随机发送一个挑战比特 b ∈ {0, 1}。
  3. 如果 b=0，证明者打开承诺，展示置换后的回路；如果 b=1，证明者展示置换 π 并打开所有非边位置的承诺。

该协议是零知识的，但其可靠性仅为 1/2（即作弊证明者有 1/2 的概率成功欺骗）。为了达到可忽略的可靠性错误，我们需要进行 λ（安全参数）次并行重复。在本节课中，当我们提及协议 P 和 V 时，均指代这个并行重复后的版本。

Fiat-Shamir 变换的挑战

Fiat-Shamir 范式将上述交互式协议转化为非交互式协议：证明者生成第一条消息 α，然后通过哈希函数 H(α) 计算出挑战 β，最后生成响应 γ。整个证明就是三元组 (α, β, γ)。

我们的目标是：构造一个具体的哈希函数 H，使得对于任何不在语言中的陈述 x（即图 G 没有汉密尔顿回路），任何多项式时间的作弊证明者都无法生成一个能被验证者接受的证明 (α, β, γ)。

一个直观的观察是：在并行重复的协议中，对于证明者发送的每条第一条消息 α，存在唯一一个“坏”的挑战 β_bad，使得如果验证者恰好发送这个挑战，作弊证明者就能成功应答。对于所有其他挑战，作弊证明者都会失败。

因此，哈希函数 H 的核心任务似乎很简单：对于每个 α，确保 H(α) ≠ β_bad(α)。如果我们能构造这样一个 H，那么作弊证明者就永远无法命中那个能让他作弊的挑战，从而保证了可靠性。

构造可靠哈希函数的初步尝试与障碍

一个最直接的想法是让哈希函数计算 H(α) = β_bad(α) + 1（或任何其他不等于 β_bad(α) 的值）。然而，这存在一个根本性问题：计算函数 β_bad(α) 本身是困难的。

在汉密尔顿回路协议中，β_bad(α) 取决于承诺 α 中所隐藏的内容（即置换后的图中是否存在汉密尔顿回路）。如果没有打开承诺的“陷门”信息（例如加密方案的私钥），计算 β_bad(α) 就如同解决一个 NP 难题。如果计算 β_bad(α) 是容易的，那么整个交互协议就没有必要了，我们可以直接构造一个非交互式证明。

因此，我们需要一种方法，使得哈希函数在不知道陷门的情况下，依然能够“避开”坏挑战。

关键思路：陷门承诺与全同态加密

接下来的思路分为两步：

  1. 使用带陷门的承诺方案：我们将协议中的承诺替换为一种公钥加密方案。公钥作为公共参考字符串公开。证明者使用公钥加密他的消息（置换和边信息）。这个加密方案起到了承诺的作用：它是隐藏的（语义安全），也是绑定的（因为解密是确定的）。更重要的是，对应公钥的私钥成为了一个“陷门”，拥有它的人可以解密承诺，从而轻松计算出 β_bad(α)。
  2. 在全同态加密下“隐藏地”使用陷门：我们不能直接将私钥（陷门）硬编码到哈希函数 H 中，因为这会破坏协议的零知识性。论文 [C-LW19] 提出了一个精妙的解决方案：让哈希函数的密钥包含一个全同态加密（FHE）的密文，这个密文加密了某个电路 G。

首先，我们简要定义全同态加密（FHE）。一个 FHE 方案除了包含标准的密钥生成 (pk, sk) <- Gen()、加密 c <- Enc(pk, m) 和解密 m <- Dec(sk, c) 算法外，还有一个评估算法 Eval：

c* = Eval(pk, C, c1, ..., cn)

其中 c1, ..., cn 是分别加密了比特 b1, ..., bn 的密文，C 是一个布尔电路。评估算法输出一个新密文 c*，使得 Dec(sk, c*) = C(b1, ..., bn)。也就是说，FHE 允许对加密数据进行任意计算。

哈希函数的构造与安全性证明概要

基于 FHE，我们构造 Fiat-Shamir 哈希函数 H 如下：

  • 哈希密钥 hk：生成一个 FHE 的公私钥对 (fpk, fsk)。然后，加密一个全零电路（或其描述）G0，得到密文 hat{G0} = Enc(fpk, G0)。哈希密钥就是 hk = (fpk, hat{G0})。
  • 哈希计算 H(hk, α)：为了计算 β = H(hk, α)，算法在密文上执行同态评估。具体来说，它计算一个“通用电路” U[α]，该电路的功能是：输入一个电路描述 G，输出 G(α)。然后，运行 Eval(fpk, U[α], hat{G0})，得到的结果 hat{β} 就是一个密文。我们将这个密文 hat{β} 的二进制表示本身作为挑战 β。注意，这里 β 不是解密结果，而是密文比特串。

这个构造看起来非常奇怪，甚至有些随意。它似乎没有显式地避免坏挑战 β_bad。然而，其安全性的证明却非常简洁和深刻，依赖于一个混合论证（Hybrid Argument）。

安全性证明的核心思想：

  1. 假设存在作弊者：假设存在一个多项式时间的作弊证明者 P*，能够为一个错误的陈述（即没有汉密尔顿回路的图 G）生成一个被接受的 Fiat-Shamir 证明 (α, β, γ)，且成功概率不可忽略。
  2. 构造一个“理想”的电路 G*：在证明中，我们考虑另一个电路 G*。这个电路内部硬编码了承诺方案的陷门（私钥）和 FHE 的私钥 fsk。对于输入 α，G* 的工作流程是：
    a. 使用承诺陷门打开 α，计算出坏挑战 β_bad(α)。
    b. 使用 FHE 私钥 fsk 解密 β_bad(α)（注意：β_bad(α) 是一个比特串，不是密文。这里“解密”是一个形式操作，意指应用解密函数）。
    c. 将解密结果与某个固定值（例如加 1）进行异或，确保输出不等于 β_bad(α)。即 G*(α) ≠ β_bad(α)。
  3. 切换哈希密钥：现在，我们将哈希密钥中的加密电路从 hat{G0}（加密全零电路）切换到 hat{G*}（加密这个特殊的 G*``）。由于我们假设 FHE 方案是**循环安全**的（即加密私钥 fsk的密文与加密全零字符串不可区分），并且G的描述中包含了fsk，因此 hat{G0}和hat{G}在计算上是不可区分的。所以，作弊者P在密钥为(fpk, hat{G})` 时成功的概率，与其在原始密钥下成功的概率几乎相同。
  4. 到达矛盾：然而，在密钥 (fpk, hat{G*}) 下，哈希函数 H 对输入 α 的输出是 β = G*(α)。根据 G* 的定义，我们确保了对所有 α，都有 β = G*(α) ≠ β_bad(α)。这意味着，作弊者 P* 永远无法找到一个 α，使得哈希输出 H(α) 等于他能成功作弊的那个坏挑战 β_bad(α)。因此，P* 的成功概率应该为 0（或可忽略）。这与步骤 3 的结论矛盾。
  5. 得出结论：矛盾表明，最初的假设（存在成功的作弊者 P*）不成立。因此，对于按照上述方式构造的 Fiat-Shamir 哈希函数，该协议在标准模型下是可靠的。

这个证明的巧妙之处在于，它通过在安全性证明中“想象”一个特殊的电路 G*，并利用加密的不可区分性进行切换，从而在逻辑上迫使作弊者失败。而在实际构造中，哈希函数使用的是完全无害的加密全零电路。

技术要点与假设

  • 循环安全性：上述证明需要假设所使用的 FHE 方案是循环安全的。这是一个额外的假设，但基于格的学习有误问题（LWE），我们相信存在这样的方案。后续的研究工作已经探索了如何通过更复杂的格技术来移除对循环安全性的依赖。
  • 通用性：虽然我们以汉密尔顿回路零知识协议为例，但这项技术非常通用。它可以应用于一大类交互式证明，只要存在一个“陷门”可以识别出对作弊者有利的坏挑战。例如，该技术后续被用于证明 GKR 协议（我们之前学过的和校验协议）在应用 Fiat-Shamir 变换后，在标准模型下基于 LWE/FHE 假设也是安全的。
  • 非交互式零知识（NIZK）：对本协议应用 Fiat-Shamir 变换后，我们实际上得到了一个基于格假设的非交互式零知识论证系统。这是该研究的一个重要动机和成果，因为在此之前，构造基于格的标准模型 NIZK 是一个长期开放问题。

总结

本节课我们一起学习了如何证明一个特定零知识证明协议在应用 Fiat-Shamir 范式后的标准模型可靠性。我们回顾了并行重复的汉密尔顿回路协议，分析了直接构造可靠哈希函数面临的挑战。接着，我们介绍了 [C-LW19] 论文中的核心思想：利用带陷门的承诺方案和全同态加密，构造一个看似随意但安全性可证的哈希函数。其安全性证明通过一个混合论证完成，关键步骤是在证明中构想一个能避开所有坏挑战的特殊电路，并利用加密的不可区分性进行替换，最终导出矛盾。这项技术不仅解决了这个具体协议的安全性问题，其思想更被广泛应用于其他协议，为构建基于后量子假设的简洁非交互式证明系统奠定了基础。

013：标准模型中Fiat-Shamir范式可靠性的证明（第二部分）

在本节课中，我们将继续探讨Fiat-Shamir范式在标准模型中的可靠性。我们将看到，通过应用Fiat-Shamir变换，我们可以得到一个非交互式的零知识证明系统。同时，我们也将解释这一结果为何不与之前关于Fiat-Shamir和零知识之间矛盾的直觉相冲突。最后，我们将讨论这一技术的通用性，并介绍“关联不可行哈希函数”这一更广泛的框架。

从交互式协议到非交互式协议

上一节我们介绍了如何为一个特定的并行重复协议构造一个哈希函数，使其满足Fiat-Shamir可靠性。现在，我们来看看应用Fiat-Shamir变换后，这个协议变成了什么样子。

应用Fiat-Shamir变换后，我们得到一个非交互式协议。该协议现在关联一个公钥（用于承诺方案）和一个哈希密钥（用于Fiat-Shamir哈希函数）。验证者原本发送的挑战消息 beta，现在由证明者通过计算哈希函数来生成。

具体来说，证明者计算：
beta = H(G, alpha)
其中 H 是哈希函数，G 是问题实例（如图），alpha 是证明者的第一条消息。

因此，原本的三轮交互协议（alpha, beta, gamma）变成了一个单一的消息流。证明者一次性发送 (alpha, beta, gamma)，而 beta 是由哈希函数确定的。这个协议是完备的，并且我们已证明它在使用特定哈希函数时是可靠的。

非交互式零知识

接下来，我们探讨这个非交互式协议的零知识属性。在交互式设置中，我们证明了协议是零知识的。但在应用Fiat-Shamir后，情况发生了变化。

我们需要定义非交互式零知识。一个非交互式零知识系统包含一个公共参考字符串。对于任何高效验证者，都存在一个高效模拟器，使得对于语言中的任何实例 x，验证者在真实世界中看到的视图（即CRS和证明者生成的证明）可以被模拟器生成的视图所模拟。

关键点在于，模拟器拥有选择CRS的权力，而作弊的证明者没有这个权力。这就是为什么我们能够同时获得Fiat-Shamir可靠性和零知识属性，两者之间并不矛盾。

为了证明我们的非交互式协议是零知识的，我们需要构造一个模拟器。模拟器的策略如下：

  1. 首先生成一个看似真实的协议记录 (alpha, beta, gamma)。这可以通过“诚实验证者零知识模拟器”来完成，即先随机生成挑战 beta，然后根据 beta 的值来构造相应的 alpha 和 gamma。
  2. 接着，模拟器需要生成CRS，其中包含哈希密钥。模拟器将编程哈希密钥，使得对 (G, alpha) 的哈希计算结果恰好等于它之前随机选定的那个 beta。

为了实现第二步，我们需要对哈希函数稍作修改。我们定义新的哈希函数为原哈希函数输出与一个固定随机字符串 Z 的异或（或加法）：
H'(G, alpha) = H(G, alpha) ⊕ Z
其中 Z 是CRS的一部分。

现在，模拟器可以先选择 alpha, beta, gamma 和原哈希密钥，然后简单地设置 Z = beta ⊕ H(G, alpha)。这样，H'(G, alpha) 就等于 beta。由于 Z 是随机均匀的，这种修改不会影响哈希函数的可靠性证明。

通过这种方式，模拟器可以生成一个与真实世界不可区分的视图，从而证明了系统的零知识性。这一切都归功于模拟器能够编程CRS。

技术的通用性：关联不可行哈希函数

以上我们针对一个特定协议进行了分析。现在，我们探讨这个技术有多通用。实际上，我们可以将其置于一个更通用的框架下：关联不可行哈希函数。

一个哈希函数族 H 对于关系 R 是关联不可行的，如果对于任何高效敌手，在获得随机哈希密钥 hk 后，很难找到一个输入 x，使得 (x, H(hk, x)) 属于关系 R。

形式化定义如下：对于所有多项式规模敌手 A，存在一个可忽略函数 negl，使得：
Pr[ hk ← Gen(1^λ); (x, y) ← A(hk) : (x, y) ∈ R ∧ y = H(hk, x) ] ≤ negl(λ)

这与Fiat-Shamir有何关联？考虑一个交互式证明系统，其第一条消息为 alpha，验证者挑战为 beta。定义关系 R 包含所有 (alpha, beta) 对，使得存在一个第三条消息 gamma 能让验证者接受。对于一个错误的陈述，关系 R 是“稀疏的”（即对于每个 alpha，只有极少数的 beta 是“坏的”）。如果我们有一个对于所有稀疏关系 R 都关联不可行的哈希函数，那么将其用于Fiat-Shamir变换就能直接保证可靠性。

然而，我们无法为所有稀疏关系构造关联不可行哈希函数。但我们可以为一个重要的子类来构造：在时间T内可搜索的关系。

一个关系 R 被称为在时间 T 内可搜索，如果对于每个 alpha，至多存在一个 beta 使得 (alpha, beta) ∈ R，并且这个 beta（如果存在）可以在时间 T 内从 alpha 计算出来。

Klivans和Lombardi等人的成果表明：对于每个多项式时间 T，存在一个哈希函数族，该族对于所有在时间 T 内可搜索的关系都是关联不可行的。这正是我们之前构造的哈希函数！其构造核心仍然是使用全同态加密。

这个通用结果非常强大，它可以被用来证明许多复杂协议（如GKR协议、求和检查协议）的Fiat-Shamir可靠性，尽管其中需要一些额外的密码学处理来应对多轮交互带来的依赖关系。

总结

本节课中，我们一起学习了以下内容：

  1. 非交互式协议的构造：通过应用Fiat-Shamir变换，我们将一个三轮交互式证明系统转化为一个非交互式论证系统。
  2. 非交互式零知识：我们定义了非交互式零知识，并解释了为何通过让模拟器编程CRS，可以在保持Fiat-Shamir可靠性的同时实现零知识。这解决了之前关于两者矛盾的直觉困惑。
  3. 关联不可行哈希函数：我们介绍了这个更通用的密码学原语，它将Fiat-Shamir可靠性的核心需求抽象出来。我们了解到，可以为“在时间T内可搜索”的关系类构造关联不可行哈希函数，这体现了我们所用技术的广泛适用性。

本节课展示的由全同态加密驱动的构造，不仅解决了一个具体的协议问题，更提供了一个强大的通用工具，用于在标准模型下为各类交互式证明系统实现安全的Fiat-Shamir变换。

014：基于LWE的批量NP简洁非交互式论证（BARGs）

在本节课中，我们将学习一种称为批量论证（Batch Arguments， 或称BARGs）的证明系统。这是一种允许证明者一次性向验证者证明多个NP语句为真的简洁非交互式论证。我们将从基本概念开始，逐步构建一个基于带错误学习（LWE）假设的BARG构造。

概述

批量论证（BARGs）是一种证明系统，它允许证明者用一个简短的证明来说服验证者，一组NP语句全部为真。其核心优势在于，证明的大小远小于所有见证（witness）的总长度，并且验证时间高效。本节课将介绍BARG的定义、重要性，并详细讲解一个基于LWE的具体构造。

批量论证（BARGs）的定义

首先，让我们正式定义什么是批量论证。

一个批量论证（BARG）由三个算法组成：一个生成器（Generator）、一个证明者（Prover）和一个验证者（Verifier）。其语法如下：

  • 生成器（Gen）：输入安全参数 λ，输出一个公共参考字符串（CRS）。
  • 证明者（Prover）：输入CRS、一组NP语句 x1, ..., xk 及其对应的见证 w1, ..., wk，输出一个证明 π。
  • 验证者（Verifier）：输入CRS、语句组 x1, ..., xk 和证明 π，输出接受（1）或拒绝（0）。

证明者希望证明所有语句 xi 都属于某个NP语言 L。该语言由一个关系电路 C 定义：(x, w) ∈ R_L 当且仅当 C(x, w) = 1。

我们要求BARG满足以下属性：

  1. 简洁性（Succinctness）：证明 π 的大小必须小于所有见证的总长度 k * |w|。这是为了防止平凡构造（例如，证明者直接发送所有见证）。
  2. 完备性（Completeness）：对于诚实的证明者生成的证明，验证者总是接受。
  3. 可靠性（Soundness）：如果存在至少一个语句 xi 不属于语言 L（即所有语句不全为真），那么任何多项式时间的作弊证明者都无法生成一个能使验证者以不可忽略概率接受的证明 π。形式化描述为：对于任何均匀PPT作弊证明者 P，其成功概率是可忽略的。

为什么研究BARGs？

你可能会问，既然BARGs证明的语句集合本身也是一个NP语言（L^k），为什么我们要专门研究它？

首先，“批量”是计算机科学中的一个基本概念，在密码学其他领域也有类似研究，例如聚合签名（Aggregated Signatures）。其次，BARGs是构建通用简洁非交互式知识论证（SNARKs for P）的关键组成部分。事实上，许多现有的P类SNARK构造都使用BARG作为其核心模块。

此外，存在一个技术上的原因。Gentry和Wichs的研究表明，对于任何需要时间 T 来判定的语言，构建证明大小显著小于 log T 的SNARK是非常困难的（在“可伪造”假设下）。对于一般的NP语言，判定时间 T ≈ 2^{|w|}，因此SNARK的证明大小很难显著小于见证大小 |w|。

然而，对于批量语言 L^k，其判定时间约为 k * 2^{|w|}。根据上述不可能结果，构建证明大小显著小于 log(k * 2^{|w|}) ≈ |w| + log k 的SNARK是困难的。但如果我们能构建一个证明大小约为 |w| + log k 的BARG，这并不违背不可能结果，同时由于 |w| + log k 已经显著小于总见证大小 k * |w|，它仍然是简洁的。这为构建高效的证明系统留下了空间。

主要定理

本节课旨在证明的主要定理如下：

定理：基于带错误学习（LWE）假设，存在一个批量论证（BARG）构造，满足：

  • 证明大小：|π| = O(|w| + poly(λ) * log k)
  • 验证时间：T_ver = O(k * |x| + poly(λ, |C|, log k))

其中，|w| 是单个见证的大小，|x| 是单个语句的大小，|C| 是关系电路的大小，λ 是安全参数，k 是语句数量。

验证算法可以进一步分为两个阶段：

  1. 预处理阶段：仅输入所有语句 x1, ..., xk，输出一个简短的状态。
  2. 在线阶段：输入预处理阶段的状态和证明 π，快速完成验证。在线阶段的时间不依赖于语句数量 k。

构造思路：从Kilian协议出发

直接展示完整构造会非常复杂。因此，我们将从一个初始尝试开始，逐步添加必要的密码学组件。

我们的起点是一个简化的Kilian协议变体。

初始协议（交互式）

假设证明者有 k 个语句-见证对 (x1, w1), ..., (xk, wk)。

  1. 证明者：为每一对 (xi, wi) 运行PCP证明者算法，生成一个长的PCP证明字符串 Π_i。将所有 Π_i 排列成一个 k行 × L列 的矩阵，其中 L 是单个PCP证明的长度。
  2. 证明者 → 验证者（第一轮）：对矩阵的每一列应用一个哈希函数 H。也就是说，将第 j 列的所有比特连接起来，计算哈希值 h_j = H(column_j)。证明者发送所有的哈希值 (h1, ..., hL) 给验证者。
  3. 验证者 → 证明者（第二轮）：验证者随机生成一个PCP查询集合 Q（它是 {1, ..., L} 的一个子集），并将其发送给证明者。
  4. 证明者 → 验证者（第三轮）：对于查询集合 Q 中的每一个位置 j，证明者“打开”矩阵的第 j 列，即发送完整的 column_j 给验证者。
  5. 验证：验证者进行两项检查：
    • 哈希一致性：对于每个收到的 column_j，重新计算其哈希值，检查是否与第一轮收到的 h_j 一致。
    • PCP验证：对于每个语句 xi，利用从对应行（第 i 行）的打开列中获取的PCP比特（即 column_j[i] 对于所有 j ∈ Q），运行PCP验证算法，检查 xi 是否被接受。

问题：这个协议是交互式的，并且第三轮消息的大小为 O(k * |Q|)，与 k 线性相关，不够简洁。我们的目标是得到一个非交互式且证明大小接近 O(|w| + log k) 的构造。

引入相关不可区分哈希（CIH）实现非交互式

上一节课我们学习了相关不可区分哈希（Correlation-Intractable Hash, CIH），它可以将三轮公开掷币的交互式协议编译为非交互式协议。

回忆CIH：对于一个关系 R ⊆ X × Y，一个CIH函数族包含密钥生成算法和哈希算法。其安全性要求：对于任何PPT敌手，在给定哈希密钥 hk 后，很难找到一个输入 x，使得 (x, CIH(hk, x)) ∈ R。

编译方法：给定一个三轮公开掷币交互协议（第二轮消息是随机串），我们可以构造非交互式证明如下：

  1. 证明者生成第一轮消息 α。
  2. 证明者计算挑战 β = CIH(hk, α)，其中 hk 在CRS中。
  3. 证明者生成第三轮消息 γ。
  4. 最终的证明是 π = (α, β, γ)。

可靠性证明思路：为交互式协议定义一个关系 R：(α, β) ∈ R 当且仅当存在一个第三轮消息 γ 使得验证者接受整个转录 (α, β, γ)。如果存在一个作弊证明者能生成被接受的证明 (α*, β*, γ*)，那么意味着 (α*, β*) ∈ R 且 β* = CIH(hk, α*)。这就与CIH的安全性相矛盾，因为敌手找到了一个 α* 使得其哈希值落入了稀疏关系 R 中。

关键条件：关系 R 必须是稀疏的，即对于任何固定的 α，满足 (α, β) ∈ R 的 β 在所有可能值中只占可忽略的比例。

应用于我们的协议及面临的挑战

我们尝试将CIH范式应用到初始协议中：

  • 第一轮消息 α：对应所有列哈希值 (h1, ..., hL)。
  • 第二轮消息 β：对应PCP查询集合 Q。我们让证明者自己计算 Q = CIH(hk, (h1, ..., hL))。
  • 第三轮消息 γ：对应打开的列。

然而，这里存在一个问题：我们为CIH定义的关系 R 是否稀疏？关系 R 包含所有 ((h1,...,hL), Q)，使得存在打开的列能让验证者接受。由于哈希函数是压缩的，一组哈希值 (h1,...,hL) 可能对应多个不同的PCP矩阵原像。对于其中一个原像矩阵，可能存在某个查询集 Q 能使其通过验证。对于另一个原像矩阵，可能存在另一个查询集 Q‘ 能使其通过验证。因此，对于固定的 (h1,...,hL)，可能有多个 Q 属于关系 R，这使得关系 R 的稀疏性难以证明。

解决方案：引入某处统计绑定哈希（SSB）

为了解决稀疏性问题，我们需要一个特殊的哈希函数，它能提供关于原像的额外信息。这个工具叫做某处统计绑定哈希（Somewhere Statistically Binding Hash, SSB）。

SSB哈希定义：一个SSB哈希函数族包含：

  • 密钥生成：Gen(1^λ, i) 输入安全参数 λ 和一个索引 i ∈ [N]，输出一个哈希密钥 hk_i。
  • 哈希计算：H(hk_i, (x1, ..., xN)) 输出一个哈希值。

它满足两个性质：

  1. 密钥不可区分性：对于任意两个索引 i, j，生成的密钥 hk_i 和 hk_j 是计算不可区分的。
  2. 某处统计绑定：对于由索引 i 生成的密钥 hk_i，如果两个不同输入 (x1,...,xN) 和 (x1‘,...,xN’) 产生相同的哈希值，那么它们在第 i 个位置的值必须相等，即 xi = xi‘。这意味着哈希值在统计上“绑定”了输入的第 i 个分量。

基于FHE的SSB构造：构造非常简单。

  • 密钥生成：对于索引 i，生成一个全同态加密（FHE）的密文 ct，该密文加密了索引 i 本身。hk_i = ct。
  • 哈希计算：对于输入 (x1, ..., xN)，在密文 ct 下同态地计算函数 F_i，该函数输出其输入的第 i 个分量 xi。哈希结果就是这个同态计算得到的密文。

分析：

  • 压缩性：哈希值是一个FHE密文，大小是固定的多项式。
  • 密钥不可区分性：由于FHE的语义安全性，加密 i 和加密 j 的密文不可区分。
  • 某处统计绑定：哈希值本身就是 xi 的一个FHE密文。如果两个输入哈希相同，则它们对应的 xi 的密文相同。由于FHE是确定性的（或使用相同随机数），这要求 xi 本身必须相同。

额外性质：可提取性：如果我们拥有FHE的解密密钥（作为陷门），可以从哈希值中解密出被绑定的值 xi。

改进的构造：使用SSB哈希

现在，我们修改初始构造，用SSB哈希代替普通的哈希函数。

  • CRS：包含一个SSB哈希密钥 hk，该密钥是针对某个（隐藏的）索引 i* 生成的。
  • 第一轮消息：证明者使用SSB哈希对PCP矩阵的每一列进行哈希，得到 (h1, ..., hL)。由于SSB密钥是针对 i* 的，根据统计绑定性，每个 hj 都绑定了第 i* 行、第 j 列的那个比特。因此，整个哈希序列 (h1, ..., hL) 在统计上编码了第 i* 行的完整PCP字符串 Π_{i*}。
  • 非交互式挑战：证明者使用CIH计算挑战 Q = CIH(hk_cih, (h1,...,hL))，其中 hk_cih 是CRS中另一个CIH的密钥。
  • 证明：证明包含 (h1,...,hL, Q, {opened columns})。

可靠性证明的核心思想

现在我们可以证明改进后构造的可靠性了。关键在于利用SSB哈希的绑定性质。

  1. 确定错误语句：如果敌手试图为一批不全部为真的语句生成证明，那么其中至少存在一个索引 i*，使得语句 x_{i*} 不属于语言 L。
  2. 设置SSB索引：在安全性证明中，我们将CRS中的SSB哈希密钥设置为针对这个 i* 生成。由于密钥不可区分性，敌手无法察觉这一变化。
  3. 定义稀疏关系 R：现在我们为CIH定义一个关系 R：
    • ((h1,...,hL), Q) ∈ R 当且仅当：从 (h1,...,hL) 中（利用SSB的提取性）提取出的第 i* 行的PCP字符串 Π_{i*}，对于语句 x_{i*}，能够通过以 Q 为查询的PCP验证。
    • 注意，由于 x_{i*} 不在语言 L 中，根据PCP的可靠性，对于任何固定的PCP字符串 Π_{i*}，能够使其通过的查询集 Q 只占所有可能查询集的可忽略比例。因此，对于固定的 (h1,...,hL)（即固定的 Π_{i*}），满足关系的 Q 的比例是可忽略的。这就保证了关系 R 是稀疏的。
  4. 归约到CIH安全性：如果一个作弊证明者成功生成了一个被接受的证明，那么根据验证过程，打开的列必须与哈希值一致，并且所有行的PCP验证通过。特别地，第 i* 行的PCP验证也必须通过。根据SSB的绑定和提取性质，这意味着从哈希值中提取出的 Π_{i*} 与证明中打开的部分一致，并且 (h1,...,hL) 和 Q 满足我们上面定义的关系 R。这就构成了对CIH安全性的一个有效攻击，从而引出矛盾。

通过这种方式，我们证明了构造的可靠性。整个证明利用了“至少存在一个错误语句”这一事实，并通过SSB哈希将攻击焦点引导至该特定语句的PCP上，从而能够定义一个稀疏的、基于PCP可靠性的关系R。

总结

本节课我们一起学习了批量NP论证（BARGs）。我们从其定义和重要性出发，逐步构建了一个基于LWE假设的非交互式BARG构造。核心步骤包括：

  1. 从基于PCP和哈希的交互式Kilian协议变体开始。
  2. 为了获得非交互性，引入相关不可区分哈希（CIH），但面临定义稀疏关系的挑战。
  3. 为解决该挑战，引入了某处统计绑定哈希（SSB），并给出了基于全同态加密（FHE）的构造。
  4. 将SSB哈希集成到协议中，使得哈希值能绑定某个特定行的PCP。
  5. 在可靠性证明中，巧妙地将SSB的索引设置为错误语句所在的行，从而能够定义一个基于PCP可靠性的稀疏关系，最终将任何攻击归约到CIH的安全性上。

最终构造的证明大小接近单个见证的大小，验证时间高效，为构建更强大的密码学协议（如通用SNARKs）奠定了基础。

015：基于LWE的批量NP简洁非交互式论证（BARGs）

在本节课中，我们将学习如何基于LWE（带错误学习）假设，为批量NP问题构建简洁的非交互式论证（BARGs）。我们将重点关注一种称为“索引BARG”的变体，它能显著降低验证时间。课程将涵盖核心构造思想、递归压缩证明大小的方法，以及实现半自适应安全性的关键技术。

从SNARGs到BARGs：基本构造

上一节我们介绍了简洁非交互式论证（SNARGs）的基本概念。本节中，我们来看看如何将其扩展，以处理批量NP（Batch NP）问题，即同时验证多个NP陈述。

基本构造使用一个“可搜索哈希”（somewhere statistically binding hash, SSB）和一个概率可检查证明（PCP）。验证者首先生成一个SSB密钥，并将其发送给证明者。证明者为每个NP实例计算PCP证明，并将所有PCP证明排列成一个矩阵。然后，证明者计算矩阵每一列的SSB哈希值，并将这些哈希值发送给验证者。验证者随后使用一个“可搜索哈希关系”（somewhere statistically binding hash relation）来生成一组PCP查询。证明者需要根据这些查询，打开对应列的PCP答案。

以下是该协议的核心步骤：

  1. 验证者 生成SSB哈希密钥 ssb_key。
  2. 证明者 对于 K 个实例 (x_i, w_i)，为每个实例生成PCP证明 π_i。
  3. 证明者 将所有PCP证明 π_i 排列成 K 行，每行对应一个实例的完整PCP。
  4. 证明者 计算每一列（共 L 列）的SSB哈希值 H_1, ..., H_L，并发送给验证者。
  5. 验证者 使用一个“可搜索哈希关系” R，基于 ssb_key 和 H_1, ..., H_L 生成一组PCP查询 Q。
  6. 证明者 对于查询 Q 中的每个位置 q，打开SSB哈希 H_q 对应的列 col_q，得到该列在所有 K 个实例上的PCP答案，并将这些答案发送给验证者。
  7. 验证者 对于每个实例 i，使用收到的PCP答案验证其PCP证明。

这个构造的证明大小包括第一轮消息（L 个哈希值）和第三轮消息（K 组PCP答案）。第一轮消息大小为 O(L * poly(λ))，与实例数量 K 无关。第三轮消息大小为 O(K * poly(λ))。这已经比直接发送 K 个完整见证（大小为 O(K * |w|)）要简洁。

然而，验证时间存在瓶颈。验证者需要为 K 个实例中的每一个都运行PCP验证，每次验证需要 O(C) 时间（C 是关系电路的大小）。因此，总验证时间为 O(K * poly(C, λ))，这仍然是 K 的线性倍数。对于批量验证，验证者至少需要读取所有实例，这似乎存在一个 Ω(K * |x|) 的下界。

引入索引BARGs：降低验证时间

为了突破验证时间的下界，我们考虑一种特殊场景：实例是“均匀”生成的。即，存在一个电路 U，使得第 i 个实例 x_i 可以由 U(i) 生成。此时，证明者试图证明的是：对于所有索引 i 从 1 到 K，U(i) 都在语言 L 中。

这等价于定义一个新的NP关系 R'：实例是索引 i，见证是 w_i，满足 C(U(i), w_i) = 1，其中 C 是原始NP关系的验证电路。

基于此，我们定义索引BARGs。在这种论证中：

  • 证明者拥有见证 w_1, ..., w_K。
  • 验证者仅输入索引总数 K（可用 log K 比特表示），而非所有具体实例。
  • 验证者需要被说服：对于所有 i ∈ [K]，(i, w_i) ∈ R'。

对于索引BARG，我们希望验证时间仅依赖于 log K 和安全性参数 λ，而不是 K。我们将证明，基于LWE假设，可以构造这样的索引BARG，其证明大小为 poly(log K, log C, λ)，验证时间也为 poly(log K, log C, λ)。

更重要的是，任何通用的BARG都可以通过索引BARG以黑盒方式构造。思路是：证明者首先将所有实例 x_1, ..., x_K 哈希成一个默克尔树根 h。然后，证明者使用一个索引BARG来证明：“对于每个索引 i，存在一个到 h 的默克尔树路径打开（Merkle opening）ρ_i，能够验证叶子节点值为 x_i，并且存在见证 w_i 使得 C(x_i, w_i) = 1。” 这样，就将一个通用BARG的构造归约到了索引BARG的构造上。

递归压缩：构建索引BARG

现在，我们专注于构建索引BARG。从基本SNARG协议出发，第三轮消息（PCP答案）的大小是 O(K * poly(λ))，我们希望能压缩它。

核心思想是递归验证。我们不直接发送庞大的第三轮消息，而是让证明者向验证者证明：“存在正确的PCP答案列，使得PCP验证能通过。” 这本身又是一个需要证明的陈述（Statement）。如果我们能把这个新陈述也表示成一个索引BARG的语言，就可以递归地应用同一套构造。

具体步骤如下：

  1. 在第一轮，证明者发送SSB哈希值 H_1, ..., H_L。
  2. 证明者本地计算PCP查询 Q 和对应的答案列 {col_q}。
  3. 现在，证明者和验证者运行另一个索引BARG协议。在这个子协议中，证明者要证明的陈述 L' 是：
    • 存在 列集合 {col_q}，满足：
      • 对于每个查询 q ∈ Q，H_q 确实是 col_q 的正确SSB哈希值。
      • 对于每个索引 i ∈ [K]，使用列 {col_q} 中第 i 行的PCP答案进行验证，PCP验证器会接受。
  4. 证明者在这个子协议中的见证就是 {col_q}。

如果子协议的证明很小，我们就压缩了原始的第三轮消息。然而，这里 {col_q} 作为见证，其大小为 O(K * L)，仍然很大。如果直接递归，见证大小会逐层膨胀，无法实现简洁性。

关键技巧：局部打开的SSB哈希与两合一归约

为了解决见证大小问题，我们需要两个关键技巧。

技巧一：支持局部打开的SSB哈希
我们要求SSB哈希具有类似默克尔树的结构，支持“局部打开验证”。即，对于哈希根 H、索引 i、值 v 和一个认证路径 ρ，存在一个高效的验证算法，可以验证 v 是 H 所承诺的第 i 个值。并且，如果验证通过，则从 H 中提取出的第 i 个值必定是 v（局部绑定性）。

利用这个性质，我们可以重写上面的子协议陈述 L'。证明者现在不需要提供整个列 col_q 作为见证，而只需为每个查询 q 和每个索引 i 提供该列第 i 个元素的局部打开 ρ_{i,q}。新的陈述 L'' 变为：

  • 对于每个索引 i ∈ [K]，存在 见证 (π_i, {ρ_{i,q}}_{q∈Q})，满足：
    1. PCP验证器对于实例 i 和答案 π_i 接受（使用查询 Q）。
    2. 对于每个查询 q，局部打开 ρ_{i,q} 能验证 H_q 所承诺的第 i 个值正是 π_i 在查询 q 上的答案。

现在，对于每个固定的 i，其见证大小是 poly(λ, log K)，与 K 无关。这正是一个索引BARG的语言格式：我们有 K 个索引（1 到 K），每个索引对应一个需要证明的陈述。

技巧二：两合一归约（2-to-1 Trick）
虽然我们将陈述转化为了索引格式，但实例数量 K 在递归中没有减少。如果无限递归下去，证明大小会包含 log K 个层级的多项式项，最终可能变得不简洁。

为了解决这个问题，我们在每一层递归时，将索引两两合并。具体来说，对于当前层的 K 个实例（索引 1...K），我们将其配对：(1,2), (3,4), ...。我们定义一个新的语言 L2，其第 j 个实例（对应原始索引 2j-1 和 2j）的见证是 (w_{2j-1}, w_{2j})，需要同时验证这两个原始陈述。

这样，下一层递归的实例数量就减半为 K/2。经过 log K 层递归后，实例数量变为 1。在最后一层，证明者可以直接发送这个唯一实例的（现在已很小的）见证，由验证者直接验证。

处理电路大小：具有快速在线验证的PCP

在递归构造中，还有一个问题：每一层验证电路的规模。子协议中的验证电路 C' 需要包含PCP验证逻辑。如果PCP验证器需要读取原始的大电路 C，那么 C' 的规模至少是 O(|C|)。经过 log K 层递归后，最终电路的规模会放大 poly(K) 倍，导致证明大小爆炸。

我们需要使用一种特殊的PCP，它具有快速在线验证特性。这种PCP的验证过程分为两个阶段：

  1. 离线预处理阶段：输入是关系电路 C，输出一个简短的“验证状态” st。该阶段耗时与 |C| 相关。
  2. 在线验证阶段：输入是实例 x、查询 Q、PCP答案 π 以及预处理状态 st。该阶段运行很快，时间仅取决于 |x| 和 |Q|，而与 |C| 无关。

在我们的构造中，由于所有实例共享相同的PCP查询 Q，我们可以让验证者（或证明者）在协议开始时，基于关系电路 C 执行一次离线预处理，生成简短的状态 st。然后，在递归的每一层，子协议的验证电路 C' 只需要实现在线验证阶段，它硬编码了 st。因此，C' 的规模不再依赖于 |C|，而只依赖于 |x|（即索引 i，大小为 log K）和 |Q|（大小为 poly(λ)）。这使得递归过程中电路规模保持为 poly(log K, λ)。

结合两合一归约，总证明大小被控制在 poly(log K, log C, λ) 以内。

安全性：半自适应声音性

最后，我们需要讨论构造的安全性。在递归中，下一层的陈述 L'' 依赖于第一轮消息中的SSB哈希值 H_q。而 H_q 是证明者发送的。这意味着敌手可以选择一个关系电路 C，使其依赖于之前收到的承诺 H_q。这超出了标准非自适应声音性的安全模型。

我们实现的是半自适应声音性。在这种模型下，我们允许敌手在收到公共参数（CRS）后自适应地选择要证明的关系电路 C。但是，我们要求存在一个（与真实CRS不可区分的）替代性CRS生成算法，该算法针对某个特定的“挑战索引” i* 生成参数。安全性要求：任何敌手都无法在让验证者接受的同时，使得第 i* 个索引对应的陈述为假。

直观上，我们可以将SSB哈希设置为对位置 i* 是统计绑定的。那么，敌手就无法在第 i* 个位置上作弊。在递归证明中，我们可以追踪这个 i*：通过两合一归约，i* 会在某一层递归中成为被合并对的一部分。如果原始陈述在 i* 处为假，那么在合并后的新陈述中，对应的那个实例也为假。通过逐层追踪，我们最终能在递归的最后一层（直接验证见证）发现矛盾，从而证明安全性。

总结

本节课中，我们一起学习了基于LWE假设构造批量NP简洁非交互式论证（BARGs）的高级技术。我们从基本SNARG协议出发，通过引入索引BARG的概念来降低验证时间。核心构造采用了递归压缩的方法：

  1. 使用支持局部打开的SSB哈希，将庞大的PCP答案列见证转化为每个索引独立的局部打开见证。
  2. 利用两合一归约，在递归过程中将实例数量逐层减半，控制递归深度。
  3. 采用具有快速在线验证的PCP，确保递归中验证电路的规模不会爆炸。
    最终，我们得到了证明大小和验证时间均为 poly(log K, log C, λ) 的索引BARG构造，并基于半自适应声音性模型证明了其安全性。这套技术不仅用于BARGs，也是构建更高级密码学原语的重要工具。

016：BARGs 到 SNARGs 的构造与连接（第一部分）

在本节课中，我们将学习如何利用批量论证（BARGs）和可提取哈希函数（Somewhere Extractable Hash）来构造简洁的非交互式论证（SNARGs）。这是本课程的核心目标之一。

概述

我们将首先回顾BARGs和可提取哈希函数的定义与关键性质。然后，我们将展示一个直观的构造，利用这两个原语来构建SNARGs。其核心思想是：证明者计算电路中所有导线的值，对其进行哈希承诺，然后使用BARG来证明电路中每一个逻辑门都得到了正确的计算。

BARGs（批量论证）回顾

上一节我们介绍了BARGs的基本概念。本节中，我们来看看其正式定义。

一个针对NP语言L的BARG包含三个概率多项式时间（PPT）算法：

  • Gen(1^λ, 1^K, 1^n) → CRS：输入安全参数λ、批处理实例数量K和每个实例的长度n，输出公共参考字符串CRS。
  • P(CRS, (x_1, w_1), ..., (x_K, w_K)) → π：输入CRS和K个（实例，证据）对，输出一个证明π。
  • V(CRS, x_1, ..., x_K, π) → {0, 1}：输入CRS、K个实例和证明π，输出接受或拒绝。

关键性质：

  1. 完备性：诚实的证明者总能生成被验证者接受的证明。
  2. 半自适应合理性：对于任何PPT敌手P*和任何预先选定的索引i（1 ≤ i ≤ K），敌手在获得CRS后自适应地选择实例x_1, ..., x_K并生成证明π，使得x_i ∉ L 但 V(CRS, x_1, ..., x_K, π) = 1的概率是可忽略的。

证明大小：证明π的大小应仅与单个实例/证据的大小多项式相关，而与批处理数量K呈亚线性关系（理想情况下为polylog(K)）。

索引语言的高效性：如果实例集x_1, ..., x_K可以由一个简洁的程序M生成（即x_j = M(j)），那么验证者V的运行时间可以仅依赖于M的大小，而不是K。

可提取哈希函数（Somewhere Extractable Hash）回顾

接下来，我们回顾构造所需的另一个核心组件。

一个可提取哈希函数族包含五个PPT算法：

  • Gen(1^λ, 1^n, i) → (hk, td)：输入安全参数λ、输入长度n和绑定索引i，输出哈希密钥hk和陷门td。
  • Eval(hk, x ∈ {0,1}^n) → v：输入哈希密钥hk和字符串x，输出哈希值v。
  • Open(hk, x, j) → ρ_j：输入哈希密钥hk、字符串x和索引j，输出一个关于第j位的打开证明ρ_j。
  • Ver(hk, v, j, b, ρ) → {0,1}：输入哈希密钥hk、哈希值v、索引j、比特b和打开证明ρ，验证是否成功。
  • Extract(td, v) → b：输入陷门td和哈希值v，输出一个比特b。

关键性质：

  1. 完备性：对于诚实的操作，验证总会成功，并且提取出的比特是正确的（即Extract(td, Eval(hk, x)) = x_i）。
  2. 索引隐藏：哈希密钥hk隐藏了绑定索引i。即，对于不同的i和j，hk_i和hk_j在计算上是不可区分的。
  3. 某处统计绑定（SSB）：对于生成时指定的绑定索引i，即使是计算无界的敌手，在给定hk_i后，也无法生成一个哈希值v以及两个都能通过验证的打开证明(ρ_0, ρ_1)，分别证明第i位是0和1。

扩展性质：

  • 通过独立重复L次，我们可以得到一个在L个位置上绑定的可提取哈希函数。
  • 即使公开其中部分位置的陷门，其余位置的索引隐藏性依然保持。

从BARGs和可提取哈希构造SNARGs

现在，我们利用上述两个原语来构造SNARGs。核心思路是：证明者承诺电路中所有导线的值，然后使用BARG批量证明所有逻辑门的计算都是正确的。

构造详述

假设我们有一个NP语言L，其对应的验证电路为C_x(w)（对于确定性语言，可忽略w）。电路C有K个门和N根导线（包括输入、输出和内部导线）。

SNARG构造包含以下算法：

  1. CRS生成 (Gen_SNARG)：

    • 生成一个可提取哈希的密钥(hk, td) ← Hash.Gen(1^λ, 1^N, i)。这里N是导线数量，i可任意选取。
    • 生成一个BARG的CRS：crs_barg ← BARG.Gen(1^λ, 1^K, 1^n')。其中K是门数量，n'是BARG语句的长度（稍后定义）。
    • 输出SNARG的CRS：crs = (hk, crs_barg)。

  2. 证明生成 (P_SNARG)：

    • 输入：CRS、实例x、证据w（对于NP语言）。
    • 计算电路C_x(w)中所有N根导线的值：W = (w_1, ..., w_N)。
    • 计算所有导线值的哈希承诺：v ← Hash.Eval(hk, W)。
    • 为电路中的每一个门j（1 ≤ j ≤ K）构造一个BARG语句x_j*及其证据w_j*：
      • x_j* 可以表示为 (hk, v, j)。它断言：“存在对哈希值v的三个有效打开证明，分别对应门j的左输入导线、右输入导线和输出导线的索引，并且这些打开出来的比特值满足门j的逻辑关系。”
      • w_j* 就是这三个打开证明 (ρ_left, ρ_right, ρ_out) 以及对应的导线值比特。
    • 使用BARG证明者为这K个语句生成一个批量证明：π_barg ← BARG.P(crs_barg, (x_1*, w_1*), ..., (x_K*, w_K*))。
    • 注意：还需要额外证明输出导线的值为1。这可以通过将输出门对应的证据w_out*中的打开值设为1来实现，或者将其作为一个特殊的语句加入BARG。
    • 输出SNARG证明：π = (v, π_barg)。

  3. 验证 (V_SNARG)：

    • 输入：CRS (hk, crs_barg)、实例x、证明π = (v, π_barg)。
    • 验证者知道电路结构。他根据(hk, v)和门索引j，可以高效地（因为这是索引语言）生成或描述出所有的BARG实例x_1*, ..., x_K*。
    • 运行BARG验证：b ← BARG.V(crs_barg, x_1*, ..., x_K*, π_barg)。
    • 输出b（接受/拒绝）。

直观理解与效率

  • 简洁性：SNARG证明π的大小由哈希值v和BARG证明π_barg决定。v是固定的短字符串，而π_barg的大小是polylog(K)，因此整个证明是简洁的。
  • 验证效率：验证者需要计算BARG实例x_j*。由于这些实例具有统一的简洁描述(hk, v, j)，验证者不需要显式列出所有K个实例，其运行时间可以做到polylog(K)加上读取输入x的时间。
  • 安全性：合理性依赖于BARG的合理性和哈希函数的绑定性。如果敌手能为一个错误电路生成有效证明，那么他要么攻破了BARG，要么在某个位置上对哈希值产生了两个不同的有效打开，从而攻破了哈希的绑定性。

总结

本节课中，我们一起学习了如何将BARGs和可提取哈希函数组合起来，构造出简洁的非交互式论证（SNARGs）。我们回顾了这两个基础原语的定义和性质，并详细阐述了一个直观的构造方案：通过哈希承诺电路的全部状态，然后使用BARG批量验证所有逻辑门的正确性。这个构造奠定了SNARGs的理论基础，并展示了高级密码学原语之间强大的组合能力。在下一节中，我们将深入分析该构造的安全性证明。

017：BARGs 蕴含 SNARGs 及与非信号 PCPs 的联系（第二部分）

在本节课中，我们将继续探讨如何从批量可提取论证（BARGs）构造简洁非交互式论证（SNARGs）。我们将深入分析构造的安全性，特别是“局部一致性”的概念，并讨论为何局部一致性并不总是能直接推导出全局一致性。

概述

上一节我们介绍了从 BARGs 构造 SNARGs 的基本框架。本节中，我们将分析该构造的安全性。我们将看到，该构造能保证一种“局部一致性”，但要证明完全的“全局一致性”（即标准意义上的可靠性）则更为复杂，这引出了对电路进行修改的需求。

构造回顾

我们的 SNARG 构造基于一个电路 C 和一个半可提取哈希函数。证明者计算电路中所有导线的值，对其进行哈希得到 V，然后生成一个 BARG 证明 π_BARG，声称对于电路中的每一个门 j，实例 (hash_key, V, j) 都在相应的语言中（即该门的输入输出导线值满足门约束）。最终的 SNARG 证明是 π = (V, π_BARG)。

验证者知道电路 C 的描述和哈希密钥 hash_key，但不知道所有导线的具体值。它验证 BARG 证明 π_BARG 是否有效。

分析：完备性与可靠性

完备性

如果输入 x 在语言中（即存在一个合法的导线赋值使电路输出 1），诚实的证明者可以正确计算所有导线值，生成正确的哈希值 V 和一个有效的 BARG 证明。根据底层原语的完备性，验证者会以高概率接受该证明。这部分是平凡的。

可靠性（Soundness）

可靠性是分析的重点。我们希望证明：对于任何多项式大小的作弊证明者 P*，其能够生成一个不在语言中的实例 x 和一个被验证者接受的 SNARG 证明 π 的概率是可忽略的。

然而，我们将发现，我们构造的 SNARG 并不能直接证明这种标准可靠性。相反，它只能证明一种局部可靠性或局部一致性。

局部一致性（Local Consistency）

定义

我们声称构造的 SNARG 是局部一致的。这意味着存在一个局部赋值生成器（或提取器）E。

  • 输入：E 接收一组导线索引 I = {i1, ..., iL}。
  • 输出：E 输出一个（可能作弊的）实例 x* 以及对这 L 根导线的赋值 {wi1, ..., wiL}。
  • 性质：
    1. 局部一致性：对于输出导线赋值中涉及的任意一个门，只要该门的所有输入输出导线都在 I 中，那么这些赋值必须满足该门的约束。同时，如果输出导线在 I 中，其值必须为 1。
    2. 非信号性：赋值 {wi1, ..., wiL} 的分布（包括 x*）在计算上不依赖于集合 I 中未被请求的其他导线索引。更形式化地说，对于任意两个大小为 L 的索引集 I 和 J，在交集 I ∩ J 上的导线赋值分布，在给定 I 或给定 J 的情况下是计算不可区分的。

如何构造局部赋值生成器

给定一个作弊证明者 P*，我们可以如下构造局部赋值生成器 E：

  1. 输入：接收希望提取的导线索引集 I。
  2. 生成 CRS：
    • 运行半可提取哈希的密钥生成算法 Gen，针对索引集 I 生成哈希密钥 hash_key 和陷门 trapdoor。
    • 运行 BARG 的 CRS 生成算法，得到 CRS_BARG。
    • 组合得到 SNARG 的 CRS：CRS = (hash_key, CRS_BARG)。
  3. 运行作弊者：将 CRS 输入给 P*，P* 输出一个实例 x* 和一个 SNARG 证明 π = (V, π_BARG)。
  4. 验证与重试：如果 π 未被 SNARG 验证者接受，则回到步骤 2 重新生成 CRS 并尝试。重复多项式次，直到获得一个被接受的证明。
  5. 提取与输出：一旦获得被接受的证明，使用陷门 trapdoor 从哈希值 V 中提取出索引集 I 对应的导线值 {wi1, ..., wiL}。最后，输出 (x*, {wi1, ..., wiL})。

为何满足局部一致性

局部一致性源于底层 BARG 的可靠性（即使是半自适应的可靠性也足够）。

  • 思路：假设 E 以不可忽略的概率输出了一个不满足局部一致性的赋值。这意味着存在某个门 j，其导线赋值不满足门约束。
  • 构造 BARG 作弊者：我们可以利用 P* 和 E 来构造一个针对 BARG 的作弊证明者 P**。
    • P** 首先生成一个针对导线集 I（包含门 j 的导线）的哈希密钥。
    • 然后运行 P* 获得 (x*, V, π_BARG)。
    • P** 将 (hash_key, V, 1), (hash_key, V, 2), ..., (hash_key, V, k)（k 为门的总数）作为自适应选择的实例提交给 BARG 验证者。
    • 其中，第 j 个实例 (hash_key, V, j) 声称门 j 被满足。但由于我们从 E 知道门 j 的赋值不满足约束，并且哈希函数在索引 I 上是绑定的，因此这个实例实际上没有合法的见证（witness）。然而，P** 却提交了被接受的 BARG 证明 π_BARG。
  • 矛盾：这就违反了 BARG 的可靠性。因此，E 输出不满足局部一致性赋值的概率必须是可忽略的。

为何满足非信号性

非信号性源于半可提取哈希函数的“索引隐藏”属性。

  • 在我们的构造中，哈希函数是通过多次重复一个基础方案来支持多个可提取索引的。
  • 当提取器 E 使用陷门提取特定索引集 I 的导线值时，它只使用了与 I 对应的那部分陷门。
  • 作弊证明者 P* 无法区分哈希密钥是针对哪些索引集生成的。因此，提取出的导线值分布不会泄露关于其他索引的信息，否则就破坏了哈希函数的索引隐藏性质。

从局部一致性到全局一致性

现在，我们有一个局部赋值生成器 E，它能提供任何 L 根导线的、局部一致的赋值。我们最终的目标是证明：如果 SNARG 验证者接受了证明，那么原始实例 x 一定在语言中（即存在一个全局的、一致的导线赋值使电路输出 1）。这需要我们将局部一致性“缝合”成全局一致性。

对于确定性电路（P 语言）的尝试

对于确定性计算（P 语言），每个导线在给定输入后只有一个正确的值。我们曾尝试通过逐层归纳来证明全局一致性：

  1. 基础：请求输入层的导线赋值。由于局部一致性，这些值必须与输入 x 一致，因此是正确的。
  2. 归纳步骤：假设第 i 层的导线赋值是正确的。为了证明第 i+1 层的某个导线值 w 正确，我们可以请求一个包含第 i 层相关导线和 w 的赋值窗口。
    • 根据非信号性，第 i 层导线的赋值分布与之前请求时相同，因此它们仍然是正确的。
    • 根据局部一致性，w 的值必须基于其前驱（第 i 层导线）的正确值计算得出，因此 w 也是正确的。
  3. 结论：通过归纳，所有导线赋值都正确，输出导线值为 1，因此 x 在语言中。

尝试中的缺陷

上述论证存在一个微妙但关键的缺陷：它忽略了错误概率的累积。

  • 局部一致性和非信号性都是以“概率 1 - ν”成立的，其中 ν 是可忽略的函数，但不是零。
  • 在归纳步骤中，要声称第 i+1 层的导线 w 正确，需要同时保证：
    1. 第 i 层的前驱导线赋值正确（概率 ~ 1 - ν）。
    2. 局部一致性条件成立（概率 ~ 1 - ν）。
  • 因此，w 正确的概率大约是 (1 - ν)^2 ≈ 1 - 2ν。
  • 随着电路深度 d 增加，这个错误概率会以 2^d 的指数级增长。当 d 大于 log(1/ν) 时，最终的错误概率可能不再可忽略。这就是“指数级诅咒”。

解决方案与改进

为了解决这个问题，研究者们探索了多种方法：

  1. 空间有界计算：最早的解决方案是针对空间有界的确定性计算。思路是让窗口大小 L 足以容纳整个计算的一个“配置”（如整个内存状态）。这样，在归纳时，我们一次读取整个配置，错误概率是线性累积（d * ν）而非指数累积（2^d * ν）。但这使得 SNARG 证明的大小与计算空间成正比。

  2. 电路变换（例如，添加默克尔哈希）：更通用的思路是修改待验证的原始电路 C，得到一个扩展电路 C‘。例如，可以在每一层计算完成后，添加一个对该层所有导线值的默克尔哈希值作为电路的一部分。

    • 优点：默克尔哈希的计算深度很浅。
    • 论证思路：首先证明基础层（如输入层）的默克尔根是正确的。然后，在归纳中，当请求高层导线值时，同时请求其对应的默克尔路径和根。如果根是正确的，那么根据哈希函数的抗碰撞性，路径末端的导线值也必须是正确的。这样，错误主要来自证明根正确的过程，而由于默克尔树深度小，其错误累积是可控的。
    • 这种方法允许构造证明大小与电路深度无关的 SNARG，适用于更广泛的电路类型。

总结

本节课中，我们一起学习了：

  1. 局部一致性：我们从 BARGs 构造的 SNARG 能够保证，对于任何作弊证明者，都存在一个局部赋值生成器，能为任何一小部分导线提供看似一致且满足“非信号性”的赋值。
  2. 局部 vs 全局：虽然局部一致性是一个强有力的性质，但将其提升为标准的全局可靠性（即证明实例在语言中）并非易事。对于确定性计算（P），简单的归纳论证会因错误概率的指数累积而失败。
  3. 当前进展：通过修改电路（如引入默克尔哈希结构），可以克服这一障碍，从而为一大类电路构造出实用的 SNARGs。然而，为所有 NP 语言构造 SNARGs 仍然是一个重大的开放性问题。

这个领域展示了理论密码学中优美数学思想与实际应用（如区块链和可验证计算）的深刻结合，是一个持续活跃且充满挑战的研究前沿。

posted @ 2026-03-29 09:22  绝不原创的飞龙  阅读(2)  评论(0)    收藏  举报