斯坦福代数编程理论笔记-全-

斯坦福代数编程理论笔记（全）

001：动机与基本问题 🎯

在本节课中，我们将学*代数编码理论的基本动机和核心问题。编码理论旨在解决信息在存储或传输过程中可能被破坏的问题，通过引入冗余来保护原始数据。

基本问题

编码理论的基本问题如下：我们有一个长度为 K 的消息 X（例如一个长度为 K 的比特串）。我们通过某种方式对 X 进行编码，得到一个长度为 N 的码字 C，其中 N > K。这样做的目的是为原始数据添加冗余。

接下来，预期会发生一些“坏事”，例如某些比特在传输或存储过程中被破坏（如翻转）。我们最终得到的是一个被破坏的码字，记作 C̃。

编码理论的目标是设计这种编码映射方式，使得在给定被破坏的码字 C̃（或对其的部分访问）后，我们能够恢复出原始消息 X 或其相关信息。

典型应用场景

这个基本框架出现在许多应用中。以下是两个典型例子：

1. 通信 📡

假设有一个发送者爱丽丝和一个接收者鲍勃。爱丽丝希望发送消息 X 给鲍勃，但他们之间存在一个有噪信道。任何通过该信道发送的信息都可能在途中被破坏。

以下是通信场景的步骤：

爱丽丝将消息 X 编码为码字 C。
爱丽丝通过有噪信道发送 C。
信道对 C 造成破坏，鲍勃接收到的是 C̃。
鲍勃需要从 C̃ 中解码，恢复出爱丽丝原本想发送的消息 X。

2. 存储 💾

在这个例子中，消息 X 不再是要传输的信息，而是我们想要存储的文件（同样是一个长度为 K 的比特串）。

以下是存储场景的步骤：

我们不直接存储文件 X，而是先将其编码为码字 C 以引入冗余。
将码字 C 存储到存储介质（如硬盘、U盘）上。
存储介质可能发生故障（如磁盘退化、损坏），导致读取时得到的是被破坏的码字 C̃。
我们需要从 C̃ 中恢复出原始文件 X，以避免数据丢失。

通信和存储只是编码理论应用的两个例子，它在计算机科学、工程和数学等领域中无处不在。在本课程中，我们将会看到更多应用实例。

编码方案的核心考量

现在，让我们聚焦于我们对一个编码方案关心哪些方面。

以下是四个核心考量因素：

处理“坏事”的能力：即方案能够应对何种类型的错误或损坏。
恢复所需信息的能力：即我们期望从被破坏的数据中恢复出关于 X 的哪些信息（例如全部恢复，或仅恢复部分）。
最小化开销：对我们而言，这通常意味着希望最大化比率 K / N。这里，K 是原始消息长度，N 是最终存储或发送的码字长度。这个比率被称为码率。比率越接* 1，意味着冗余开销越小；比率越小，则开销越大。我们的目标是尽可能减少开销，即让码率尽可能接* 1。
效率：例如，编码映射（将 X 映射为 C）和解码映射（从 C̃ 恢复 X）需要能够高效运行。

核心问题与权衡

考虑到以上四个我们关心的方面，本课程后续要解决的核心问题（或者说是一系列问题）是：在这些因素之间，最佳的权衡是什么？

例如，一个直观的权衡是：如果我们极力最小化开销（即添加很少的冗余），那么保护数据免受损坏并恢复信息的能力就会变得困难得多。

之所以说这是一系列问题而非单一问题，是因为我们尚未精确定义上述概念：

“坏事”具体指什么？是指一定比例的符号被破坏，还是指部分符号丢失（删除），或是其他情况？
我们想恢复关于 X 的什么信息？是完全恢复 X，还是仅恢复其第一位，或是其他？
“高效”具体指什么？我们以何种方式、多大成本访问被破坏的码字 C̃？我们拥有多少计算资源来处理获得的信息？

定义这些概念的方式有很多种，每种定义都会引出一系列关于这些权衡的、各不相同且非常有趣的问题。

在下一个简短的视频中，我们将给出一些正式的定义，为这些问题提供一种具体的描述方式，并引出我们将在后续课程中重点研究的一类问题。当然，定义的方式还有很多，随着课程的深入，我们可能会遇到其他不同的定义框架。

002：定义与示例 📚

在本节课中，我们将学*编码理论中的一些核心正式定义，并通过具体示例来理解这些概念如何应用于实际通信场景。

概述

上一节我们通过一个非正式的故事介绍了编码理论的动机。本节中，我们将正式定义什么是“码”，并引入汉明距离、最小距离、码率等核心概念。我们将通过几个具体的例子来展示码如何检测和纠正错误。

码的正式定义

我们从一个码的正式定义开始。

定义：一个码 C，其分组长度为 n，定义在字母表 Σ 上，是 Σ^n 的一个子集。这里，n 是一个正整数，Σ 是一个有限集合（例如 {0, 1}）。码 C 中的元素 c 被称为码字。

目前来看，这还不是一个非常有趣的定义。一个码 C 只是一组长度为 n 的向量，其系数来自某个有限字母表 Σ。在我们了解它如何变得有趣之前，先看几个例子以确保理解基本概念。

以下是几个示例：

示例一：考虑码 C = {“HELLOWORLD”, “BRUNCHTIME”, “ALLTHETIME”}。这是一个完全有效的码。它的分组长度为 10，字母表 Σ 是所有大写字母 {A, B, C, …, Z}。有时，我们也会直接称分组长度为“长度”。
示例二：考虑码 C 是以下向量的集合：
```
{ (0,0,0,0),
  (0,0,1,1),
  (0,1,0,1),
  (0,1,1,0),
  (1,0,0,1),
  (1,0,1,0),
  (1,1,0,0),
  (1,1,1,1) }
```
这是 8 个长度为 4 的向量，每个向量的字母表是 {0, 1}。因此，这是一个分组长度为 4、字母表 Σ = {0, 1} 的码。当 Σ = {0, 1} 时，我们称该码为二进制码。

码与编码图的关系

此时，你可能理解了码的定义，但可能想知道这个定义与我们之前讲述的 Alice 和 Bob 的故事有何关系。

回忆一下，我们之前的场景是：Alice 有一个消息 x ∈ Σ^k，她通过一个编码图 Enc 将其编码为一个码字 c ∈ Σ^n。然后，这个码字在传输中可能被损坏，接收方 Bob 收到一个损坏的码字 c̃，他的任务是根据 c̃ 推断出原始消息 x。

为了理解码的定义与这个场景的关系，让我们回到上面的示例二。考虑以下编码图：
Enc: {0,1}^3 → {0,1}^4，定义为：
Enc(x1, x2, x3) = (x1, x2, x3, x1 + x2 + x3 mod 2)。

例如，Enc(0,1,1) = (0,1,1,0)，因为 0+1+1 = 0 (mod 2)。观察这个例子，你会发现码 C 实际上就是这个编码图 Enc 的像（所有可能输出值的集合）。这就解释了码的定义与图中编码部分的关系：码是所有可能码字的集合。

码的纠错与检错能力

那么，关于“发生错误并试图修复”的部分呢？下面的示例二实际上可以在一定程度上做到这一点。

更准确地说，这个例子可以纠正 1 个删除。让我通过例子解释这意味着什么。

假设你看到损坏的码字 c̃ = (0, ?, 0, 1)。我承诺你看到的这些符号是正确的，但有人不小心用红笔涂掉了其中一个。问题是：原始的码字是什么？通过查看码 C，你可以推断出缺失的位必须是 1。原因是：0 + ? + 0 mod 2 必须等于 1，而唯一能使等式成立的情况是 ? = 1。因此，接收方 Bob 可以正确推断出缺失的位是 1，从而得知 Alice 的原始消息是 (0,1,0)。

这里发生的就是一个删除：某个位被擦除了，我们知道是哪个位置，但不知道它的实际值。

类似地，这个例子也可以检测 1 个错误。再次通过例子说明。

假设你看到损坏的码字 c̃ = (0,0,0,1)，并且我告诉你：要么一切正常，要么有一个位被翻转了（我们称之为错误：一个位出错，但我们不知道是哪一个）。那么，发生了什么？一切正常还是出错了？如果出错了，是哪里出错了？你可能会意识到出错了，因为 (0,0,0,1) 不是一个合法的码字（合法的码字要求第四位是前三位之和 mod 2，但这里 0+0+0 ≠ 1）。然而，你可能也意识到你无法确定是哪个位被翻转了，可能是其中任何一个。因此，在这种情况下，我们说这个码可以检测一个错误（因为它知道出错了），但它不一定能纠正这个错误。

在下一个例子中，我们将看到一个可以真正纠正一个错误的码。

一个能纠正错误的码

考虑编码图 Enc: {0,1}^4 → {0,1}^7，定义如下：
Enc(x1, x2, x3, x4) = (x1, x2, x3, x4, x2+x3+x4 mod 2, x1+x3+x4 mod 2, x1+x2+x4 mod 2)。

和之前一样，让码 C 是这个编码图的像。因此，C 是一个分组长度为 7 的二进制码。

这个定义看起来有点奇怪，但有一种很好的可视化方法。想象三个重叠的圆圈：蓝色、红色和黄色。将消息位 x1, x2, x3, x4 放在重叠区域的特定位置。那么，每个额外的校验位（c5, c6, c7）就对应每个圆圈中其他位的异或和（mod 2 加法）。具体来说：

c5 = x2 + x3 + x4 mod 2 （红色圆圈内所有位）
c6 = x1 + x3 + x4 mod 2 （蓝色圆圈内所有位）
c7 = x1 + x2 + x4 mod 2 （黄色圆圈内所有位）

我声称这个码可以纠正一个错误。让我们通过例子来看。

假设我告诉你，一个这种形式的码字最多发生一个错误（即最多有一个位被翻转）。你看到的结果是 (0,1,1,1,0,1,0)。问题是：原始的码字 c 是什么？通过检查三个圆圈的奇偶性（每个圆圈内所有位之和应为偶数 mod 2），你会发现蓝色圆圈正常，但红色和黄色圆圈的奇偶性都不对（有奇数个 1）。这两个圆圈共同包含的位是 x3（对应接收向量的第三位 1）。因此，这个位一定是出错的位，应该将其从 1 翻转为 0。这样我们就得到了纠正后的码字 (0,1,0,1,0,1,0)。由于码的最小距离为 3（稍后证明），这个纠正方案是唯一的。

汉明距离与最小距离

上面的圆圈解法看起来有些特殊。为了使其不那么特殊并围绕它建立一些理论，我们将引入更多定义。

我们的第一个定义是汉明距离。

定义：两个向量 x 和 y（属于 Σ^n）之间的汉明距离 Δ(x, y) 定义为：
Δ(x, y) = Σ_{i=1}^{n} [x_i ≠ y_i]
其中 [条件] 是指示函数（条件为真时值为 1，否则为 0）。也就是说，汉明距离就是向量 x 和 y 在不同位置上的数量。

我们还可以定义相对汉明距离：
δ(x, y) = Δ(x, y) / n
即不同位置所占的比例。

一个相关的定义是码的最小距离。

定义：一个码 C ⊆ Σ^n 的最小距离 d 定义为：
d = min_{c ≠ c‘ ∈ C} Δ(c, c‘)
即查看码中每一对不同的码字，计算它们之间的汉明距离，然后取这些距离中的最小值。

为什么我们关心这些定义？正如我们即将看到的，具有较大最小距离的码可以用来纠正错误。

最小距离与纠错能力的关系

具体来说，有以下定理：

定理：一个最小距离为 d 的码可以做到：

纠正最多 d - 1 个删除。
检测最多 d - 1 个错误。
纠正最多 ⌊(d-1)/2⌋ 个错误。

我们可以通过一个算法/图示来非正式地证明。想象以正确码字 c 为中心，画一个半径为 ⌊(d-1)/2⌋ 的汉明球（所有与 c 距离不超过该半径的向量的集合）。由于最小距离为 d，任何其他码字 c‘ 都必然在这个球之外，并且以 c‘ 为中心的相同半径的球与 c 的球是不相交的。

纠正错误：如果发生不超过 ⌊(d-1)/2⌋ 个错误，接收到的向量 c̃ 将落在 c 的球内，而不会落在任何其他码字的球内。因此，寻找与 c̃ 汉明距离最*的码字的算法总能正确返回 c。
检测错误：如果发生不超过 d-1 个错误，c̃ 可能仍然在 c 的球内（半径为 d-1 的更大球），但不可能到达任何其他码字 c‘。因此，c̃ 本身是一个合法码字的唯一可能性就是它等于 c。所以，算法可以通过检查 c̃ 是否是码字来判断是否出错。

回顾示例

现在让我们回到之前的例子。

示例二（单个奇偶校验位）：可以验证这个码的最小距离为 2。正如我们所见，它可以纠正 1 个删除，检测 1 个错误。这与定理一致（d=2，d-1=1 个删除/错误检测，⌊(d-1)/2⌋=0 个错误纠正）。
示例三（圆圈码）：这个码的最小距离为 3。这解释了为什么它能纠正一个错误（⌊(3-1)/2⌋ = 1）。当我们之前纠正一个错误时，不必担心有其他解，因为最小距离保证了唯一性。

码率与开销

有了最小距离的定义，我们可以更精确地描述我们对编码图的要求：我们希望码具有足够的最小距离 d 以对抗一定数量的最坏情况错误或删除。同时，我们希望最小化开销。

为了量化开销，我们引入以下定义：

定义：一个定义在字母表 Σ 上的码 C 的消息长度（或维度） k 定义为：
k = log_{|Σ|} (|C|)
其中 |C| 是码字的总数，|Σ| 是字母表大小。

定义：一个分组长度为 n 的码 C 的码率 R 定义为：
R = k / n
即消息长度与分组长度之比。

码率 R 是一个介于 0 和 1 之间的数。R 越接* 1 越好，意味着开销越小（有效信息占比高）。R 接* 0 则意味着开销很大。

定义：一个具有距离 d、消息长度 k、分组长度 n、字母表 Σ 的码，被称为一个 [n, k, d]_{|Σ|} 码。这是一种汇总码的重要参数的符号。

因此，我们关心的核心问题可以简化为：我们想要一个具有足够最小距离 d，并且码率 R 尽可能接* 1 的码（理想情况下，编解码算法还要高效）。

这就引出了一个根本性问题：码率 R 和最小距离 d 之间可能存在的最佳权衡是什么？ 理解这一点，就能理解为了纠正最坏情况错误或删除，必要的开销是多少。这个问题非常基础，也已被思考了很久。对于二进制码，我们至今仍未完全知晓答案，但已经了解了很多相关知识。

总结

本节课中，我们一起学*了编码理论的核心定义。我们正式定义了码、码字、汉明距离、最小距离和码率。通过具体示例，我们看到了码如何利用其结构来检测和纠正传输中的错误，并理解了最小距离与纠错能力之间的理论关系。最后，我们明确了编码的核心目标：在给定纠错能力（最小距离 d）的前提下，追求尽可能高的码率 R 以降低开销。在接下来的课程中，我们将开始探索码率与距离之间的权衡关系。

003：汉明界

在本节课中，我们将学*编码理论中的第一个基本界限——汉明界。这个界限描述了编码的码率和最小距离之间必须满足的权衡关系。

上一节我们提出了“码率与距离的最佳权衡是什么”的问题。本节中，我们来看看汉明界如何为这种权衡设定一个基本的限制。

核心思想

假设整个空间是 Σⁿ（所有长度为 n、字母表为 Σ 的字符串集合）。我们有一个最小距离为 d 的码 C，其码字分布在这个空间中。

现在，考虑以每个码字为中心、半径为 ⌊(d-1)/2⌋ 的汉明球。由于码的最小距离为 d，这些球彼此之间是不相交的。

汉明界的基本逻辑是：我们有 |C| 个不相交的汉明球，它们都必须容纳在总空间 Σⁿ 中。因此，汉明球的数量（即码字数量）不能太多，否则空间将无法容纳。这意味着码率不能太高。

为了将这个直观想法转化为定量的界限，我们需要几个定义。

定义与公式

首先，我们正式定义汉明球。

对于字母表 Σ，在空间 Σⁿ 中，以点 x 为中心、半径为 e 的汉明球定义为：

B_{Σⁿ}(x, e) = { y ∈ Σⁿ | Δ(x, y) ≤ e }

其中 Δ(x, y) 表示 x 和 y 之间的汉明距离。

汉明球的体积（包含的点数）记为 Vol_q(e, n)，其中 q = |Σ| 是字母表大小。体积与中心点 x 无关。

对于一个大小为 q 的字母表，半径为 e、维度为 n 的 q 元汉明球体积公式为：

Vol_q(e, n) = Σ_{i=0}^{e} C(n, i) * (q-1)^i

其中 C(n, i) 是组合数。这个公式的每一项分别计算了与中心点汉明距离为 0, 1, ..., e 的向量数量。(q-1)^i 项是因为在 i 个不同的位置上，每个位置可以有 (q-1) 种非零取值（假设字母表包含 0）。

另一个有用的定义是向量的权重，即向量中非零元素的个数。

推导汉明界

现在，我们回到之前的直观图景来推导界限。

设 C ⊆ Σⁿ 是一个长度为 n、字母表大小为 q 的码，其最小距离为 d，消息长度为 k。

根据之前的讨论，所有不相交的汉明球（半径为 t = ⌊(d-1)/2⌋）的总体积不能超过整个空间的体积：

|C| * Vol_q(t, n) ≤ qⁿ

对不等式两边取以 q 为底的对数：

log_q(|C|) + log_q(Vol_q(t, n)) ≤ n

重新排列，并回忆码率 R 的定义为 R = log_q(|C|) / n，我们得到汉明界：

R ≤ 1 - [ log_q(Vol_q(⌊(d-1)/2⌋, n)) / n ]

这个公式给出了在给定最小距离 d 和长度 n 下，码率 R 所能达到的上限。

实例分析：汉明码

为了观察汉明界的作用，我们回顾上一讲的例3（即汉明码）。

以下是该码的参数：

消息长度 k = 4
分组长度 n = 7
最小距离 d = 3
字母表大小 q = 2

让我们计算汉明界给出的限制。

首先，计算半径为 t = ⌊(3-1)/2⌋ = 1 的汉明球体积：

Vol_2(1, 7) = C(7,0) * (1)^0 + C(7,1) * (1)^1 = 1 + 7 = 8

然后，代入汉明界公式：

R ≤ 1 - (log_2(8) / 7) = 1 - (3 / 7) = 4/7

对于这个汉明码，其实际码率 R = k/n = 4/7，恰好达到了汉明界给出的上限。

这意味着，对于参数 (n=7, k=4, d=3, q=2)，汉明码在码率与距离的权衡上达到了理论最优。这样的码被称为完美码。

总结与思考

本节课中，我们一起学*了汉明界。我们通过“不相交的汉明球必须容纳在总空间中”这一直观概念，推导出了码率 R 与最小距离 d 之间必须满足的不等式关系。汉明界为编码的性能设定了一个基本限制。

通过分析汉明码的例子，我们发现它达到了汉明界，因而是最优的。这引出了一个有趣的问题：能否构造出其他达到汉明界的“完美码”？ 这样的码在给定的参数下具有理论最优的纠错能力。我们将在后续课程中部分探讨这个问题。

代数编码导论：04：汉明码（再探）🔍

在本节课中，我们将重新审视之前介绍过的一个例子——汉明码。我们将从线性代数的角度，通过生成矩阵和校验矩阵两种新方式来理解它，并利用这些视角轻松计算其距离和实现解码。

概述 📋

汉明码是一个消息长度 K = 4、码字长度 n = 7、字母表为 {0, 1} 的编码方案。其编码规则是：前四位是原始消息位，后三位是前四位的特定线性组合（模2运算）。我们将看到，这个结构可以用矩阵乘法来简洁地描述。

生成矩阵视角 🧮

上一节我们回顾了汉明码的基本定义，本节中我们来看看如何用矩阵来表示其编码过程。

我们可以将编码映射视为一个矩阵与向量的乘法（模2运算）。具体来说，将消息向量 x = (x₁, x₂, x₃, x₄) 编码为码字 c 的过程可以写成：

c = G · x (mod 2)

其中，矩阵 G 被称为生成矩阵，其结构如下：

G = [ 1 0 0 0 ]
    [ 0 1 0 0 ]
    [ 0 0 1 0 ]
    [ 0 0 0 1 ]
    [ 0 1 1 1 ]
    [ 1 0 1 1 ]
    [ 1 1 0 1 ]

（矩阵中未标出的位置均为0）

这个矩阵的前四行构成了一个单位矩阵，确保了消息位原样出现在码字前四位。后三行则定义了三个校验位的计算规则。

基于这个矩阵表示，我们可以做出一些线性代数上的观察（假设模2下的线性代数性质成立）：

码字集合对加法封闭：对于码 C 中的任意两个码字 c 和 c'，它们的和 c + c' (mod 2) 仍然在 C 中。这是因为 c + c' = Gx + Gx' = G(x + x')，而 G(x + x') 本身就是一个码字。
码是一个线性子空间：码 C 是向量空间 {0,1}⁷ 中的一个维度为 4 的线性子空间。它实际上是生成矩阵 G 的列张成的空间。由于 G 的前四列线性独立（构成单位矩阵），所以其列空间的维度为4。
距离等于最小重量：一个线性码的距离（任意两个不同码字之间的最小汉明距离）等于其最小重量（除零向量外，所有码字中非零位的最小数量）。这是因为两个码字 c 和 c' 的距离等于 c - c' 的重量，而 c - c' 本身也是一个码字。

校验矩阵视角 🔍

上一节我们从生成的角度看了汉明码，本节我们换一个角度，看看如何用校验条件来等价地定义它。

回顾汉明码的“圆圈”图示，每个圆圈都代表一个模2和为0的校验方程。我们可以将这些线性约束写成一个矩阵方程：

H · c = 0 (mod 2)

其中，矩阵 H 被称为校验矩阵，其结构如下：

H = [ 0 1 1 1 1 0 0 ]
    [ 1 0 1 1 0 1 0 ]
    [ 1 1 0 1 0 0 1 ]

（矩阵中未标出的位置均为0）

矩阵 H 的每一行对应一个圆圈的校验条件。这意味着，码 C 恰好是矩阵 H 的核（kernel），即所有满足 H·c = 0 的向量 c 的集合。通过维度计算（H 的秩为3，核的维度为7-3=4），可以验证这与码的维度一致，因此 C = ker(H)。

线性代数视角的应用 💡

拥有了校验矩阵这个强大工具后，我们可以更轻松地解决关于汉明码的两个关键问题。

以下是利用校验矩阵可以轻松完成的两项任务：

证明距离为3：
- 根据之前的观察，只需证明码的最小重量是3。
- 假设存在一个重量为1或2的码字 c，那么 H·c = 0 意味着 H 的某一行或两列的线性组合（模2）为零。
- 然而，观察 H 的列可以发现，没有任何一列是全零列，并且任意两列都互不相同（即线性无关）。因此，不可能有一列或两列的线性组合为零。这矛盾说明不存在重量小于3的码字。
- 同时，码字 (0,1,0,1,0,1,0) 的重量恰好为3。因此，汉明码的距离正好是3。
提供简洁的解码算法：
- 假设接收到的（可能出错的）向量是 c̃，且最多有一个比特错误，即 c̃ = c + z，其中 c 是原始码字，z 是重量至多为1的错误向量。
- 计算 s = H · c̃ (mod 2)，这个结果 s 被称为伴随式（syndrome）。
- 由于 H·c = 0，所以 s = H·z。
- 如果 z 的重量为1，假设错误发生在第 i 位，那么 s 就等于 H 的第 i 列。
- 因此，解码算法是：计算 s = H·c̃，然后在 H 的列中寻找等于 s 的那一列。该列的索引 i 就是出错的位置。将 c̃ 的第 i 位取反（模2下加1），即可得到正确的码字 c。

总结 🎯

本节课中我们一起学*了从线性代数角度重新审视汉明码。

我们首先看到，长度为7的汉明码 C 是 {0,1}⁷ 中的一个线性子空间。
这让我们可以用两种等价的方式来描述它：
1. 生成矩阵描述：C = { G·x | x ∈ {0,1}⁴ }，即矩阵 G 的列张成的空间。
2. 校验矩阵描述：C = { c ∈ {0,1}⁷ | H·c = 0 }，即矩阵 H 的核。
最后，我们发现这种线性代数视角非常有用。它让我们能够轻松地证明汉明码的距离为3，并提供了一个高效、清晰的单错误解码算法。

然而，我们所有的推导都建立在“模2下的线性代数性质成立”这一假设之上。在进入下一讲之前，建议你思考一下：我们的论证在哪些地方依赖了线性代数的标准性质？这些性质在模2运算下是否依然成立？

代数编码导论：p05：一个警示性的例子 🔍

在本节课中，我们将要学*一个关于模运算下线性代数可能失效的警示性例子。我们将通过一个具体的模4运算的例子，来理解为什么不能理所当然地将实数域上的线性代数结论直接套用到有限域上。

在上一节视频中，我们看到，如果线性代数在模2运算下“正常工作”，会带来很多便利。

本节中，我们来看看一个快速的例子，说明为什么我们不应该理所当然地认为这种“正常工作”总是成立。

具体来说，在模4运算下，情况似乎会变得更加复杂。

以下是一个例子。

假设字母表 Σ 是 {0, 1, 2, 3}，我们在模4下运算。考虑矩阵 G。

这个矩阵将作为我们的生成矩阵，其值为：

G = [2, 0;
     0, 2;
     2, 2]

同时，令 H 为 G 的转置，所以 H 为：

H = [2, 0, 2;
     0, 2, 2]

现在，考虑由生成矩阵 G 定义的码 C。

即，C 是所有 G 乘以 x 的结果（模4）的集合，其中 x 取自集合 {0, 1, 2, 3}²。

因此，C 是一个消息长度 k = 2、码块长度 n = 3、定义在字母表 Σ 上的码。

让我们尝试用这个码重复上一节视频中针对汉明码所做的同类分析。

首先注意到，对于这个 H，我们有：

H * G = [8, 4;
         4, 8] ≡ [0, 0;
                  0, 0] (mod 4)

这意味着 H 是 C 的一个合法的校验矩阵。也就是说，对于码 C 中的所有码字 c，存在某个对应的消息 x，使得 H * c = H * (G * x) ≡ 0 (mod 4)。

这如同之前一样，意味着 C 包含在 H 的核空间中。

至此，我们得到了一个定义在大小为4的字母表上的码 C，以及其生成矩阵和校验矩阵。但这里有些地方不太对劲。

首先，H 的核空间的维数。

如果我们沿用上一节视频中的逻辑，它应该是 3 - 2 = 1。这是因为观察矩阵 H，它的两行看起来是线性无关的，所以 H 的秩应为2，那么核空间维数就是 3 - 2 = 1。

另一方面，码 C 的维数应该等于2。

因为 C 是矩阵 G 的列张成的空间，而 G 的两列看起来也是线性无关的，所以秩应为2。

但这说不通，因为一个维数为2的空间不可能包含在一个维数为1的空间里。

所以这里有些奇怪。不过，让我们先忽略这一点，继续进行计算。

让我们尝试沿用之前的逻辑，通过观察校验矩阵来确定这个码的距离。

如果我们这样做，会发现奇怪的事情仍在继续。

如果应用上一节视频中的相同逻辑，可以证明这个码的距离至少为3。这个结论的得出，是基于 H 中没有任何两列是线性相关的（至少看起来是这样）。

但是，考虑码字 G 乘以向量 (1, 1)ᵀ：

G * [1; 1] = [2; 2; 4] ≡ [2; 2; 0] (mod 4)

这个向量的汉明重量为2。

这意味着，如果遵循上一个例子的逻辑，码 C 的距离小于或等于2。

于是我们得出了一个矛盾的结论：3 ≤ 2。这显然是有问题的。

那么，问题出在哪里呢？

也许你在跟随论证过程时已经发现了，我陈述了一些错误或没有意义的事情。

我所说的没有意义的主要事情是，我断言某些向量是线性无关的。

例如，我断言 H 的列向量 [2, 0]ᵀ 和 [0, 2]ᵀ 是线性无关的。我还断言 G 的列向量 [2, 0, 2]ᵀ 和 [0, 2, 2]ᵀ 是线性无关的。

如果我们暂时忘记是在模4下运算，这看起来相当合理。一个向量看起来不是另一个向量的标量倍数。

但如果我们实际查阅线性无关的正式定义，就会发现问题所在。

例如，如果我想正式证明这些向量是线性无关的，我会怎么做？

以下是一个注定会失败的证明。假设存在这些向量的一个非平凡线性组合等于0。

也就是说，假设存在系数 a 和 b，使得：

a * [0; 2] + b * [2; 0] = [0; 0]

那么我们可以得出结论：向量 [2b; 2a] 等于向量 [0; 0]。如果我们两边同时除以2，就意味着向量 [b; a] 等于向量 [0; 0]，从而推出 a = 0 且 b = 0。因此，这并不是一个非平凡的线性组合，所以这些向量线性无关。

这个证明在实数域上是完全正确的，但在模4下是错误的。原因在于，在模4下“除以2”这个操作没有意义。

事实上，我们确实可以找到这些向量的一个非平凡线性组合等于0。例如：

2 * [0; 2] + 2 * [2; 0] = [4; 4] ≡ [0; 0] (mod 4)

所以，之前出错的地方在于，我仅仅因为两个向量不是彼此的标量倍数，就断言它们是线性无关的，但这在模4下并不成立。

以上所有这些只是为了说明，当我们开始在模2（或其他模数）下进行线性代数运算时，应该更加谨慎。

在下一节视频中，我们将深入探讨，要使这种“线性代数”在有限域上合法有效，究竟需要满足什么条件。

本节课中，我们一起学*了一个在模4运算下线性代数直觉失效的具体例子。我们看到了如何错误地判断向量的线性无关性，以及这如何导致关于码的维数和距离的矛盾结论。这个例子强调了在将实数域上的线性代数概念应用到有限域时，必须严格遵循定义，并意识到运算规则的根本不同。

代数编码导论：06：有限域

在本节课中，我们将学*有限域的概念。有限域是代数编码理论中至关重要的数学结构，它为在线性代数运算中处理有限元素集合提供了坚实的理论基础。

在上一个视频中，我们了解到在有限集合上进行线性代数运算需要格外小心，例如在模4的整数集合上。本节视频将说明，只要我们在称为“有限域”的结构上进行运算，一切都会顺利进行。如果你已经熟悉有限域，可以跳过本节。

什么是域？什么是有限域？

首先，我们从一个非正式的定义开始。

非正式地讲，一个域是一个元素集合，你可以在其中像通常期望的那样进行加、减、乘、除运算。

那么，一个有限域就是一个有限的元素集合，你可以在其中同样自由地进行加、减、乘、除运算。

现在，让我们将这个定义形式化。

定义：一个域 F（我几乎总是用黑板粗体 F 来表示一个域）是一个元素集合，连同两个称为加法（+）和乘法（×）的运算，使得以下性质成立：

结合律：对任意 x, y, z ∈ F，有 (x + y) + z = x + (y + z) 和 (x × y) × z = x × (y × z)。
交换律：对任意 x, y ∈ F，有 x + y = y + x 和 x × y = y × x。
分配律：对任意 x, y, z ∈ F，有 x × (y + z) = (x × y) + (x × z)。
单位元存在性：存在加法单位元 0 ∈ F，使得对任意 x ∈ F，有 x + 0 = x。存在乘法单位元 1 ∈ F，使得对任意 x ∈ F，有 x × 1 = x。
逆元存在性：
- 加法逆元：对任意 x ∈ F，存在 y ∈ F 使得 x + y = 0。这个 y 记作 -x。
- 乘法逆元：对任意非零元素 x ∈ F（即 x ≠ 0），存在 y ∈ F 使得 x × y = 1。这个 y 记作 x⁻¹ 或 1/x。

一个有限域就是一个元素个数有限的域。

例子与非例子

为了理解这个定义，让我们看一个具体的例子和一个反例。

例子：模5的整数域
考虑集合 {0, 1, 2, 3, 4}，运算为模5的加法和乘法（即 + mod 5 和 × mod 5）。

以下是验证它满足域的所有条件：

结合律、交换律、分配律：由于普通整数运算满足这些定律，模5运算也继承这些性质。
单位元：0 是加法单位元，1 是乘法单位元。
逆元：
- 加法逆元：1+4=0, 2+3=0, 0+0=0。每个元素都有加法逆元。
- 乘法逆元：1×1=1, 2×3=1 mod 5, 4×4=1 mod 5。每个非零元素都有乘法逆元。

因此，{0, 1, 2, 3, 4} 在模5运算下构成一个有限域。

非例子：模4的整数（不是域）
现在考虑集合 {0, 1, 2, 3}，运算为模4的加法和乘法。

它满足结合律、交换律、分配律，也有单位元 0 和 1。但是，它不满足乘法逆元条件。例如，元素 2 在模4下没有乘法逆元，因为：
2 × 0 = 0, 2 × 1 = 2, 2 × 2 = 0, 2 × 3 = 2。没有任何数与 2 相乘模4等于 1。
因此，模4的整数集合不是一个域。

有限域的存在性与结构

了解了域的定义和例子后，一个自然的问题是：有限域有哪些？它们何时存在？

对此有一个非常简洁的答案，由以下定理描述：

定理：对于每一个素数幂 pᵗ（其中 p 是素数，t 是正整数），都存在一个唯一的（在同构意义下）有限域，其元素个数恰好为 pᵗ。在本课程中，我们将其记作 F_{pᵗ}（有时也记作 GF(pᵗ)，GF 代表伽罗瓦域）。此外，不存在元素个数不是素数幂的有限域。

这个定理的证明超出了本课程范围，但你可以查阅抽象代数教材以深入了解。

一个特别有用的事实是：当 t = 1 时，即域的大小是素数 p 时，这个有限域就是整数模 p 的集合 {0, 1, ..., p-1}，以及模 p 的加法和乘法。我们刚才验证的模5域就是 F₅。

重要警告：当 t > 1 时，大小为 pᵗ 的有限域并不等于整数模 pᵗ 的集合。我们刚刚看到模4（2²）的集合不是一个域，尽管大小为4的有限域 F₄ 是存在的。尝试构造 F₄ 的加法和乘法表是一个很好的练*。

为什么有限域对本课程很重要？

在前几节的背景下，有限域对本课程至关重要的一个原因是：线性代数在有限域上“依然成立”。

这意味着，你在实数或复数域上熟悉和喜爱的线性代数中的大多数定义，在有限域上同样有意义且适用。

以下是几个关键概念在有限域 F 上的定义：

向量空间：我们可以定义向量空间 Fⁿ 为所有形如 (x₁, x₂, ..., xₙ) 的向量的集合，其中每个分量 xᵢ ∈ F。
子空间：Fⁿ 的一个子空间 V 是一个对加法和标量乘法封闭的集合。即，对于所有 v, w ∈ V 和所有标量 λ ∈ F，都有 v + λw ∈ V。
线性无关：向量 v₁, ..., vₜ ∈ Fⁿ 是线性无关的，如果不存在一组不全为零的标量 λ₁, ..., λₜ ∈ F，使得线性组合 ∑ λᵢ vᵢ = 0。
张成空间：向量 v₁, ..., vₜ 的张成空间 span{v₁, ..., vₜ} 是所有由这些向量的线性组合（系数来自 F）构成的向量的集合。
基与维数：子空间 V 的一个基是一组线性无关的向量，其张成空间恰好等于 V。子空间 V 的维数就是其任意一个基中向量的个数（可以证明，在域上，所有基的大小相同，因此维数定义良好）。

在这个意义上，线性代数在有限域上“运作良好”。许多算法，如高斯消元法，在有限域上同样有效。

当然，也有一些不同之处。例如，在实数域线性代数中关于角度、长度等的几何直觉，在有限域上不再适用。

补充说明：在非域的结构（如模 n 的整数环，当 n 不是素数时）上也可以进行某种程度的线性代数，但这会更复杂且性质不那么好（相关概念可查阅“模”）。在本课程中，我们将坚持使用有限域。

总结

本节课中，我们一起学*了有限域的核心概念。我们首先给出了域和有限域的形式化定义，要求集合元素在加、减、乘、除（除以非零元）运算下封闭且满足基本代数定律。接着，我们通过模5整数（是域）和模4整数（不是域）的例子加深了理解。然后，我们了解了有限域的存在性定理：有限域的元素个数必须是素数幂 pᵗ，且对于每个素数幂都存在唯一的（同构意义下）这样的域。最后，我们探讨了有限域对于本课程的重要性——它为在有限集合上进行可靠、定义良好的线性代数运算提供了基础，这是代数编码理论的基石。

007：线性编码 📚

在本节课中，我们将学*线性编码的核心概念，包括线性码的定义、生成矩阵、校验矩阵及其重要性质。我们将使用线性代数的语言来描述这些概念，使初学者也能轻松理解。

线性码的定义

上一节我们介绍了编码的基本概念，本节中我们来看看线性码的正式定义。

一个线性码 ( C )，维度为 ( K )，分组长度为 ( N )，定义在有限域 ( F ) 上，是 ( F^N ) 中的一个 ( K ) 维子空间。

这与我们之前对码的定义以及用 ( K ) 表示消息长度是一致的。具体来说，如果一个码 ( C ) 的分组长度为 ( N )，消息长度为 ( K )，字母表 ( \Sigma ) 等于有限域 ( F )，那么根据此定义，( C ) 是线性码当且仅当 ( C ) 是 ( F^N ) 的一个子空间。

特别地，我们可以注意到，如果码的消息长度是 ( K )，那么其维度也是 ( K )。这是因为，如果 ( C ) 是一个维度为 ( K ) 的子空间，那么其大小等于 ( |F|^K )。对等式两边取对数，我们有 ( K = \log_{|F|} |C| )，这恰好是我们对消息长度的定义。因此，线性码就是一个恰好是线性子空间的码。

生成矩阵

接下来，我们定义码的生成矩阵。我们已经在汉明码的例子中见过这个概念，现在我们将更一般地定义它。

假设 ( C ) 是 ( F^N ) 中维度为 ( K ) 的线性码。我们说一个矩阵 ( G \in F^{N \times K} ) 是码 ( C ) 的生成矩阵，如果码 ( C ) 是 ( G ) 的列张成的空间。也就是说，码 ( C ) 应该是集合 ( { G \cdot x \mid x \in F^K } )。

以下是关于生成矩阵的几个要点：

任何线性码都有生成矩阵。我们可以取 ( C ) 的任何一组基向量，将它们作为 ( G ) 的列即可。
生成矩阵不是唯一的。同一个码可能有多个生成矩阵。
通过行约简，总存在一个形如 ( G = \begin{bmatrix} I_K \ P \end{bmatrix} ) 的生成矩阵，其中 ( I_K ) 是 ( K \times K ) 的单位矩阵。这种形式的生成矩阵对应于系统编码。系统编码意味着消息的 ( K ) 个比特直接出现在码字的前 ( K ) 个比特中。因此，对于线性码，总是存在一个系统编码映射。

对偶码与校验矩阵

现在，我们来定义对偶码和校验矩阵。

首先，对偶码。假设 ( C \subset F^N ) 是一个线性码。我们定义 ( C ) 的对偶码为 ( C^\perp )，其表达式为：
[
C^\perp = { v \in F^N \mid \langle v, c \rangle = 0, \ \forall c \in C }
]
其中，( \langle v, c \rangle = \sum_{i=1}^{N} v_i c_i ) 是标准内积。对偶码的定义与线性代数中对偶子空间的定义完全相同。

接下来，校验矩阵。假设 ( C \subset F^N ) 是一个维度为 ( K ) 的线性码。我们说一个矩阵 ( H \in F^{(N-K) \times N} ) 是码 ( C ) 的校验矩阵，如果 ( C ) 是 ( H ) 的零空间，即：
[
C = { x \in F^N \mid H \cdot x = 0 }
]

以下是关于校验矩阵的几个要点：

任何线性码都有校验矩阵。我们可以取对偶码 ( C^\perp ) 的任何一组基向量，将它们作为 ( H ) 的行即可。
校验矩阵也不是唯一的。

重要性质

有了这些定义，我们来记录一些关于生成矩阵和校验矩阵的有用性质。我们在之前关于汉明码的例子中已经见过其中一些，这里不再证明，但你应该确保理解它们为何成立。

假设 ( C ) 是 ( F^N ) 中维度为 ( K ) 的线性码，其生成矩阵为 ( G )，校验矩阵为 ( H )。那么以下性质成立：

矩阵乘积为零：( H \cdot G = 0 )（零矩阵）。
对偶码的结构：对偶码 ( C^\perp ) 本身也是一个线性码，其维度为 ( N-K )。它的生成矩阵是 ( H^T )（( H ) 的转置），而其校验矩阵是 ( G^T )（( G ) 的转置）。
距离与最小重量：码 ( C ) 的距离等于其所有非零码字中的最小汉明重量。我们之前在汉明码的背景下论证过这一点，对于任何线性码，仅凭线性性就足以保证此性质成立。
距离与线性相关性：码 ( C ) 的距离是满足“校验矩阵 ( H ) 有 ( d ) 个线性相关的列”这一条件的最小数字 ( d )。我们同样在汉明码的例子中见过这个性质，它对于任何线性码都成立。

总结

本节课中我们一起学*了线性编码的核心构件。我们定义了线性码作为向量空间的子空间，引入了生成矩阵 ( G ) 用于编码消息，以及校验矩阵 ( H ) 用于验证码字和描述对偶码。我们还回顾了线性码的几个关键性质，包括距离与最小重量的等价性，以及距离与校验矩阵列线性相关性之间的关系。这些概念和工具为我们进一步分析和构造纠错码奠定了坚实的代数基础。

008：GV界

在本节课中，我们将学*一个基于上次建立的线性代数视角得出的重要结果，称为吉尔伯特-瓦尔沙莫夫界，简称GV界。GV界证明了在码率和距离之间存在良好权衡的编码是存在的。

📖 定理陈述

GV界的陈述如下：对于任意素数幂 Q，以及任意满足 D ≤ N 的 N 和 D，存在一个线性码 C。该码具有长度 N、字母表大小 Q 和距离 D。其码率 R（定义为 k/n）至少为以下表达式：

R ≥ 1 - (log_Q(V_Q(N, D-1)) - 1) / N

其中，V_Q(N, D-1) 表示在 N 维空间中，半径为 D-1 的汉明球的 Q 元体积。我们将证明的是针对素数幂 Q 和线性码的版本，但事实上，该定理在不附加这些条件时也成立。

🔍 与汉明界的比较

上一节我们介绍了GV界，本节中我们来看看它与之前学过的汉明界有何异同。

汉明界指出，对于任意具有长度 N、距离 D 和字母表大小 Q 的码 C，其码率 R 至多为：

R ≤ 1 - log_Q(V_Q(N, ⌊(D-1)/2⌋)) / N

以下是GV界与汉明界的几个主要区别：

不等式方向相反：汉明界是一个“不可能性”结果，它告诉我们无法构造出码率过高的码。相反，GV界是一个“可能性”结果，它断言存在具有不错码率的码。
半径参数不同：GV界中的半径是 D-1，而汉明界中是 ⌊(D-1)/2⌋。忽略GV界表达式中的 -1（因为除以 N 后影响很小），这是两个表达式之间最主要的定量差异。

这两个表达式中的对数项可能看起来有些复杂。现在，请暂停视频，思考并确认GV界的表达式（下界）确实小于汉明界的表达式（上界）。这是合理的，如果情况相反，数学上就会出现矛盾。

🧮 GV界的证明

在接下来的部分，我们将证明吉尔伯特-瓦尔沙莫夫界。证明思路是概率方法：我们随机选择一个具有特定码率的线性码，然后证明这个随机码具有良好距离的概率大于零。这就能推出至少存在一个具有该良好距离的码。

第一步：参数设定

首先，令 K 等于：

K = N - ⌈log_Q(V_Q(N, D-1))⌉ - 1

请注意，如果我们这样选择 K，那么 K/N 恰好就是GV界定理陈述中的码率表达式。

第二步：构造随机码

现在，我们选择一个随机的线性码 C，其维数为 K。也就是说，C 是 F_Q^N（N 维 Q 元域空间）中一个均匀随机的子空间。由于所有对象都是有限的，所以只需在所有可能的 K 维子空间中均匀随机地选取一个。

接着，令 G 是一个 N × K 的随机生成矩阵，其元素取自 F_Q。这本质上是为子空间 C 随机选取一组基，并用这组基作为 G 的列。

第三步：一个有用的事实

在分析随机码的距离之前，我们先记录一个有用的事实：

对于任意固定的非零向量 x ∈ F_Q^K，由这个随机矩阵 G 得到的向量 Gx 在集合 F_Q^N \ {0} 上是均匀分布的。

换句话说，如果我固定一个非零的 x，并用我的随机矩阵 G 乘以它，得到的向量将均匀地取遍 F_Q^N 中所有非零向量的可能性相同。这个事实的证明基于对称性，鼓励你暂停视频尝试进行形式化证明。

第四步：计算距离概率

我们的目标是证明这个随机码 C 的距离至少为 D 的概率非零。

由于 C 是线性码，其距离等于所有非零码字的最小汉明重量。这可以写成：

dist(C) = min_{x ∈ F_Q^K, x ≠ 0} weight(Gx)

现在，对于任意固定的非零 x，事件“weight(Gx) < D”发生的概率，等于向量 Gx 落入以 0 为中心、半径为 D-1 的汉明球内的概率。

根据上述有用事实，Gx 是均匀分布的。因此，这个概率等于该汉明球的体积除以整个空间的大小（需注意排除零点，但为简化分析，我们可以给出一个上界）：

P(weight(Gx) < D) ≤ V_Q(N, D-1) / Q^N

第五步：应用并集界限

我们想知道是否存在任何一个非零 x 使得 weight(Gx) < D。应用并集界限，这个存在性事件的概率上界为：

P(∃ x ≠ 0, weight(Gx) < D) ≤ (可能的 x 的数量) × P(weight(Gx) < D 对于某个特定的 x)

可能的非零 x 的数量最多为 Q^K 个。因此：

P(∃ x ≠ 0, weight(Gx) < D) ≤ Q^K × [V_Q(N, D-1) / Q^N]

第六步：完成证明

我们希望证明上述概率严格小于 1。如果成立，那就意味着我们的随机码“不具有良好距离（即距离 < D）”的概率小于 1，因此其“具有良好距离（距离 ≥ D）”的概率就严格大于 0。这就能推出至少存在一个这样的码。

让我们验证这个不等式。对不等式两边取以 Q 为底的对数：

K - N + log_Q(V_Q(N, D-1)) < 0

整理后得到：

K < N - log_Q(V_Q(N, D-1))

而根据我们最初对 K 的定义：K = N - ⌈log_Q(V_Q(N, D-1))⌉ - 1，这个不等式显然成立。因此，概率上界确实严格小于 1。

于是，我们得出结论：这个随机的 K 维线性子空间，其距离至少为 D 的概率严格大于 0。因此，这样的码是存在的。这便完成了吉尔伯特-瓦尔沙莫夫界的证明。

📝 总结

本节课中我们一起学*了GV界。我们首先陈述了定理，并将其与汉明界进行了对比，明确了前者是存在性下界，后者是性能上界。随后，我们使用概率方法证明了GV界：通过构造一个随机的线性码，并计算其满足最小距离要求的概率大于零，从而证明了满足特定码率和距离权衡的码是存在的。尽管定理中的公式看起来复杂，但其核心思想清晰有力，为我们寻找好码提供了理论保证。在后续课程中，我们将进一步解读这个公式的直观含义。

代数编码导论：09：线性码的高效算法

在本节课中，我们将要学*线性码所支持的高效算法。我们将探讨哪些任务可以高效完成，哪些任务在一般情况下被认为是困难的，并理解这对于编码理论的实际应用意味着什么。

如果一个码是线性的，那么它天然支持一些高效的算法。这里，“高效”指的是算法运行时间是码长 n 的多项式级别。

具体来说，假设 C ⊆ F_q^n 是一个距离为 d 的线性码，那么以下三件事是成立的。

以下是线性码可以高效完成的三个任务：

存在高效的编码映射 Enc，它将消息 F_q^k 映射到码字 C 中。这个映射就是乘以一个生成矩阵 G：
Enc(x) = G * x
由于矩阵乘法可以在多项式时间内完成，因此这是一个高效算法。
可以高效地检测最多 d-1 个错误。给定一个可能被少于 d 个错误污染的接收向量 c̃，存在算法能判断是否出错。一种方法是使用校验矩阵 H：
计算 H * c̃，如果结果等于 0，则 c̃ 是一个合法的码字；否则，说明发生了错误。这同样是一个高效的矩阵乘法。
可以高效地纠正最多 d-1 个删除。假设我们收到一个码字，其中部分坐标被删除（即未知）。原始的码字可以表示为 c = G * x。删除某些坐标相当于从矩阵 G 中移除对应的行，得到一个新矩阵 G̃。由于码的距离为 d，对于最多 d-1 个删除，存在唯一的 x 满足 c̃ = G̃ * x。因此，算法就是求解这个线性方程组，例如使用高斯消元法，这可以在有限域上高效完成。

上一节我们介绍了线性码可以高效完成的三个任务：编码、错误检测和删除纠正。然而，还有一个非常重要的任务我们尚未讨论：错误纠正。

这里的问题是：对于一个任意的、距离为 d 的线性码 C，是否存在一个高效算法，能够纠正最多 ⌊(d-1)/2⌋ 个错误？

对于某些特定的码（例如汉明码），答案可能是肯定的。但这个问题问的是：对于任意的线性码 C，我都能做到这一点吗？

坏消息是，答案很可能是否定的。

更详细地说，考虑以下问题：给定一个接收向量 c̃ ∈ F_q^n 和一个生成矩阵 G ∈ F_q^(n×k)，找到一个消息 x ∈ F_q^k，使得 c̃ 与码字 G * x 之间的汉明距离最小。

这个问题被称为最大似然译码问题。解决这个问题，基本上就等同于能够高效纠正最多 ⌊(d-1)/2⌋ 个错误。

不幸的是，这个问题是 NP 难的。这意味着，我们不太可能找到一个多项式时间算法来解决任意（最坏情况）线性码 C 的这个问题。事实上，即使允许对码进行任意预处理，该问题仍然是 NP 难的。甚至仅计算给定生成矩阵的线性码的距离，本身也是 NP 难的。

因此，我们的结论是：我们不太可能为任意线性码找到解决此任务的多项式时间算法。

然而，也有好消息。

首先，我们并不关心任意的线性码。我们关心的是我们可以设计的线性码。在后续课程中，我们将重点研究如何设计具有特殊结构的、确实支持快速译码算法的线性码。

其次，这个问题被认为是困难的，有时反而带来了便利。在下一个视频中，我们将看到密码学中的一个应用，正是依赖于这个事实。

本节课中我们一起学*了线性码的高效算法。我们了解到，对于任意线性码，编码、错误检测和删除纠正都可以高效完成。然而，一般的错误纠正（最大似然译码）问题被认为是计算困难的（NP难）。这一事实既指明了通用译码算法的局限性，也为我们设计具有快速算法的特殊结构码提供了动力，同时还在密码学等领域找到了意想不到的应用。

010：McEliece密码系统 🔐

在本节课中，我们将学*线性码在密码学中的一个应用：McEliece密码系统。这是一种公钥密码系统，其安全性基于某些计算问题的困难性。

公钥密码学基础

上一节我们介绍了线性码的基本概念，本节中我们来看看如何利用它来构建一个密码系统。首先，我们需要理解公钥密码学的基本框架。

在公钥密码学中，通信双方（例如发送者Alice和接收者Bob）拥有一个完全清晰的通信信道。但问题是，存在一个窃听者Eve，她试图窃听他们的通信。

以下是公钥密码学的基本设置：

首先，每个参与者都拥有一对密钥：一个公钥和一个私钥。
公钥是公开的，任何人都可以获取。私钥则是秘密的，只有拥有者自己知道。
当Alice想给Bob发送加密消息时，她使用Bob的公钥对消息进行加密。
当Bob收到加密消息后，他使用自己的私钥进行解密。
窃听者Eve虽然能看到加密后的消息，但由于她没有Bob的私钥，因此（我们希望）她无法解密出原始消息。

McEliece密码系统的构建

了解了基本框架后，我们来看Bob如何生成他的公钥和私钥。以下是Bob生成密钥的步骤：

Bob选择一个在有限域 F₂ 上的 n × k 生成矩阵 G。这个矩阵对应一个能高效解码（纠正最多 t 个错误）的线性码。在实际应用中，G 通常选择为二进制Goppa码的生成矩阵。
Bob选择一个随机的 k × k 可逆矩阵 S。
Bob选择一个随机的 n × n 置换矩阵 P。这个矩阵的作用是打乱向量坐标的顺序。

Bob的私钥就是这三个组成部分：(S, G, P)。

Bob的公钥则是这三个矩阵的乘积：Ĝ = P × G × S。Bob同时会将纠错能力参数 t 也放入公钥中公布。

加密与解密过程

现在，我们来看看Alice如何利用Bob的公钥发送消息，以及Bob如何用私钥解密。

加密过程

当Alice想发送消息 x（一个 k 比特的向量）给Bob时，她执行以下操作：

Alice随机选择一个重量为 t 的 n 比特错误向量 e。
Alice计算密文 c = Ĝ × x + e，并将其发送给Bob。

解密过程

Bob收到密文 c 后，利用他的私钥进行解密：

Bob计算 P⁻¹ × c。由于 Ĝ = P × G × S，这等于 G × S × x + P⁻¹ × e。
令 e‘ = P⁻¹ × e，由于 P 是置换矩阵，e‘ 的重量仍为 t。因此上式可写为 G × (S × x) + e‘。
此时，G × (S × x) 是一个码字，但被最多 t 个错误 e‘ 污染。因为 G 对应的码能高效纠正最多 t 个错误，Bob可以对其进行解码，恢复出 S × x。
最后，Bob用他私钥中的可逆矩阵 S 的逆，计算 S⁻¹ × (S × x) = x，从而获得原始消息。

系统安全性分析

那么，窃听者Eve面临什么情况呢？Eve可以看到Bob的公钥 Ĝ 和Alice发送的密文 c = Ĝ × x + e。我们希望她无法从中恢复出消息 x。

系统的安全性基于以下两个希望：

公钥看起来是随机的：虽然生成矩阵 G 本身具有特殊的代数结构以支持高效解码，但经过随机可逆矩阵 S 和置换矩阵 P 的“扰乱”后，得到的公钥 Ĝ 在计算上应与一个随机的生成矩阵难以区分。
解码随机线性码是困难的：我们在之前的课程中看到，解码一个最坏情况下的线性码是NP难问题。因此，我们有理由希望解码一个“看起来随机”的线性码在计算上也是困难的。

如果以上两点成立，那么对于只拥有多项式时间计算能力的Eve来说，从 Ĝ 和 c 中恢复 x 将是极其困难的。

需要指出的是，这些是安全假设，我们目前尚无法证明其绝对成立。在密码学中，基于某些计算问题的困难性来构建系统是常见做法（例如RSA算法基于大数分解的困难性）。对于McEliece系统，当 G 是二进制Goppa码的生成矩阵时，这个假设被称为 McEliece假设。

现实意义与总结

本节课中我们一起学*了McEliece密码系统。这是一个利用具有高效解码算法的特殊线性码来构建公钥加密方案的经典例子。

其现实意义在于，McEliece密码系统被认为是能够抵抗未来量子计算机攻击的候选算法之一。例如，截至2021年，美国国家标准与技术研究院（NIST）推动的后量子密码学标准化进程中，就有一类决赛方案是基于McEliece密码系统的变体。

总结来说，McEliece系统展示了编码理论不仅可用于可靠通信（纠错），还能应用于信息安全（加密），是连接这两个重要领域的一个优美范例。

011：渐*分析

在本视频中，我们将探讨当码长 N 变得非常大时会发生什么。

概述

在本节中，我们将学*如何分析编码参数在趋于无穷大时的行为，即渐*分析。我们将定义码族的概念，并引入渐*好码的定义，为后续理解码的极限性能打下基础。

动机与回顾

为了引出我们将要研究的渐*分析，让我们先回顾一下目前已经了解的几个概念。

首先，我们已经见过几个界。我们见过吉尔伯特-瓦尔沙莫夫界和汉明界。这些界表明，对于一个具有距离 D 和字母表大小 Q 的码，其最优码率 K/N 被一些复杂的公式所界定。

在了解了这些界之后，一个很自然的问题是：这些界是好是坏？也就是说，这些复杂的公式表现如何？它们是很大、很小，还是别的什么？

其次，我们讨论过所谓的“效率”。我们看到，对于线性码存在一些高效的算法，例如编码、从擦除中译码或检错。同时，我们也看到对于所有线性码或随机线性码，不太可能存在高效的算法。也就是说，我们看到最大似然译码是 NP 难的。我们还介绍了梅勒斯密码系统，它假设译码随机线性码在计算上是困难的。

在讨论这些时，你可能思考过一个问题：我们这里说的“高效”是什么意思？我们说过，高效意味着关于 N 是多项式时间的。但如果你熟悉渐*记法，你可能会记得，要让这类说法有意义，必须有某个量趋于无穷大。在我们之前的讨论中，所有参数都是固定的。那么，对于一个常数，我们说的“高效”是什么意思呢？因此，必须有某个量变得非常大。这个量是什么？

为了回答这些问题，我们将形式化一些渐*分析。我们应该把哪些参数看作大的？哪些参数是小的？参数之间如何关联？

渐*参数体系

在本课程的大部分时间里，我们将研究以下参数体系。

我们将假设参数 N、K 和 D（即码长、消息长度和距离）都趋于无穷大。我们通常进一步假设，它们以这样的方式趋于无穷大：比值 K/N（即码率）趋于某个常数 R，而比值 D/N（即码的相对距离）趋于某个常数 δ。

我们采用这个假设有几个原因。首先，正如上一张幻灯片所说，这将使我们更容易理解什么是可能的，什么是不可能的。例如，我们可以只关注 R 与 δ 的关系，而忽略 N、K 和 D，只要它们都足够大。其次，它使我们能够有意义地讨论计算复杂度。当然，第三，这个参数体系与许多实际应用是相关的。

码族的定义

基于以上考虑，我们给出一个定义。

一个码族 C 是一个码的集合 {C₁, C₂, C₃, ...}，其中每个 Cᵢ 是一个 (Nᵢ, Kᵢ, Dᵢ) 子 Qᵢ 码。记住，这意味着它的码长为 Nᵢ，维数为 Kᵢ，距离为 Dᵢ，字母表大小为 Qᵢ。

给定这样一个族，我们定义该码族的码率 R(C) 为第 i 个码的码率的极限（假设该极限存在）：

R(C) = lim_{i→∞} (Kᵢ / Nᵢ)

类似地，我们定义码族 C 的相对距离 δ(C) 为各个码的相对距离的极限：

δ(C) = lim_{i→∞} (Dᵢ / Nᵢ)

关于这个定义有几点说明。

首先，我经常会简称码族 C 为一个“码”。我会省略下标 i。也就是说，我将滥用符号，只考虑一个单一的码 C，但它的参数 N、K 和 D 都以某种方式趋于无穷大。这在技术上并不完全正确，但可以为我们省去很多下标，希望不会造成太多混淆。

第二点说明是，码族 C 的字母表大小可能不是常数。它可能取决于我们看的是族中的哪个码。在这种情况下，当我像这样滥用符号时，我可能会说这个码 C 的字母表大小是码长 N 的函数，或类似的说法。

一个熟悉的例子：汉明码族

这是一个熟悉的码族例子。

令 Nᵢ = 2ⁱ - 1。那么长度为 Nᵢ 的汉明码 Cᵢ 是以下奇偶校验矩阵定义的码：

Hᵢ = [所有 F₂ⁱ 中的非零元素作为列向量]

这是一个 i × (2ⁱ - 1) 的矩阵，其列是 F₂ⁱ 中所有非零元素。注意，这样的元素有 2ⁱ - 1 个，所以我们把它们作为列堆叠在这里。

我们之前在这些视频中已经见过 Nᵢ = 7 的汉明码。你可能在作业中更一般地探索过这个族。再次说明，这是一个有趣的练*（你可能在作业中已经做过），可以证明第 i 个汉明码 Cᵢ 是一个 (2ⁱ - 1, 2ⁱ - i - 1, 3) 子 2 码。也就是说，它的码长为 2ⁱ - 1，维数为 2ⁱ - i - 1，距离为 3。

这意味着 C（所有这些 Cᵢ 的集合）根据之前的定义，是一个码族。

这个码族的码率是第 i 个码的码率的极限：

R(C) = lim_{i→∞} ( (2ⁱ - i - 1) / (2ⁱ - 1) )

当 i 趋于无穷大时，它趋*于 1。这非常棒，1 是非常高的码率。

另一方面，该码族的相对距离 δ(C) 是第 i 个码的相对距离的极限：

δ(C) = lim_{i→∞} ( 3 / (2ⁱ - 1) )

这个值非常快地趋*于 0。所以，这就不太好了。

核心问题：码率与距离的权衡

你可能还记得，之前我们问过一个问题：码率和距离之间最好的权衡是什么？之前这个问题有些复杂，因为我们还有参数 N、K 和 D 需要考虑。但现在，对于任何一个码族，我们可以直接问：这个码族的码率和距离之间最好的权衡是什么？这仅仅是两个数字。

正如我们在这个例子中看到的，基本上，我们目前已知的唯一码族（汉明码族）在码率和距离之间并没有取得很好的权衡。更确切地说，它有非凡的码率，但距离非常差。

因此，我们可能提出的第一个问题是：是否存在码率和相对距离都严格大于 0 的码族？

渐*好码的定义

这里有一个快速的定义。

如果一个码族的码率和相对距离都严格大于 0，则称该码族为渐*好码。

也就是说，我们称一个码族是渐*好码，当且仅当：

R(C) > 0 且 δ(C) > 0

那么，是否存在渐*好码呢？我们将在下一个视频中解答这个问题。

总结

在本节中，我们一起学*了渐*分析的基本框架。我们定义了码族的概念，并引入了码率和相对距离的渐*定义。通过汉明码族的例子，我们看到了高码率与低相对距离的权衡。最后，我们提出了是否存在码率和距离都非零的“渐*好码”这一核心问题，为后续内容做好了铺垫。

012：q元熵

在本节课中，我们将学*如何利用q元熵函数来简化汉明界和吉尔伯特-瓦尔沙莫夫界的渐*表达式。我们将定义q元熵函数，理解其基本性质，并最终用它来描绘码率与相对距离之间的渐*关系图。

上一节我们介绍了渐*参数体系。本节中，我们来看看如何利用q元熵来简化汉明界和吉尔伯特-瓦尔沙莫夫界的表达式。

q元熵函数是二进制熵函数的推广。其定义如下：

定义：对于整数 ( q \geq 2 )，q元熵函数 ( H_q ) 将单位区间 ([0, 1]) 映射到 ([0, 1])，其公式为：
[
H_q(x) = x \log_q (q-1) - x \log_q x - (1-x) \log_q (1-x)
]
其中 ( x \in [0, 1] )。

我们关心这个函数，是因为它能帮助我们简化涉及汉明球体积的复杂表达式。具体来说，有以下命题：

命题：设整数 ( q \geq 2 )，并设 ( p ) 是介于 ( 0 ) 和 ( 1 - 1/q ) 之间的一个数。那么以下两点成立：

( q ) 元汉明球 ( B_q(pn, n) ) 的体积上界为 ( q^{n H_q(p)} )。
该汉明球的体积下界为 ( q^{n (H_q(p) - o(1))} )，其中 ( o(1) ) 表示当 ( n \to \infty ) 时趋于0的项。

本质上，这个命题说明汉明球的体积*似等于 ( q^{n H_q(p)} )。这将允许我们用更简洁的表达式替换那些复杂的体积公式。

为了利用q元熵来简化界，我们首先需要理解这个函数的行为。

以下是q元熵函数在 ( q = 2, 3, 6 ) 时的示意图（手绘草图，非精确图像）：

二进制熵 (( q=2 ))：在 ( x=0 ) 和 ( x=1 ) 处为0，在 ( x=1/2 ) 处达到最大值1。
三元熵 (( q=3 ))：在 ( x=0 ) 处为0，最大值点右移至 ( x=2/3 )，最大值仍为1。
六元熵 (( q=6 ))：最大值点进一步右移至 ( x=5/6 )。

更一般地，( H_q(x) ) 在 ( x = 1 - 1/q ) 处取得最大值1，且随着 ( q ) 增大，曲线整体向右移动。

为了获得更定量的理解，我们考察两个参数体系下的行为：

当 ( q ) 非常大时：若 ( q \to \infty )，而 ( p ) 是 (0,1) 区间内的一个常数，则 ( H_q(p) \approx p )。此时函数图像*似为一条直线 ( H_q(p) = p )，仅在末端略有不同。
当 ( q ) 为常数且 ( p ) 非常小时：此时 ( H_q(p) ) 的行为主要由中间项主导，即 ( H_q(p) \approx p \log_q (1/p) )。

通过对各项进行类似的分析或使用泰勒展开，我们可以理解其他参数体系下q元熵的行为。

现在我们已经对q元熵有了一定的了解，接下来让我们用它来简化GV界和汉明界的表达式。

回顾一下，GV界和汉明界都涉及半径为 ( \delta n ) 的q元汉明球的体积。我们的策略是利用*似关系：
[
\text{Vol}(B_q(\delta n, n)) \approx q^{n H_q(\delta)}
]
两边取以 ( q ) 为底的对数，得到：
[
\log_q (\text{Vol}) \approx H_q(\delta) \cdot n
]
这个表达式简洁得多。

将这个*似代入之前得到的非渐*形式的界中，我们可以得到它们的渐*形式：

渐*汉明界：对于任何q元码族 ( C )，其码率 ( R(C) ) 满足：
[
R(C) \leq 1 - H_q(\delta(C)/2)
]
其中 ( \delta(C) ) 是相对距离。
渐*吉尔伯特-瓦尔沙莫夫界：设 ( q \geq 2 )，对于任意 ( \delta \in (0, 1-1/q) ) 和任意 ( \epsilon \in (0, 1 - H_q(\delta)) )，都存在一个q元码族 ( C )，其相对距离至少为 ( \delta )，码率至少为 ( 1 - H_q(\delta) - \epsilon )。这里的 ( \epsilon ) 是一个微调因子，它会影响码所需的最小码长。

使用这些渐*表达式的好处是，我们现在只需关注两个参数：码率 ( R ) 和相对距离 ( \delta )。因此，我们可以将它们绘制在一张图上。

在横轴为 ( \delta )、纵轴为 ( R ) 的坐标系中：

汉明界（红色曲线）给出了不可能达到的 ( (R, \delta) ) 区域（曲线上方）。
吉尔伯特-瓦尔沙莫夫界（蓝色曲线）给出了已知存在码能达到的 ( (R, \delta) ) 区域（曲线下方）。
两条曲线之间是一个巨大的不确定区域。

这张图引出了几个重要问题：

以下是关于这些界限和构造的几个关键问题：

是否存在超越GV界的码族？ 答案是“是”也是“否”。对于字母表大小 ( q \geq 49 \，已知代数几何码可以超越GV界。然而，对于二进制码 (( q=2 ))，这仍然是一个悬而未决的问题。
能否给出达到或接*GV界的显式构造？ 答案同样是“是”也是“否”。对于大的 ( q )，答案是肯定的，我们将在后续视频中看到这样的构造。但对于二进制码，除了在特定参数区间（如低码率区）有一些突破性进展外，这仍然是一个极具挑战性的开放性问题。
是否存在渐*好码？ 答案是肯定的。GV界本身就已经证明了渐*好码的存在性，例如图中蓝色曲线下方许多点的参数组合都对应着渐*好码。

本节课中，我们一起学*了q元熵函数的定义和基本性质，并利用它将汉明界和吉尔伯特-瓦尔沙莫夫界简化成了更易于处理的渐*形式。通过绘制码率-相对距离图，我们清晰地看到了已知可能区域、不可能区域以及广阔的未知区域。虽然许多关于构造最优码的根本性问题仍未完全解决，但我们已经取得了重要的进展，并确认了渐*好码的存在性。在接下来的视频中，我们将看到更多的界限和构造，以帮助缩小这片不确定的黄色区域。

013：Singleton界

在本节课中，我们将学*并证明一个关于码率与距离之间可实现性权衡的另一个不可能性结果，称为Singleton界。

概述 📋

Singleton界阐述了以下内容：如果一个码 C 是一个参数为 (N, K, D) 的 q 元码，即其码长为 N，消息长度为 K，最小距离为 D，字母表大小为 q，那么 K 至多为 N - D + 1。

在证明这个界之前，我们先直观感受一下它的含义。

Singleton界的直观理解 📈

当 q = 2（二元码）时，图像大致如下。请注意，这张图的 X 轴是相对距离 Δ，Y 轴是码率 R。我们关心的是哪些 (Δ, R) 对是可实现的，即存在一系列码能达到这些参数。

在之前的课程中，我们学*了汉明界。汉明界指出，此区域之外的任何权衡都是不可实现的。

那么Singleton界说了什么呢？如果我们画出它，它看起来是这样的。它指出，此区域之外的任何权衡也是不可实现的。但我们从汉明界已经知道了这一点。因此，对于 q = 2，Singleton界并没有告诉我们任何新信息。它严格弱于汉明界，尽管它更简洁一些。

然而，当字母表大小 q 增大时，Singleton界可能变得比汉明界更强。

一般来说，图像更接*这样。随着 q 变大，汉明界开始呈现这样的形状，而Singleton界则保持不变。具体来说，在这个区域里，在本视频开始之前，我们可能认为获得此区域内的权衡是可能的。但现在我们知道事实并非如此。Singleton界排除了这种可能性。因此，对于较大的 q，Singleton界确实在汉明界之外告诉了我们一些新信息。

Singleton界的证明 🔍

让我们来证明Singleton界。为了方便查看，我把它复制到这里。

定理（Singleton界）：若 C 是一个 (N, K, D) 的 q 元码，则 K ≤ N - D + 1。

首先，考虑我们 (N, K, D) 码中的一个码字 c。假设它看起来像这样：

即 c 是一个长度为 N 的向量，我刚刚写出了它的各个坐标。

接下来，我们将丢弃最后 D - 1 个坐标。让我们把剩余的部分称为 φ(c)。也就是说，我们丢弃这 D - 1 个坐标，而把前面的部分称为 φ(c)。

现在，考虑我们通过保留原码 C 中每个码字的前面部分而得到的新码 C̃。即 C̃ = { φ(c) | c ∈ C }。因此，C̃ 存在于集合 Σ^(N - D + 1) 中，其中 Σ 是原码 C 的字母表。

我将提出两个主张。

以下是第一个主张：

主张 1：|C| = |C̃|。

为什么是这样？如果不是这样，那么在我们创建 C̃ 时必定发生了碰撞。必定存在两个不同的码字 c 和 c‘，使得 φ(c) = φ(c‘)。但这样一来，我断言 c 和 c‘ 之间的距离至多为 D - 1。这是因为如果 φ(c) = φ(c‘)，意味着它们的前面部分相同，所以它们只能在最后这部分坐标上不同，而这里最多只有 D - 1 个坐标。但原码的最小距离是 D，这将导致矛盾。因此，主张 1 成立。

以下是第二个主张：

主张 2：|C̃| ≤ q^(N - D + 1)。

这是成立的，因为 C̃ 是 Σ^(N - D + 1) 的一个子集。特别地，C̃ 的大小不可能大于该集合的大小，即 q^(N - D + 1)。

综合起来，这两个主张意味着 |C| = |C̃| ≤ q^(N - D + 1)。如果我们对两边取以 q 为底的对数，可以看到消息长度 K（根据定义，K = log_q(|C|)）至多为 N - D + 1。这正是我们要证明的。因此，Singleton界得证。

总结 ✨

本节课中，我们一起学*了Singleton界。我们了解到，对于任何 (N, K, D) 的 q 元码，其消息长度 K 受到 K ≤ N - D + 1 的限制。我们通过构造一个“截断”码并分析其大小的方式证明了这一点。对于小字母表（如二元码），这个界弱于汉明界；但对于大字母表，它能提供更强的限制，帮助我们排除一些理论上不可行的码率与距离组合。

代数编码理论导论：2：普洛特金界

在本节课中，我们将学*另一个不可能性结果，即普洛特金界。我们将了解它如何进一步限制码的码率与相对距离之间的权衡关系，并证明其一个有用的推论。

上一节我们介绍了汉明界和辛格尔顿界，它们都是不可能性结果，限定了码率与距离之间可实现的权衡范围。我们还介绍了吉尔伯特-瓦尔沙莫夫界，它是一个可能性结果。这留下了一个问题：在汉明界/辛格尔顿界与吉尔伯特-瓦尔沙莫夫界之间的区域，权衡关系是否可能实现？特别是对于二进制码，是否可能拥有大于1/2的相对距离和大于0的码率？

普洛特金界告诉我们，答案是否定的。

普洛特金界定理

设 C 是一个参数为 [n, k, d]_q 的码。那么以下两点成立：

如果码的距离 d = (1 - 1/q) * n，则码的大小 |C| ≤ 2qn。
如果码的距离 d > (1 - 1/q) * n，则码的大小 |C| ≤ d / (d - (1 - 1/q)n)。

这个定理的核心结论是：如果相对距离 δ = d/n ≥ 1 - 1/q，那么当码长 n 趋于无穷大时，码率 R 必然趋于0。这意味着，在相对距离很大的区域，无法维持非零的码率。

一个重要推论

虽然我们不在此视频中证明普洛特金界定理本身，但我们将基于该定理证明以下有用的推论。这个推论将普洛特金界的结论扩展到了 δ < 1 - 1/q 的区域。

推论：设 {C} 是一族渐*码率为 R、相对距离为 δ 的码，且 δ < 1 - 1/q。那么，码率 R 满足以下上界：
R ≤ 1 - (q/(q-1)) * δ

以下是推论的证明过程。

首先，我们选择一个参数 n'：
n' = ⌊ (q*d) / (q-1) ⌋ - 1
这个选择确保了 d > (1 - 1/q) * n'。

接着，对于所有 x ∈ Σ^(n-n')，我们定义一个新码 C_x：
C_x = { (c_{n-n'+1}, ..., c_n) | c ∈ C 且 (c_1, ..., c_{n-n'}) = x }
也就是说，C_x 是原码 C 中所有以 x 开头的码字的后 n' 个符号组成的集合。

断言1：C_x 的距离至少为 d。
证明：考虑 C_x 中的任意两个不同码字，它们对应于原码 C 中两个以相同前缀 x 开头的不同码字。由于原码的距离为 d，这两个码字至少相差 d 个位置。因为它们的前缀 x 完全相同，所以这些差异全部出现在后 n' 个位置上。因此，它们在 C_x 中的对应向量的距离也至少为 d。

断言2：C_x 的码长 n' ≤ d / (1 - 1/q)。
这由 n' 的定义直接可得。

现在，对码 C_x 应用普洛特金界定理的第二部分。因为 d > (1 - 1/q) * n'，所以有：
|C_x| ≤ d / (d - (1 - 1/q)n')
对分子分母同时乘以 q，得到：
|C_x| ≤ (qd) / (qd - (q-1)n')
由于分母是正整数，它至少为1，因此：
|C_x| ≤ q*d

接下来，我们观察原码 C 的大小。每个码字 c ∈ C 都唯一地属于一个以其前 n-n' 位 x 标识的集合 C_x。因此：
|C| = Σ_{x ∈ Σ^(n-n')} |C_x|
将 |C_x| 的上界代入：
|C| ≤ Σ_{x ∈ Σ^(n-n')} (qd) = q^(n-n') * (qd)
代入 n' 的定义（忽略取整和减1带来的低阶影响）：
|C| ≤ q^n * q^{ - (q/(q-1))δ * n + o(n) } * (q*d)
这里 o(n) 表示相对于 n 的低阶项。两边取以 q 为底的对数并除以 n 得到码率 R：
R = (log_q |C|) / n ≤ 1 - (q/(q-1))δ + o(1)
其中 o(1) 是随着 n 增大而趋于0的项。这就完成了推论的证明。

权衡关系全景图

现在，让我们总结一下目前所知的关于码率与相对距离最佳权衡的知识。

对于二进制码 (q=2)，权衡图如下所示：

辛格尔顿界 是一条直线：R ≤ 1 - δ。
汉明界 在中小 δ 区域给出了更紧的约束。
普洛特金界 在 δ > 1/2 的区域成为主导约束，它表明当 δ ≥ 1/2 时，R 必须趋于0。其推论在 δ < 1/2 时是一条斜率更陡的直线：R ≤ 1 - 2δ。
吉尔伯特-瓦尔沙莫夫界 则给出了可达到的下界。

对于更大的字母表 (q > 2)，图形类似，但关键点发生变化：

辛格尔顿界 不变。
普洛特金界 的“拐点”移动到 δ = 1 - 1/q 处，这也是GV界的终点。
普洛特金界推论 的直线变为：R ≤ 1 - (q/(q-1))δ。

你可能会问，既然普洛特金界似乎总是优于辛格尔顿界，为什么我们还需要辛格尔顿界？一方面，在渐*意义上这确实成立。另一方面，在后续课程中，我们将看到一类能够达到辛格尔顿界的码族（MDS码）。在学*了普洛特金界之后，你可以思考一下这是如何成为可能的。

本节课中，我们一起学*了普洛特金界及其推论。普洛特金界揭示了在相对距离较大时，无法维持非零码率，从而填补了之前认知中的一个重要空白。结合辛格尔顿界、汉明界和吉尔伯特-瓦尔沙莫夫界，我们现在对码的率-距权衡有了更全面的理解。

015：有限域上的多项式

在本节课中，我们将学*有限域上的多项式。这是理解后续课程中将要介绍的里德-所罗门码的基础。里德-所罗门码是一类达到单例界、拥有快速算法且非常实用和强大的编码。

多项式的定义

我们可以像在实数域上一样定义有限域上的多项式。

具体来说，在有限域 F_q 上，一个关于变量 X 的 d 次一元多项式具有以下形式：

f(X) = a₀ + a₁X + a₂X² + ... + a_dX^d

其中，所有系数 a_i 都来自域 F_q，并且最高次项系数 a_d 不为零。所有在变量 X 上的一元多项式集合记为 F_q[X]。

多项式的根

关于实数域或有限域上的多项式，一个非常有用的性质是：低次多项式不会有太多根。

更精确地说，一个非零的、次数至多为 d 的多项式 f，其根的数量至多为 d 个。这里，多项式的根是指满足 f(x) = 0 的值 x ∈ F_q。

这个性质极其有用，我们将在整个课程中反复使用它。为了强调这一点，我们引入一个新角色：多项式插值鹦鹉波莉，来提醒我们“低次多项式没有太多根”。

性质证明

为什么这个性质成立？如果你相信多项式在 F_q 上的运算与预期大致相同，这里有一个简要的证明。

证明：假设对于某个特定的 α ∈ F_q，有 f(α) = 0。那么，一次多项式 (X - α) 可以整除 f(X)。

这意味着，如果 f(X) 有 d+1 个根，比如 α₁, ..., α_d+1，那么乘积 ∏ (X - α_i) 将整除 f(X)。然而，这个乘积是一个 d+1 次多项式，这意味着 f(X) 的次数至少为 d+1。这与 f(X) 次数至多为 d 的假设矛盾。

因此，一个次数至多为 d 的非零多项式，其根的数量至多为 d 个。

示例分析

为了确保我们理解“低次多项式没有太多根”这个极其有用的性质，让我们看几个在 F₃ 上的简单例子。

以下是几个多项式及其在 F₃ 上的根的数量：

f(X) = X² - 1 有两个根：1 和 2。
f(X) = X² + 2X + 1 有一个根：2。
f(X) = X² + 1 在 F₃ 上没有根。

这些例子表明，虽然二次多项式最多有两个根，但可能少于两个。同时，最后一个多项式 X² + 1 在 F₂ 上确实有一个根（1），这说明多项式的根的数量也取决于所选的域。

范德蒙德矩阵

在讨论有限域上的多项式、多项式求值和多项式插值时，一个有用的概念是范德蒙德矩阵。

定义：一个范德蒙德矩阵具有以下形式。我们选择某个域 F 中 n 个不同的值 α₁, ..., α_n，然后令矩阵 V 的第 (i, j) 项为 α_i^j。其形式如下：

V = [ [1, α₁, α₁², ..., α₁^m], [1, α₂, α₂², ..., α₂^m], ..., [1, α_n, α_n², ..., α_n^m] ]

第一列全是1（即 α_i⁰），第二列是所有的 α_i，第三列是所有的 α_i²，依此类推，直到某个整数 m 次幂。

一个有用的性质是：方阵范德蒙德矩阵是可逆的。

证明概要：设 V 是一个方阵范德蒙德矩阵。要证明 V 可逆，等价于证明其核空间仅为 {0}。假设存在向量 a 使得 V * a = 0。将 a 视为多项式 f(X) = Σ a_iXⁱ 的系数向量，那么 V * a 的结果向量就是 f(α₁), f(α₂), ..., f(α_n)。

现在有两种情况：

f(X) 是零多项式，这意味着 a = 0。
f(X) 是一个非零的低次多项式。根据“低次多项式没有太多根”的性质，f(X) 的根数严格小于 n。这意味着 V * a 的结果向量不可能是零向量，因为它包含了 n 个求值结果，其中严格少于 n 个会是零。

因此，要么 a = 0，要么 V * a ≠ 0。这证明了 V 的核空间仅为 {0}，所以 V 是可逆的。

推论：范德蒙德矩阵的任何方阵子矩阵也是可逆的。证明思路是，这样的子矩阵可以表示为一个可逆的对角矩阵与一个（较小的）范德蒙德方阵的乘积，因此其本身也是可逆的。

多项式插值

关于范德蒙德矩阵的这些事实引出了一个非常有用的结论：多项式插值在 F_q 上是“可行”的。

定理：假设给定 d+1 个点对 (α_i, y_i)，其中 i = 0, ..., d。那么，存在一个唯一的、次数至多为 d 的多项式 f，使得对于所有 i，都有 f(α_i) = y_i。

证明：将多项式 f 写作 f(X) = Σ_i=0^d a_iXⁱ。条件 f(α_i) = y_i 等价于以下线性系统成立：

V * a = y

其中，V 是以 α₀, ..., α_d 为参数构成的 (d+1) x (d+1) 范德蒙德矩阵，a 是系数向量，y 是值向量。

由于方阵范德蒙德矩阵 V 可逆，这个线性方程有唯一解：

a = V^-1 * y

因此，插值这些点的唯一多项式 f 的系数由 V^-1 * y 给出。这个证明不仅说明了唯一性，还表明我们可以通过求解线性系统来高效地找到这个多项式。实际上，存在类似快速傅里叶变换的算法，可以在 O(d log d) 时间内完成这个计算。

有限域上的函数与多项式

我们如此关心有限域上的多项式的另一个原因是以下事实：从有限域 F_q 到其自身的每一个函数，都可以由某个次数至多为 q-1 的多项式给出。

证明：设 F 是任意一个从 F_q 到 F_q 的函数。考虑那个唯一存在的、次数至多为 q-1 的、插值所有 F_q 中点 (x, F(x)) 的多项式（根据上一节的定理，它存在）。这个多项式在域上的每一个点都与函数 F 的值一致，因此它就是我们要找的多项式。

一个快速示例：考虑多项式 f(X) = X^q。根据上述事实，它必须有一个次数至多为 q-1 的表示形式。实际上，这个表示就是 f(X) = X。原因在于有限域的一个有用性质：对于所有 α ∈ F_q，都有 α^q = α。因此，多项式 X^q 和 X 在所有点上的求值结果都相同。

总结

本节课中，我们一起学*了有限域上多项式的核心知识：

我们定义了有限域上的多项式。
我们学*了“低次多项式没有太多根”的关键性质及其证明思路。
我们介绍了范德蒙德矩阵，并证明了方阵范德蒙德矩阵的可逆性。
基于此，我们证明了多项式插值在有限域上的可行性和唯一性。
最后，我们了解到有限域上的任何函数都可以用一个次数至多为 q-1 的多项式来表示。

掌握了这些关于多项式的知识后，我们现在已经为定义和理解强大的里德-所罗门码做好了充分准备，这将是下一节课的内容。

代数编码导论：4：Reed-Solomon 码！📡

在本节课中，我们将要学* Reed-Solomon 码。这是一种重要的纠错码家族，以其能够达到 Singleton 界而闻名，并拥有高效的编码和译码算法，因此在实践中被广泛应用。

基本思想 🧠

Reed-Solomon 码背后的核心思想，正如我们之前所见，是低次多项式没有太多根。这意味着，当我们用低次多项式在多个点上求值来构造码字时，这些码字不会出现太多零值，从而保证了码具有良好的距离。

定义 📖

让我们正式定义 Reed-Solomon 码。

设 Q >= n >= K。我们在有限域 F_Q 中选择 n 个互不相同的点 α_1, α_2, ..., α_n。

那么，在 F_Q 上、以这些点为求值点、维数为 K 的 Reed-Solomon 码定义如下：

RS_Q(α, N, K) = { (f(α_1), f(α_2), ..., f(α_n)) | f ∈ F_Q[x], deg(f) ≤ K-1 }

当上下文明确时，我们也可以简写为 RS(N, K)。

这个定义隐含了一个自然的编码映射。它将一个消息向量 (a_0, a_1, ..., a_{K-1}) 映射为码字 (f_a(α_1), f_a(α_2), ..., f_a(α_n))，其中 f_a(x) = Σ_{i=0}^{K-1} a_i * x^i。

性质与证明 🔍

上一节我们介绍了 Reed-Solomon 码的定义，本节中我们来看看它的一些关键性质。

以下是 Reed-Solomon 码的两个重要性质：

线性性与生成矩阵：Reed-Solomon 码是线性码，其生成矩阵是一个 Vandermonde 矩阵。具体来说，对于求值点 α 和维数 K，生成矩阵 G 是一个 n × K 的矩阵，其第 i 行、第 j 列的元素为 α_i^{j-1}。将消息向量 a 乘以这个矩阵，就相当于在点 α_i 处求值多项式 f_a(x)。
距离：一个块长为 n、维数为 K 的 Reed-Solomon 码，其距离 d 恰好等于 n - K + 1。

距离性质的证明：
由于 Reed-Solomon 码是线性的，我们只需证明任何非零码字的最小重量至少为 n - K + 1。这等价于证明任何码字最多有 K-1 个零分量。而一个码字是某个次数不超过 K-1 的多项式 f(x) 在 n 个点上的求值结果。码字中零分量的数量，就是多项式 f(x) 在这些求值点中根的数量。根据代数基本定理，一个非零的、次数不超过 K-1 的多项式，在域中最多有 K-1 个根。因此，码字中零分量的数量最多为 K-1，这意味着最小重量至少为 n - (K-1) = n - K + 1。同时，我们可以构造一个恰好有 K-1 个根的多项式（例如 (x - α_1)...(x - α_{K-1})），使得对应的码字重量恰好为 n - K + 1。因此，距离 d 精确等于 n - K + 1。

达到 Singleton 界与 MDS 码 🏆

上一节我们证明了 Reed-Solomon 码的距离公式，本节我们将其与之前学过的界联系起来。

Singleton 界指出，对于任何参数为 (n, K, d)_Q 的码，都有 d ≤ n - K + 1。

由于 Reed-Solomon 码的距离 d 精确等于 n - K + 1，因此它恰好达到了 Singleton 界。任何达到 Singleton 界的码都被称为最大距离可分码。

以下是关于 MDS 码的两个有用观察：

生成矩阵的性质：一个线性码是 MDS 码，当且仅当其 K × n 生成矩阵的任意 K × K 子矩阵都是满秩的。直观理解是，这保证了即使码字中发生 n-K 个删除（只剩下 K 个符号），我们仍然可以通过解这 K 个线性方程来唯一恢复原始消息。Reed-Solomon 码的 Vandermonde 生成矩阵正好满足这个性质。
信息位置：对于一个 (n, K, d)_Q 的 MDS 码，码字的任意 K 个位置就足以确定整个码字。这同样是其强大纠删能力的另一种表述。

在界图中的位置与字母表大小 📊

现在，让我们将 MDS 码放到我们之前学过的码率-距离权衡界图中进行观察。

我们之前学过 Singleton 界和 Plotkin 界，它们都是不可能性结果，指出在界线上方的参数组合是无法实现的。Plotkin 界比 Singleton 界更强，它表明对于固定的字母表大小 Q，Singleton 界实际上是无法达到的。

然而，我们刚刚说 Reed-Solomon 码是达到 Singleton 界的 MDS 码。这似乎产生了矛盾。

秘密在于：Plotkin 界适用于固定的 Q。而对于 Reed-Solomon 码，其字母表大小 Q 并不是固定的，它必须随着块长 n 的增长而增长（因为我们需要在域中找到 n 个互不相同的点）。这是 Reed-Solomon 码的一个缺点。在后续课程中，我们将看到一些试图减小字母表大小的方法。

作为一个旁注，Plotkin 界意味着，任何 MDS 码族都必须具有随块长增长的字母表大小。那么它需要以多快的速度增长呢？这实际上是一个开放问题，有一个称为 MDS 猜想 的假设，认为 Reed-Solomon 码基本上具有最优的字母表大小，但该猜想尚未被证明。

总结 📝

本节课中我们一起学*了 Reed-Solomon 码。我们首先了解了其基于“低次多项式根不多”的核心思想。然后，我们给出了其正式定义，并证明了它是线性码，其距离精确为 d = n - K + 1，从而达到了 Singleton 界，属于 MDS 码。我们还讨论了 MDS 码的性质，以及 Reed-Solomon 码的字母表大小必须随块长增长这一重要限制。Reed-Solomon 码因其优异的性能和高效的算法，成为了实践中极其重要的纠错码。

代数编码理论：第5章：RS码的对偶视角

在本节课中，我们将学*里德-所罗门码的奇偶校验矩阵。我们将从一些必要的代数定义开始，然后推导出RS码的奇偶校验矩阵，并探讨其对偶码的性质。

有限域乘法群与原始元

首先，我们需要定义 Fq*。Fq* 是有限域 Fq 中所有非零元素构成的集合。在这个上下文中，乘法群意味着它在乘法运算下构成一个群，即它对乘法封闭且每个元素都有乘法逆元。

例如，考虑域 F5 = {0, 1, 2, 3, 4}，其上的运算为模5加法和乘法。那么，F5* 就是 F5 中所有非零元素，即 {1, 2, 3, 4}，并且我们只考虑其上的模5乘法。

关于 Fq* 的一个重要事实是：它是一个循环群。这意味着存在一个元素 γ ∈ Fq*，使得 Fq* 可以由 γ 的幂次生成。即：
Fq* = {γ, γ², γ³, ..., γ^(q-1)}
这样的 γ 被称为 Fq 的一个原始元。

回到我们的例子，2 是 F5 的一个原始元，因为：
2¹ = 2
2² = 4
2³ = 8 ≡ 3 (mod 5)
2⁴ = 16 ≡ 1 (mod 5)
集合 {2, 4, 3, 1} 恰好等于 F5*。另一方面，4 不是原始元，因为它的幂次只会产生 {4, 1}，无法生成整个 F5*。

一个关键代数事实

对于任何满足 0 < d < q-1 的整数 d，有限域 Fq 中所有元素的 d 次幂之和等于 0。即：
∑_{α ∈ Fq} α^d = 0

证明：
由于 α=0 时贡献为0，我们可以只对非零元素求和：
∑_{α ∈ Fq*} α^d
设 γ 是 Fq 的一个原始元，那么 Fq* 中的每个元素都可以表示为 γ^j，其中 j = 0, 1, ..., q-2。因此，求和式变为：
∑_{j=0}^{q-2} (γ^d)j
这是一个几何级数。对于任何 x ≠ 1，我们知道：
∑_{j=0}^{t-1} x^j = (1 - x^t) / (1 - x)
令 x = γ^d， t = q-1，我们得到：
∑_{j=0}^{q-2} (γ^d)j = (1 - (γ^d)(q-1)) / (1 - γ^d)
根据有限域的性质，对于任何 β ∈ Fq，有 β^q = β。因此，令 β = γ^d，我们有 (γ^d)q = γ^d。两边同时除以 γ^d（非零），得到 (γ^d)(q-1) = 1。
所以，分子 1 - (γ^d)(q-1) = 0。由于 d 满足 0 < d < q-1，且 γ 是原始元，因此 γ^d ≠ 1，分母 1 - γ^d ≠ 0。最终，整个分式等于 0。证毕。

RS码的对偶描述

上一节我们介绍了有限域的关键性质，本节中我们来看看如何利用它来重新描述RS码。

命题：设 n = q-1，γ 是 Fq 的一个原始元。考虑一个里德-所罗门码，其评估点为 {γ⁰, γ¹, ..., γⁿ⁻¹}，码长为 n，维度为 k。那么，这个RS码等于以下集合：
{ (c₀, c₁, ..., c_{n-1}) ∈ Fqⁿ | C(γʲ) = 0, 对所有 j = 1, 2, ..., n-k }
其中，C(x) 是由系数 cᵢ 定义的多项式：C(x) = ∑_{i=0}^{n-1} c_i x^i。

注意，这个视角翻转了RS码的原始定义。在原始定义中，消息是某个多项式的系数，而码字是该多项式在评估点上的取值。在这个新视角下，码字本身被看作是某个多项式的系数，并且该多项式在某些点（γ¹ 到 γⁿ⁻ᵏ）上的取值必须为0。

证明（包含关系之一）：
设 f(x) 是一个次数至多为 k-1 的多项式，那么一个RS码字就是 (f(γ⁰), f(γ¹), ..., f(γⁿ⁻¹))。
现在，考虑由这个码字构造的多项式 C(x) = ∑_{l=0}^{n-1} c_l x^l，其中 c_l = f(γˡ)。
我们计算 C(γʲ)（其中 1 ≤ j ≤ n-k）：
C(γʲ) = ∑_{l=0}^{n-1} c_l (γʲ)^l = ∑_{l=0}^{n-1} f(γˡ) γʲˡ
将 f(γˡ) 展开为 f(x) = ∑_{i=0}^{k-1} f_i x^i 在 x = γˡ 处的值：
= ∑_{l=0}^{n-1} [ ∑_{i=0}^{k-1} f_i γⁱˡ ] γʲˡ
交换求和顺序：
= ∑_{i=0}^{k-1} f_i [ ∑_{l=0}^{n-1} γ⁽ⁱ⁺ʲ⁾ˡ ]
令内部求和项为 S = ∑_{l=0}^{n-1} (γ⁽ⁱ⁺ʲ⁾)^l。
由于 0 ≤ i ≤ k-1 且 1 ≤ j ≤ n-k，我们有 1 ≤ i+j ≤ n-1 = q-2 < q-1。
根据上一节证明的关键事实，对于指数 d = i+j（满足 0 < d < q-1），有 ∑_{α ∈ Fq} α^d = 0。由于我们的求和是从 l=0 到 n-1（覆盖了 γ⁰ 到 γⁿ⁻¹，即 Fq* 的所有元素），因此 S = 0。
所以，C(γʲ) = 0。这证明了RS码是上述集合的一个子集。

要证明两个集合相等，还需要证明另一个方向的包含关系以及它们维度相同。通过计算奇偶校验矩阵，我们可以更清楚地看到这一点。

RS码的奇偶校验矩阵

上一节我们看到了RS码的一个对偶描述，本节我们将把这个描述转化为具体的奇偶校验矩阵。

推论：以下矩阵 H 是上述命题中RS码的一个奇偶校验矩阵：

H = [ 1,    γ,    γ²,   ..., γⁿ⁻¹ ]
    [ 1,    γ²,   γ⁴,   ..., γ²⁽ⁿ⁻¹⁾ ]
    [ ...,  ...,  ...,  ..., ...     ]
    [ 1,    γⁿ⁻ᵏ, γ²⁽ⁿ⁻ᵏ⁾, ..., γ⁽ⁿ⁻ᵏ⁾⁽ⁿ⁻¹⁾ ]

矩阵 H 有 n 列和 n-k 行。

为什么？
考虑 H 乘以一个向量 c = (c₀, c₁, ..., c_{n-1})^T。乘积结果向量的第 j 个元素（j 从1到 n-k）是：
∑_{i=0}^{n-1} c_i (γʲ)^i = C(γʲ)
其中 C(x) = ∑_{i=0}^{n-1} c_i x^i。
因此，条件 H * c = 0 等价于要求 C(γʲ) = 0 对所有 j = 1, ..., n-k 成立。这正是上一节命题中描述的集合。所以，该RS码就是 H 的零空间（核），故 H 是其奇偶校验矩阵。

此外，矩阵 H 是一个范德蒙矩阵，因此它是满秩的，秩为 n-k。那么，其零空间的维度就是 n - (n-k) = k，这与RS码的维度一致，也证明了上一节命题中两个集合的维度相同，从而它们是相等的集合。

对偶码与广义RS码

注意到，奇偶校验矩阵 H 的转置 Hᵀ 看起来非常像一个RS码的生成矩阵（除了第一列全是1）。这暗示着RS码的对偶码本身也*似是一个RS码。为了精确描述这种关系，我们引入广义里德-所罗门码。

一个广义里德-所罗门码 GRRS_q(α, n, k, λ) 定义如下：

α = (α₀, α₁, ..., α_{n-1}) 是一组互不相同的评估点。
n 是码长。
k 是维度。
λ = (λ₀, λ₁, ..., λ_{n-1}) ∈ (Fq*)ⁿ 是一个乘性权重向量。
其码字集合为：
{ (λ₀ * f(α₀), λ₁ * f(α₁), ..., λ_{n-1} * f(α_{n-1})) | f(x) ∈ Fq[x], deg(f) < k }
与标准RS码的唯一区别是在每个坐标上乘了一个非零常数 λᵢ。

定理：对于任意一组互异的评估点 α 和任意乘性权重向量 λ ∈ (Fq*)ⁿ，总存在另一个乘性权重向量 σ ∈ (Fq*)ⁿ，使得广义RS码 GRRS_q(α, n, k, λ) 的对偶码，等于另一个广义RS码 GRRS_q(α, n, n-k, σ)。

换句话说，广义RS码的对偶码仍然是广义RS码（评估点相同，维度变为 n-k，乘性权重向量不同）。我们在此不证明该定理，但鼓励读者思考权重向量 σ 应该如何由 λ 和评估点 α 决定。

总结

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

有限域的乘法群 Fq* 和原始元的概念，它们能生成整个非零元素集合。
一个关键代数事实：∑_{α ∈ Fq} α^d = 0（当 0 < d < q-1 时）。
利用该事实，我们得到了RS码的一个对偶描述：码字作为系数的多项式在特定点（γ¹ 到 γⁿ⁻ᵏ）上取值为零。
由此推导出RS码的奇偶校验矩阵 H，它是一个范德蒙矩阵。
通过观察 Hᵀ 类似于生成矩阵，我们引入了广义RS码，并指出其对偶码仍然是广义RS码。

所有这些结果都源于多项式的一个基本性质：非零多项式不能有太多根。正是这一性质赋予了RS码强大的纠错能力。

018：里德-所罗门码简史 📜

在本节中，我们将简要回顾里德-所罗门码的发展历史，并介绍其众多应用中的几个例子。

里德-所罗门码的定义回顾

首先，我们回顾一下里德-所罗门码的定义。我们有一组 n 个互不相同的评估点：α₁, α₂, ..., αₙ。给定参数 q（有限域的大小）、n（码长）和 k（维数），那么基于这些评估点的、定义在有限域 F_q 上的里德-所罗门码定义如下：

RS(n, k) = { (f(α₁), f(α₂), ..., f(αₙ)) | f ∈ F_q[x], deg(f) < k }

换句话说，它是所有次数低于 k 的多项式在这些评估点上的取值所构成的向量集合。我们在之前的视频中已经看到，里德-所罗门码达到了辛格尔顿界，这是一个非常出色的特性。

起源与发明者

这种通过评估低次多项式来构造编码的想法非常巧妙。那么它从何而来，又用在哪里呢？

里德-所罗门码由欧文·里德和古斯塔夫·所罗门于1960年发明。当时，里德和所罗门都在麻省理工学院的林肯实验室工作。在他们发表的原始论文中，他们引入了里德-所罗门码，并展示了其在码率与距离之间取得了极佳的权衡，这一点我们之前已经观察到。

早期解码算法的挑战

在上一节我们观察到其优异性能后，你可能产生了一个疑问：既然它们在码率与距离上有这么好的权衡，那么我们如何能高效地对它们进行纠错解码呢？

事实证明我们可以做到，但这绝非显而易见。实际上，里德和所罗门在最初提出这种码时，并不知道如何高效解码。如果你去查阅原始论文，会发现其中给出的解码算法远非最优。

以下是里德和所罗门最初提出的解码算法思路：
假设我们有一个码字，它是某个低次多项式 f 的评估值。在传输后，其中一些评估值被破坏了（产生了错误）。原始的算法是：随机选择 k 个符号，通过这些点插值出一个次数为 k-1 的多项式，并希望这 k 个点中没有包含错误符号。如果运气好避开了所有错误，就能正确恢复；如果不幸包含了错误，结果就会出错。这个算法可以重复多次，通过多数表决来提高正确率。

该算法在错误非常少时可行，但可以验证，它无法达到我们期望的最佳纠错能力，即纠正最多 (d-1)/2 个错误（其中 d 是最小距离）。

解码算法发展时间线

接下来，我们简要回顾一下里德-所罗门码解码算法的发展历程。

1960年：里德-所罗门码被发明。
同期：人们开始为BCH码（我们将在后续视频中讨论，它与里德-所罗门码相关）开发解码器。这些早期的BCH解码器对部分里德-所罗门码有效，但并非全部。
1969年：出现了对BCH解码器的改进，即伯利坎普-梅西算法。该算法利用了我们在之前视频中看到的里德-所罗门码的对偶视角（将码字视为在某些点上取零值的多项式的系数）。时至今日，这仍然是里德-所罗门码的标准解码器之一。
1986年：伯利坎普和韦尔奇提出了一种风格迥异的新算法——伯利坎普-韦尔奇算法。该算法使用的是原始视角，即消息是多项式的系数。
1990年代：研究人员开始探索如何突破“半距离”限制进行解码，即纠正超过 (d-1)/2 个错误。

你可能会问，这怎么可能？这被称为列表解码。我们将在后续的视频中回到这个话题，并在那时了解一些相关的解码器。

主要应用领域

那么，里德-所罗门码有哪些应用呢？由于其发明之初缺乏高效解码算法，它并未立即得到广泛应用。

然而，从20世纪70年代开始，它找到了许多高规格的应用场景，例如：

旅行者号太空计划
光盘（CD）技术

如今，里德-所罗门码已无处不在。虽然在通信领域，它因存在更快速算法的其他编码而不再那么流行，但它在存储领域应用非常广泛，例如：

硬盘驱动器
分布式存储系统

此外，它也用于像QR码这样的应用中。你看到的这个QR码，其本质就是通过某种方式将多项式转换成了二进制形式。我们将在课程后续部分详细讨论如何将里德-所罗门码转换为二进制码。

除了通信和存储，里德-所罗门码还有许多其他应用，我们也会在后面的视频中看到一些例子。

本节总结

在本节课中，我们一起学*了里德-所罗门码的简要历史。我们回顾了其定义，了解了它由里德和所罗门在1960年发明，并经历了从简单随机插值到伯利坎普-梅西算法、伯利坎普-韦尔奇算法，乃至列表解码的算法发展历程。最后，我们看到了它从早期的太空探测、光盘到现代存储系统和QR码的广泛应用。

在下一个视频中，我们将聚焦于其中一个具体的解码算法——伯利坎普-韦尔奇算法，来深入学*如何对里德-所罗门码进行纠错解码。

019：Berlekamp-Welch算法

在本节中，我们将学*一种用于解码里德-所罗门码的算法，称为Berlekamp-Welch算法。我们将了解该算法要解决的问题、其核心思想、具体步骤以及为何它是正确的。

问题定义 🎯

首先，我们需要明确要解决的问题：从错误中解码里德-所罗门码。

具体来说，假设我们收到一个字 W，即 W = (W₁, W₂, ..., Wₙ) ∈ F_qⁿ。我们的目标是找到一个里德-所罗门码字，使其与 W 足够接*。

这意味着我们需要找到一个定义在有限域 F_q 上的多项式 F(x)，其度数严格小于 K，并且与 W 的差异不能太大。量化来说，使得 F(αᵢ) ≠ Wᵢ 的位置 i 的数量最多为 E，其中 E 满足：

E ≤ ⌊(n - K) / 2⌋

如果不存在这样的多项式，算法应返回错误符号 ⊥。

这里为什么是 (n - K) / 2 呢？因为里德-所罗门码达到了Singleton界，⌊(n - K) / 2⌋ 本质上等于 ⌊(距离 - 1) / 2⌋，这是我们理论上能纠正的最大错误数。因此，我们要求算法能高效地纠正尽可能多的错误。

算法核心思想 💡

上一节我们定义了要解决的问题，本节中我们来看看Berlekamp-Welch算法的基本思路。

算法的基本思想是引入一个错误定位多项式 E(x)。

假设 F(x) 是我们想找的正确码字多项式。我们定义多项式 E(x) 如下：

E(x) = ∏ (x - αᵢ)，其中乘积遍历所有满足 Wᵢ ≠ F(αᵢ) 的索引 i。

注意，在解决问题时，我们并不知道这个多项式具体是什么，因为我们不知道哪些位置是错误。但从数学上讲，如果存在正确的 F，那么这个 E(x) 就存在。我们称它为错误定位多项式，因为如果我们代入一个错误位置 αᵢ（即 Wᵢ ≠ F(αᵢ)），这个多项式值就为零。

基于这个定义，我们可以得到一个关键观察：对于所有的 i，下式成立：

Wᵢ * E(αᵢ) = F(αᵢ) * E(αᵢ)

为什么成立？如果 Wᵢ = F(αᵢ)，那么等式两边显然相等。如果 Wᵢ ≠ F(αᵢ)，那么根据定义 E(αᵢ) = 0，等式变为 0 = 0，同样成立。因此这个等式恒成立。

现在，我们定义另一个多项式 Q(x) = F(x) * E(x)。那么上面的等式可以重写为：

Wᵢ * E(αᵢ) = Q(αᵢ)，对所有 i 成立。

Berlekamp-Welch算法的思路就是：找到满足上述关系式的多项式 Q(x) 和 E(x)，然后通过计算 Q(x) / E(x) 来恢复出 F(x)。

算法步骤 📝

理解了核心思想后，现在我们来看算法的具体步骤。算法分为两步：

步骤 1：寻找多项式
找到满足以下条件的多项式：

E(x)：首一多项式（最高次项系数为1），次数恰好为 E。
Q(x)：次数最多为 E + K - 1。
对于所有 i = 1 到 n，满足：Wᵢ * E(αᵢ) = Q(αᵢ)。

我们称这组条件为 （★）。如果找不到这样的多项式，则返回 ⊥。

步骤 2：恢复并验证

计算 F̃(x) = Q(x) / E(x)（多项式除法）。
检查 F̃(x) 是否是一个好答案。计算向量 F̃（在全部评估点 αᵢ 上的取值）与接收字 W 之间的汉明距离。
如果距离大于 E，说明 F̃ 不是正确答案，返回 ⊥。
否则，返回 F̃。

这就是完整的Berlekamp-Welch算法。此时，你可能会有两个疑问：第一，如何实现步骤1？第二，为什么步骤2中除以 E(x) 就能得到正确答案？

算法正确性证明 ✅

上一节我们提出了两个关键问题，本节我们先来回答第二个问题：为什么算法是正确的？这需要两个引理来证明。

引理 1：解的存在性
如果存在一个次数小于 K 的多项式 F(x)，其与 W 的汉明距离不超过 E，那么必然存在满足条件 （★） 的多项式 E(x) 和 Q(x)，并且满足 F(x) = Q(x) / E(x)。

证明：
按照核心思想中的定义来构造即可。
令 d = d_H(F, W) 为实际错误数（d ≤ E）。
定义错误定位多项式：
E(x) = x^(E - d) * ∏_{i: Wᵢ ≠ F(αᵢ)} (x - αᵢ)
乘以 x^(E-d) 是为了确保 E(x) 的次数恰好为 E，并且它是首一的。
定义 Q(x) = E(x) * F(x)。
可以验证，这样定义的 E(x) 和 Q(x) 满足条件 （★），且 Q(x) / E(x) = F(x)。

引理 2：解的唯一性（在比值意义上）
假设有两组多项式 （E₁, Q₁） 和 （E₂, Q₂） 都满足条件 （★）。那么，Q₁(x) / E₁(x) = Q₂(x) / E₂(x)。

证明：
考虑多项式 R(x) = Q₁(x)E₂(x) - Q₂(x)E₁(x)。

次数：Q 的次数 ≤ E + K - 1，E 的次数 = E。因此 R(x) 的次数 ≤ 2E + K - 1。
根：对于所有 i，根据条件 （★），有 Q₁(αᵢ) = Wᵢ E₁(αᵢ) 和 Q₂(αᵢ) = Wᵢ E₂(αᵢ)。代入 R(αᵢ) 可得其值为0。所以 R(x) 在 n 个点 αᵢ 上都为0，即有 n 个根。
矛盾与结论：我们已知 E ≤ ⌊(n - K)/2⌋，这意味着 2E + K - 1 < n。因此，R(x) 是一个次数小于 n 却拥有 n 个根的多项式。在域上，非零多项式的根数不能超过其次数。所以 R(x) 必须是零多项式，即 R(x) ≡ 0。
由 R(x) ≡ 0 可得 Q₁(x)E₂(x) = Q₂(x)E₁(x)，从而 Q₁(x)/E₁(x) = Q₂(x)/E₂(x)。

结合这两个引理，算法的正确性就得到了保证：引理1保证了至少存在一组解 （E, Q） 能通过除法得到正确的 F；引理2保证了任何满足条件 （★） 的解，其比值 Q/E 都是相同的。因此，无论我们在步骤1中找到哪一组解，通过步骤2的除法都能得到唯一的正确答案 F。

算法实现：步骤1的求解 🔧

现在我们来回答第一个问题：如何具体实现步骤1，即找到多项式 E 和 Q？

答案是将其转化为一个线性方程组并求解。

条件 Wᵢ * E(αᵢ) = Q(αᵢ) 对于每个 i 都提供了一个线性方程。这些方程中的变量是多项式 E(x) 和 Q(x) 的系数。

E(x) 是首一的 E 次多项式，有 E 个未知系数（因为首一，所以最高次项系数为1，是已知的）。
Q(x) 是次数 ≤ E + K - 1 的多项式，有 E + K 个未知系数。

因此，我们总共有 (E) + (E + K) = 2E + K 个未知变量。
我们有 n 个线性方程（每个评估点一个）。

根据引理1，如果存在接* W 的码字，那么这个线性方程组至少有一个解。我们的任务就是找到这个方程组的任意一个解。这可以通过标准的高斯消元法等线性系统求解方法来完成。

算法复杂度与总结 📊

最后，我们来分析一下Berlekamp-Welch算法的时间复杂度，并对本节内容进行总结。

算法的运行时间主要取决于两个步骤：

步骤1（求解线性系统）：对于一个有 O(n) 个方程和 O(n) 个变量的系统，使用高斯消元法需要 O(n³) 的时间。
步骤2（多项式除法）：两个次数为 O(n) 的多项式相除，也可以在 O(n²) 或 O(n³) 时间内完成（取决于实现方式）。

因此，算法的总时间复杂度为 O(n³)，其中 n 是里德-所罗门码的码长。这比暴力遍历所有码字（指数级复杂度）要高效得多。

😊 然而，还存在更快的解码算法。例如，在之前的课程中提到的 Berlekamp-Massey算法，其运行时间可以达到 O(n²) 甚至更快。虽然本系列视频不会深入讲解该算法，但鼓励感兴趣的读者自行查阅相关资料。

本节课总结
在本节课中，我们一起学*了Berlekamp-Welch解码算法。

我们首先明确了算法要解决的问题：纠正最多 ⌊(n-K)/2⌋ 个错误的里德-所罗门码解码。
我们理解了算法的核心思想：通过引入错误定位多项式 E(x)，将解码问题转化为寻找满足线性约束 WᵢE(αᵢ) = Q(αᵢ) 的多项式对 （E, Q），然后通过 Q/E 恢复信息多项式 F。
我们详细阐述了算法的两个步骤，并利用两个关键引理证明了算法的正确性。
我们说明了如何通过建立并求解线性方程组来实现算法的关键步骤。
最后，我们分析了算法具有 O(n³) 的多项式时间复杂度，是一种高效的解码方法。

020：为RS码寻找更小的字母表？ 🔍

在本节课中，我们将要学*里德-所罗门码面临的一个主要挑战：其庞大的字母表规模。我们将分析为何这在实际应用中会成为一个问题，并探讨如何将其转化为性能更优的二进制码。

概述：里德-所罗门码的挑战

上一节我们介绍了里德-所罗门码，它基于低次多项式根的数量有限这一优美思想，达到了Singleton界，实现了编码率与距离之间的最优权衡，并且拥有高效的编解码算法。然而，里德-所罗门码有一个主要缺点：它需要很大的字母表。

为了理解为何这是一个问题，让我们回到Alice和Bob的通信场景。假设他们想使用一个参数为 (n, k, d) 的里德-所罗门码，其中字母表大小为 Q（且 Q ≥ n）。然而，他们之间的信道只能传输比特（0和1），并且最多可能有 e 个比特在传输中被破坏。

简单的二进制转换策略

Alice和Bob可以尝试一种非常自然的方法来将他们的里德-所罗门码用于这个二进制信道。

基本思路是，将字母表 F_Q 中的每个符号（大小为 Q）用 log₂(Q) 个比特来表示。这样，一个长度为 n 的RS码字就被转换成了一个长度为 N = n log Q 的比特串。

这似乎是一个合理的做法。但如果我们将其视为一个二进制码，它的参数表现如何呢？

以下是新二进制码的参数计算：

消息长度 k'：新码的大小与原码相同，为 Q^k。因此，二进制码的消息长度为 k' = log₂(Q^k) = k log Q。
块长度 n'：n' = n log Q。
距离 d'：我们至少可以保证 d' ≥ d = n - k + 1（即原RS码的距离）。这是因为，如果我们在转换后的比特串中破坏了 d 个比特，并且这些比特恰好分布在 d 个不同的符号块中，那么它们就对应着破坏了原码字中的 d 个完整符号。我们无法期望距离会乘以 log Q。

现在，让我们计算这个新二进制码的编码率和相对距离。

新编码率 R'：R' = k' / n' = (k log Q) / (n log Q) = k / n。这与原RS码的编码率 R 相同。
新相对距离 δ'：δ' = d' / n' ≥ d / (n log Q) = δ / log Q，其中 δ = d/n 是原RS码的相对距离。由于对于RS码有 n ≤ Q，我们可以得到 δ' ≤ δ / log n。

这个结果有些令人困扰。新二进制码的相对距离 δ' 不仅比原RS码的相对距离 δ 更差，而且随着 n 的增大，log n 项会使 δ' 趋*于0。如果我们采用这种方法，虽然得到了一个二进制码，但我们甚至无法得到一个渐*好码（asymptotically good code），因为其相对距离会随着块长度的增加而趋于零。

设定新目标

鉴于上述情况，让我们为自己设定一个新的目标。首先，回顾一下我们已经实现的目标：

证明渐*好二进制码的存在性：我们通过Gilbert-Varshamov界实现了这个目标，它告诉我们随机线性码就是这样的码。
构造明确的、达到Singleton界且具有快速算法的码：我们通过里德-所罗门码实现了这个目标（尽管它们不是二进制码）。这里的“明确”意味着存在一种高效的方式来描述它们。

接下来，我们追求的是两者的结合。

我们想要的是明确的、二进制的、具有高效编解码算法的码。同时，我们希望它们在编码率和距离之间有良好的权衡。理想情况下，我们希望它们能达到二进制码可达到的最优权衡（尽管我们尚不清楚这个最优值具体是什么）。目前，让我们先满足于渐*好这个条件，即编码率和相对距离都远离零。

这将是接下来几节课我们的新目标。

总结

本节课中我们一起学*了里德-所罗门码在实际应用中的一个核心限制：其庞大的字母表规模。通过分析将其简单转换为二进制码的性能，我们发现这种直接的方法会导致相对距离严重衰减，无法得到渐*好码。因此，我们需要寻找更好的方法将RS码（或其思想）转化为高效的二进制码。在后续课程中，我们将探索实现这一新目标的策略。

代数编码理论：2：BCH码

在本节课中，我们将学*如何将里德-所罗门码转换为二进制码，这种方法被称为BCH码。我们将探讨BCH码的定义、性质、维度分析，并评估其作为二进制码的性能。

在之前的课程中，我们提出了如何将里德-所罗门码转换为二进制码的问题。本节中，我们将介绍一种称为BCH码的方法。

BCH码的名称来源于其发明者Bose、Chaudhuri和Hocquenghem的首字母，他们分别在1959年和1960年发现了这种码。

以下是BCH码的定义。

设 n = 2^m - 1，其中 m 是一个整数。令 γ 是有限域 F_{2^m} 的一个本原元。对于某个参数 d ≤ n，定义参数为 (n, d) 的BCH码为所有满足以下条件的向量 c = (c_0, c_1, ..., c_{n-1}) ∈ F_2^n 的集合：
对于所有 j ∈ {1, 2, ..., d-1}，有 c(γ^j) = 0。
其中，c(x) 是以 c_i 为系数的多项式：c(x) = Σ_{i=0}^{n-1} c_i x^i。

这个定义与之前看到的里德-所罗门码的对偶视角非常相似。另一种理解是，BCH码就是所有恰好是二进制的里德-所罗门码字的集合。换句话说，它是相应里德-所罗门码与集合 F_2^n 的交集。

基于这个观察，我们可以得出两个结论。

首先，这个BCH码的距离至少为 d，因为 d 是对应里德-所罗门码的距离。我们通过丢弃所有非二进制码字得到BCH码，这不会减小距离。

其次，BCH码拥有高效的解码算法。特别是，我们可以使用一些为里德-所罗门码设计的算法（如Berlekamp-Massey算法）来解码BCH码。实际上，历史上这些算法是先为BCH码开发的，后来才扩展到里德-所罗门码。

因此，我们现在有了一个具有良好距离和高效算法的二进制码。剩下的主要问题是：BCH码的维度是多少？

如果我们把BCH码定义为所有恰好是二进制的里德-所罗门码字，我们可能会怀疑BCH码中是否真的存在任何码字。为什么一个定义在大域上的低次多项式，在其所有域元素上的取值会恰好都是0或1呢？凭直觉，我们可能认为BCH码的维度是0，除了全零码字外没有其他码字。但事实上，它的维度大于0。让我们看看原因。

以下是一个关于BCH码维度的断言。

断言：BCH码是域 F_2 上的一个线性码，其维度至少为 n - d + 1。

需要指出，这个断言是错误的。然而，我们尝试证明它的过程将很有启发性。在证明过程中，请注意找出错误。

以下是“证明”：

首先，注意到定义中的条件 c(γ^j) = 0 是系数 c_0, ..., c_{n-1} 上的一个线性约束。具体来说，这个线性约束是：
Σ_{i=0}^{n-1} (γ^{j})i * c_i = 0。
对于每个 j ∈ {1, ..., d-1}，都有这样一个约束，因此总共有 d-1 个约束。

根据线性代数，BCH码的维度至少应为变量数减去约束数。这里有 n 个变量和 d-1 个约束，所以维度至少为 n - (d-1) = n - d + 1。证毕。

这个证明是错误的，断言也是错误的。为了看清原因，我们可以做一个快速检查。

在速率与相对距离的关系图上，对于 q=2，辛格尔顿界是一条斜率为-1的直线，而普洛特金界则指出，在相对距离大于1/2的区域，辛格尔顿界是无法达到的。然而，上述断言声称BCH码达到甚至可能超过了辛格尔顿界（具有块长 n，距离至少 d，维度至少 n-d+1），这与普洛特金界矛盾。

那么错误在哪里？问题在于，约束 Σ_{i=0}^{n-1} (γ^{j})i * c_i = 0 并不是在 F_2 上的线性约束。这是一个系数在 F_{2^m}（大域）中的线性方程，而不是系数在 F_2 中的线性约束。因此，之前的线性代数论证不成立。

不过，我们可以修正这个证明。以下是正确的断言。

修正后的断言：参数为 (n, d) 的BCH码是一个线性码，其维度至少为 n - (d-1) * ⌈log_2(n+1)⌉。

让我们来证明它。

基本思路相同，我们仍然计算约束数量，但这次要正确计算。我们将证明，每个约束 c(γ^j) = 0 实际上对应着 m 个不同的 F_2 线性约束。

为此，我们需要使用关于域 F_{2^m} 的一个事实：有限域 F_{2^m} 在忽略乘法运算后，其加法结构与向量空间 F_2^m 相同。更正式地说，存在一个双射映射 φ: F_{2^m} → F_2^m，使得 φ 与加法兼容：φ(α + β) = φ(α) + φ(β)。

利用这个事实，我们来看约束 c(γ^j) = 0，即 Σ_{i=0}^{n-1} c_i * γ^{ij} = 0。
对等式两边应用映射 φ。由于 φ 是 F_2 线性的，并且 c_i ∈ {0, 1}，我们得到：
Σ_{i=0}^{n-1} c_i * φ(γ^{ij}) = 0 （作为 F_2^m 中的向量）。

这可以写成一个矩阵方程：H * c^T = 0，其中 H 是一个 m × n 的矩阵，其第 i 列是向量 φ(γ^{ij})。因此，原始的单个约束等价于 m 个 F_2 上的线性约束（即矩阵 H 的 m 行）。

现在，让我们计算变量和约束的数量。

变量数：n（即 c_0, ..., c_{n-1}）。
约束数：对于每个 j ∈ {1, ..., d-1}，有 m 个约束。总约束数为 m * (d-1)。
由于 n = 2^m - 1，所以 m = ⌈log_2(n+1)⌉。

因此，BCH码的维度至少为：
n - m*(d-1) = n - (d-1) * ⌈log_2(n+1)⌉。
这就证明了修正后的断言。

另一种理解这个证明的方式是通过校验矩阵。我们可以构造BCH码的一个校验矩阵 H，它由 d-1 个上述的 m×n 矩阵堆叠而成，总共有 m*(d-1) 行。码字位于该矩阵的零空间中，因此维度至少是 n - rank(H) ≥ n - m*(d-1)。

实际上，我们还可以将这个界限改进大约2倍。

改进的断言：参数为 (n, d) 的BCH码的维度至少为 n - ⌈(d-1)/2⌉ * ⌈log_2(n+1)⌉。

证明的基本思想是，我们之前证明中的一些约束是冗余的，可以去掉一半。

考虑我们之前构建的校验矩阵 H，它有 d-1 “层”（每层对应一个 j）。我们将证明，只需要保留对应于奇数 j 的那些层，得到的矩阵 H' 与 H 具有相同的行空间，因此是同一码的校验矩阵。

为了证明这一点，我们需要一个子结论。

子结论：对于任何系数在 F_2 上的多项式 c(x)，以及对于所有 α ∈ F_{2^m}，如果 c(α) = 0，那么 c(α^2) = 0。

证明：假设 c(α) = 0，即 Σ c_i α^i = 0。
在特征为2的域（如 F_{2^m}）中，有一个性质称为“Freshman‘s Dream”：(a+b)^2 = a^2 + b^2。这个性质可以推广到求和。因此：
0 = (Σ c_i αⁱ⁾2 = Σ (c_i αⁱ⁾2 = Σ c_i^2 α^{2i}。
由于 c_i ∈ {0,1}，有 c_i^2 = c_i。所以上式变为 Σ c_i α^{2i} = c(α^2) = 0。
这就证明了子结论。

这个子结论意味着，如果 c(γ^j) = 0，那么对于任何偶数 j，有 c(γ^j) = 0 ⇔ c(γ^{j/2}) = 0。因此，所有对应于偶数 j 的约束，都已经包含在对应于 j/2（一个更小的数，可能是奇数）的约束中了。所以，在构造校验矩阵时，我们只需要保留对应于奇数 j 的那些层。这样，约束层的数量就从 d-1 减少到了 ⌈(d-1)/2⌉。

使用与之前相同的论证，变量数为 n，约束数至多为 ⌈(d-1)/2⌉ * m。因此，维度至少为 n - ⌈(d-1)/2⌉ * m，其中 m = ⌈log_2(n+1)⌉。这就证明了改进的断言。

现在我们已经理解了BCH码的维度，让我们回到在之前视频中设定的原始目标：构造具有高效编码解码算法的、显式的、渐*好的二进制码。

之前我们看到的简单策略（将里德-所罗门码的每个q元符号替换为长度为 log q 的二进制串）效果不佳。其速率 R 和相对距离 δ 满足 δ ≈ (1-R) / log_2 n。

那么BCH码在这个目标上表现如何？与之前的结果相比又如何？

对于参数为 (n, d) 的BCH码：

距离至少为 d。
拥有高效解码算法。
根据改进的维度下界，其速率 R = k/n 满足：
R ≥ [n - (d-1)/2 * log_2(n)] / n ≈ 1 - (δ * log_2 n) / 2，
其中 δ = d/n 是相对距离。

整理上式，可得 δ ≈ (2 / log_2 n) * (1 - R)。

将此式与之前简单策略的结果 δ ≈ (1-R) / log_2 n 比较，我们发现BCH码的表现要好大约2倍（分母上多了个因子2）。

然而，当 n 趋于无穷大时，如果保持速率 R 为常数，相对距离 δ 仍然会趋于0。因此，BCH码并未实现我们“渐*好”的最终目标（即同时保持常数速率和常数相对距离）。

尽管如此，由于这些高效的算法以及比简单策略更优的速率-距离权衡，BCH码在实践中被广泛使用，特别是在 n 不是特别大的场景中。

总结

本节课中，我们一起学*了BCH码。BCH码是一种将里德-所罗门码“二进制化”的有效方法，即取里德-所罗门码中所有恰好是二进制的码字构成的子集。我们发现这个子集确实非空，并且BCH码具有明确定义的距离下界和高效解码算法。

我们详细分析了BCH码的维度，推导出其下界为 n - ⌈(d-1)/2⌉ * ⌈log_2(n+1)⌉。虽然BCH码未能实现构造渐*好二进制码的最终目标，但其在实用中的优异性能使其成为一个非常重要且有用的编码方案。

在下一节课中，我们将探索另一种将里德-所罗门码转换为二进制码的方法。

022：二进制里德-穆勒码

在本节课中，我们将学*另一种基于里德-所罗门码思想的二进制编码方案——二进制里德-穆勒码。我们将了解其定义、参数特性，并分析它是否满足我们对“好”码的期望。

定义与历史背景

上一节我们介绍了不同的二进制里德-所罗门码变体。本节中，我们来看看另一种称为二进制里德-穆勒码的变体。

以下是二进制里德-穆勒码的定义。作为一个历史旁注，里德-穆勒码实际上早于里德-所罗门码被发明，尽管我们是以相反的顺序介绍它们。里德-穆勒码由穆勒发明，并由里德在1954年提供了一种高效的解码算法。

二进制M元里德-穆勒码（度数为R）定义如下：
我们使用符号 RM₂(m, R)。它的定义方式与里德-所罗门码类似。它是所有向量的集合，这些向量是某个多项式F在一组评估点α₁到α₂ᵐ上的取值。其中，F是定义在二元域F₂上的一个M元多项式，且度数至多为R。这里的评估点α₁到α₂ᵐ，就是F₂ᵐ中所有可能的点。因此，每个αᵢ都是一个长度为M的二进制向量。

F是一个M元多项式。例如，F(x₁, x₂)是一个包含两个变量的二元多项式。多项式中可以包含这些变量的任意组合构成的单项式。多项式F的度数就是其中出现的任何单项式的最高次数。一个包含K个变量的单项式的次数就是K。

这看起来非常像里德-所罗门码，只不过我们处理的是多元多项式。

多元多项式的形式

为了更清晰地定义度数至多为D的多元多项式，任何这样的多项式——即定义在F₂上、变量为x₁到xₘ、度数至多为D的M元多项式——都具有以下形式：

F(x₁, …, xₘ) = Σ_{S ⊆ {1,…,m}, |S| ≤ D} a_S · (Π_{i∈S} x_i)

其中，系数a_S来自F₂。这就是此类多项式的一般形式。你选择一些系数，就得到了具有这些系数的多项式。

请注意，因为我们在F₂上运算，所有这些单项式中每个变量的次数至多为1。这是因为对于F₂中的任何x，都有x² = x。因此，包含x₁²或x₂⁵等项是没有意义的。如果我们在更大的域上运算，这些单项式可能会看起来更复杂一些。

码的参数

以上就是二进制里德-穆勒码的定义。这些码具有什么样的参数呢？

以下是里德-穆勒码的定义复述：

RM₂(m, R) = { (F(α₁), …, F(α₂ᵐ)) | F ∈ F₂[x₁, …, xₘ], deg(F) ≤ R }

让我们来确定其码长和维数。

码长 (n)：码字向量的长度是2ᵐ。
维数 (k)：维数是Σ_{j=0}^{R} C(m, j)。我们实际上对此有过一些记号，这就是在大小为2的字母表上，M维空间中半径为R的汉明球的体积。

这个公式的原因是，它等于我们在任意多项式中可以选择的系数数量。就像里德-所罗门码一样，思考里德-穆勒码编码映射的一种方式是：先选择系数a_S，然后用它们构造出多项式，最后在所有不同的评估点上计算这个多项式的值。因此，消息长度或维数就是我们能选择的系数数量，也就是集合{1,…,m}中大小至多为D的子集的数量，而这个求和式正是在计算这个数量。

码的距离

现在我们知道了二进制里德-穆勒码的码长和维数。那么它的距离呢？

为了理解二进制里德-穆勒码的距离，我们将使用一个称为施瓦茨-齐佩尔引理的工具。以下是该引理的内容：

设F是定义在F₂上的一个M元多项式，且不恒等于0（即并非所有系数都为0）。并假设F的度数至多为R。那么，在F₂ᵐ中满足F(α) ≠ 0的点α的数量至少为2ᵐ⁻ᴿ。

这个引理的风格可能看起来很熟悉。没错，莫雷多项式没有太多根。这个引理基本上是在说，低次多元多项式没有太多根。

关于证明，我们将跳过，但这是一个有趣的练*。提示：可以证明你能将F写成F = xₘ·F₁ + F₀的形式，其中F₀和F₁是M-1元多项式，然后对M进行归纳。

但假设这个引理成立，我们还要观察到这个引理是紧的。也就是说，存在一些次数为R的多项式使得这个不等式取等号。

为了看出其紧性，考虑多项式F(x₁, …, xₘ) = x₁·x₂·…·x_R。观察可知，这个多项式非零当且仅当x₁到x_R都等于1，而剩下的M-R个变量可以任意取值。因此，使得该多项式非零的可能性有2ᵐ⁻ᴿ种。

该引理及其观察的一个推论是：参数为m和R的里德-穆勒码的距离恰好是2ᵐ⁻ᴿ。确实，这个引理正是在说任何非零的里德-穆勒码字至少有2ᵐ⁻ᴿ个非零分量。由于它是线性码，这意味着距离至少是2ᵐ⁻ᴿ。而我们观察中的例子表明距离至多是2ᵐ⁻ᴿ，因此它等于这个值。

高效算法与目标回顾

现在我们理解了二进制里德-穆勒码的参数。那么高效的算法呢？

里德-穆勒码确实有高效的解码算法。我们可能在后面的视频中会看到，但现在先跳过。这是一个有趣的练*：尝试自己设计一个。

让我们回到驱动过去几个视频的目标：我们想要具有高效编码和解码算法的、显式的、渐进好的二进制码。

好的，二进制里德-穆勒码是显式的（我可以确切地告诉你它们是什么）。它们是二进制的。如果你相信我的话，它们确实有高效的编码和解码算法。

但是，它们是渐进好的吗？我们已经计算了它们的参数n、k和d。现在让我们计算相对距离和码率，看看这个权衡关系如何。

相对距离 (δ)：δ = d / n = 2ᵐ⁻ᴿ / 2ᵐ = 2⁻ᴿ。特别地，如果我们希望它远离零，那么R需要是一个常数。
码率 (R)：参数为R和m的二进制里德-穆勒码的码率R = k / n。这就是在{0,1}ᵐ中半径为R的汉明球的体积除以码长n（即2ᵐ）。这看起来有点复杂，但幸运的是，我们已经在一定程度上理解了它的样子。至少当R不太接*m时，它大约等于 2^{ -m · [1 - H(R/m)] }，其中H是二元熵函数。

不幸的是，如果R是常数，随着m增长，这个值会非常快地趋*于零。具体来说，二进制里德-穆勒码也无法实现我们的目标，因为它们不是渐进好的。如果我们想要恒定的相对距离，码率就需要趋*于0。

然而，就像BCH码一样，里德-穆勒码实际上非常有用，在实践中被大量使用。特别是，尽管它们在最坏情况下的距离并不好，但它们在随机错误模型下实际上表现相当不错，而随机错误模型对于许多应用来说也是合理的。作为一个补充说明，完全理解二进制里德-穆勒码在随机错误下的性能仍然是一个悬而未决的问题。最*一些激动人心的研究已经解决了某些参数体系下的问题，但一般性问题仍然完全开放。

总结与预告

本节课的主要收获是：二进制里德-穆勒码是构造里德-所罗门式码的一种方法，它是低次多项式（恰好是二进制的）的取值。它们仍然非常酷且非常有用，但不幸的是，它们未能完全实现我们“渐进好码”的目标。

在下一个视频中，我们将看到另一种尝试使里德-所罗门码二进制化的方法，而这种方法将最终实现我们的目标。

023：级联码（第一部分） 🧩

在本节课中，我们将学*一种将大字母表上的码转换为二进制码的新方法。这种方法被称为“级联码”，它能帮助我们实现一个明确的目标：显式地构造出渐*好的二进制码。

动机与问题

上一节我们介绍了一种简单的转换方法：将大字母表上的码字直接写成二进制向量并拼接起来。然而，这种方法存在一个问题：转换后二进制码的距离会变差。

直观原因是，一个二进制块中哪怕只有一位出错，也可能导致整个符号块被错误解读。这引出了核心问题：我们如何保护这些二进制字符串免受错误影响？

级联码的核心思想

为了解决上述问题，我们引入了级联码的概念。其核心思想是：对每个二进制小块，再用一个纠错码（内码）进行二次编码。

以下是构建级联码的步骤：

将原始大字母表码（外码）的码字拆分成符号。
将每个符号视为一个二进制消息。
使用一个二进制码（内码）对每个二进制消息进行编码。
将所有内码编码后的结果拼接起来，形成最终的二进制码字。

正式定义与参数

现在，让我们正式定义级联码及其参数。

定义组件码

外码 (C_out)：定义在大字母表 Σ_out 上，参数为 [n_out, k_out, d_out]，字母表大小为 Q_out。
内码 (C_in)：定义在小字母表 Σ_in 上，参数为 [n_in, k_in, d_in]，字母表大小为 Q_in。我们要求 Q_out = Q_in^{k_in}，以确保内码能编码外码的一个符号。

定义级联码

级联码 C = C_in ∘ C_out 的编码过程如下：

将长度为 k_in * k_out 的消息 x 视为 k_out 个块，每块是 Σ_in^{k_in} 中的一个向量。
通过双射，将每个块映射为外码字母表 Σ_out 中的一个符号，得到消息 x' ∈ Σ_out^{k_out}。
使用外码 C_out 对 x' 进行编码，得到码字 y ∈ Σ_out^{n_out}。
将 y 的每个符号 y_i 通过双射还原为 Σ_in^{k_in} 中的向量。
使用内码 C_in 对每个这样的向量进行编码，得到 n_out 个内码码字。
将这些内码码字拼接起来，得到最终的级联码字 c ∈ Σ_in^{n_in * n_out}。

参数计算

以下是级联码的关键参数：

字母表：Σ_in（例如，二进制时为 {0, 1}）。
消息长度：k_in * k_out。
码字长度：n_in * n_out。
码率 (R)：R = (k_in * k_out) / (n_in * n_out) = R_in * R_out。
距离 (d)：d ≥ d_in * d_out。
相对距离 (δ)：δ ≥ δ_in * δ_out。

实现渐*好码

我们回到最初的目标：构造显式的、渐*好的二进制码。

思路如下：

选择一个里德-所罗门码作为外码 C_out。它具有正的码率 R_out > 0 和相对距离 δ_out = 1 - R_out > 0。
选择一个渐*好的二进制码作为内码 C_in。它具有正的码率 R_in > 0 和相对距离 δ_in > 0。
将它们级联。根据上述计算，得到的二进制级联码的码率 R = R_in * R_out > 0，相对距离 δ ≥ δ_in * δ_out > 0，因此它是一个渐*好码。

里德-所罗门码是显式的。那么，如何获得一个显式的、渐*好的二进制内码呢？这似乎成了一个“先有鸡还是先有蛋”的问题。

关键在于，内码的码长可以比外码短得多。根据吉尔伯特-瓦尔沙莫夫界，这样的好码是存在的。如果码长足够短，我们甚至可以通过穷举搜索在多项式时间内找到一个。这解决了“显式性”的问题。

总结

本节课我们一起学*了级联码的构造方法。我们首先分析了简单转换方法导致距离变差的问题，进而引入了对内码块进行二次编码的级联思想。我们正式定义了级联码，并推导了其码率是内外码码率的乘积，其距离至少是内外码距离的乘积。最后，我们展示了如何通过选择里德-所罗门码作为外码和一个短且渐*好的二进制码作为内码，来构造显式的渐*好二进制码，为解决“先有鸡还是先有蛋”的显式构造问题铺平了道路。在后续课程中，我们将探讨级联码的高效解码算法。

024：Zyablov界

在本节课中，我们将至少部分地实现我们的目标：构建具有高效算法的、显式的、渐*好的二进制码。同时，我们还将引入一个称为Zyablov界的概念。

概述

本节我们将学*Zyablov界。这个定理不仅保证了具有特定参数（码率与相对距离）的二进制线性码的存在性，更重要的是，它给出了这些码的显式构造方法。这意味着我们可以通过多项式时间算法来实际生成这些码。

Zyablov界的陈述

对于任意 ε > 0，存在一族显式的二进制线性码，其码率 R 和相对距离 Δ 满足以下复杂的权衡关系：

R ≥ sup_{R∈(0, 1-H₂(Δ)-ε]} [ R × (1 - Δ / H₂⁻¹(1 - R - ε) ) ]

其中：

H₂(x) 是二进制熵函数：H₂(x) = -x log₂(x) - (1-x) log₂(1-x)
H₂⁻¹(y) 是其逆函数。
“显式”意味着存在一个关于码长 n 的多项式时间算法，可以生成该码的描述。

这个表达式看起来很复杂，我们将在证明过程中看到它的来源。首先，让我们在图上看看它是什么样子。

图形化理解

我们最喜欢的图是y轴为码率R，x轴为相对距离Δ的图（针对二进制字母表）。图中包含了我们已经知道的各种界，以及Zyablov界。

Gilbert-Varshamov界：这是我们已知的存在性最好的界，它告诉我们存在具有特定R-Δ权衡的码，但并未给出构造方法（非构造性的）。
Zyablov界：其曲线位于Gilbert-Varshamov界之下。该定理的关键在于，在这条曲线上，不仅存在具有此权衡的码，而且我们可以显式地构造它们。

在我们之前设定的目标（寻找具有高效编解码算法的、显式的、渐*好的二进制码）的背景下，Zyablov界实现了前半部分。它给出了显式的、渐*好的二进制码。实际上，这些码也具有高效的解码算法（我们将在后续视频中看到）。

现在，让我们来证明Zyablov界。

证明Zyablov界

我们将使用级联码来证明Zyablov界。首先快速回顾一下级联码的结构。

级联码回顾

一个级联码 C 由内码 C_in 和外码 C_out 构成，记作 C = C_in ◯ C_out。构造过程如下：

将消息 x（属于小字母表 Σ_in 的 k_in × k_out 维空间）视为大字母表 Σ_out 上的 k_out 维向量。
用外码 C_out 对该向量进行编码，得到一个码字 y。
将 y 的每个符号（属于 Σ_out）视为 Σ_in 上的一个向量。
用内码 C_in 分别对这些小向量进行编码。
将所有编码结果拼接起来，得到最终的级联码码字 c。

构造选择

对于Zyablov界，我们按如下方式选择内码和外码：

外码 C_out：选择一个里德-所罗门码。其码率 R_out 和相对距离 Δ_out 满足 Δ_out = 1 - R_out（因为RS码达到了Singleton界）。
内码 C_in：选择一个二进制线性码，它位于Gilbert-Varshamov界上。即，其码率 r 和相对距离 Δ_in 满足 r ≥ 1 - H₂(Δ_in) - ε。

我们稍后再讨论如何实际获得这个内码。

分析参数

现在，我们来看待证明的定理所要求的几个方面：R-Δ权衡、二进制线性码、显式性。

1. 码率-距离权衡

级联码 C 的参数如下：

相对距离 Δ：等于内码和外码相对距离的乘积，即 Δ = Δ_in × Δ_out。
- 代入我们的选择：Δ_out = 1 - R_out，并且从内码条件 r = 1 - H₂(Δ_in) - ε 可解出 Δ_in = H₂⁻¹(1 - r - ε)。
- 因此，Δ = (1 - R_out) × H₂⁻¹(1 - r - ε)。
码率 R：等于内码和外码码率的乘积，即 R = r × R_out。
- 从上面的距离公式 Δ = (1 - R_out) × ... 可以解出 R_out = 1 - Δ / H₂⁻¹(1 - r - ε)。
- 代入码率公式得到：R = r × [1 - Δ / H₂⁻¹(1 - r - ε)]。

至此，我们看到定理中那个复杂表达式的来源。目前，内码码率 r 可以是任意值。为了得到最佳的R-Δ权衡，我们选择使表达式最大的 r 值，这就得到了定理中的上确界 sup。✅ 这便建立了定理中的码率-距离权衡。

2. 二进制与线性

根据构造，该码显然是二进制的。✅
可以证明，当里德-所罗门码的域大小为2的幂时，整个级联码是线性的。（这留给读者作为练*）✅

3. 显式性
这是不显然的部分。外码（RS码）是完全显式的。但内码 C_in 依赖于非构造性的Gilbert-Varshamov界，我们如何显式地获得它？

对我们而言，“显式”意味着存在一个关于最终码长 n 的多项式时间算法，能给出码的描述。只要我们能高效生成 C_in 的描述，整个级联码就是显式的。

假设外码RS码的求值点为有限域 F_Q* 的所有非零元，并令 Q = 2^{k_in}，其中 k_in 是内码的维数。这意味着 k_in = log Q，且外码长度 n_out = Q - 1。

以下是一个生成 C_in 描述的算法：

算法思路：暴力搜索
我们搜索所有可能的、具有指定码率 r 的二进制线性码（即搜索所有生成矩阵）。需要搜索的生成矩阵数量约为 2^{k_in * n_in}。由于内码码率 r = k_in / n_in，所以 n_in = k_in / r。因此搜索空间大小为 2^{(k_in)² / r}。

代入 k_in = log Q，得到搜索空间大小为 2^{(log² Q) / r}。

我们需要判断这个数量相对于最终码长 n 是大还是小。最终码长 n = n_in * n_out ≈ (k_in / r) * Q。由于 Q = 2^{k_in}，可以推导出 n ≈ (Q log Q) / r，进而得到 log² Q ≈ log² n。

因此，搜索空间大小约为 2^{O(log² n)}。这意味着算法总运行时间约为 n^{O(log n)}。这种运行时间被称为拟多项式时间，它非常接*但并非严格的多项式时间。

实际上，通过比这种朴素搜索更智能的方法，可以将运行时间降低到真正的多项式时间。我们在此不展开，课程笔记中提供了相关指引。

基于上述讨论（以及关于线性的练*），我们*似地认为显式性要求也得到了满足。✅

至此，我们完成了定理的证明，它确立了显式的、渐*好的二进制码的存在性。

补充说明

你可能会对这种“显式”的定义有所顾虑。即使存在多项式时间算法来告诉我一个码是什么，这也远不如像里德-所罗门码那样直接（可以直接写在幻灯片上）。实际上，通过精心选择级联码构造中的内码，可以得到更加显式的渐*好二进制码构造。如果你感兴趣，可以在课程笔记中找到更多相关内容。

总结

本节课我们一起学*了Zyablov界。我们了解到：

Zyablov界给出了一个位于Gilbert-Varshamov界之下的、具体的码率-距离权衡曲线。
关键突破在于，该曲线上的码是可以显式构造的，而不仅仅是存在。
我们利用级联码结构，选择RS码作为外码，并（通过一个高效可计算的搜索）选择达到GV界的二进制码作为内码，从而证明了该界。
这实现了我们寻找显式、渐*好二进制码目标的第一步。

在下一节课中，我们将讨论级联码的高效解码算法，这将引领我们完全实现最初设定的目标。

025：级联码解码（第一部分）🎯

在本节课中，我们将要学*如何高效地解码级联码。我们将从一个直观的解码算法开始，分析其有效性和局限性，并探讨如何改进它以接*理论最优的解码能力。

上一节我们介绍了级联码可以构造出渐*好码。本节中，我们来看看如何高效地对它们进行解码。

我们的目标，在几个视频以来，一直是寻找具有高效编码和解码算法的、显式的、渐*好的二进制码。到目前为止，我们已经得到了“显式”和“渐*好”的部分。在本视频及下一个视频中，我们将解决“高效解码”的部分。

请记住，我们用于第一部分（构造）的码是一个级联码 C = C_out ∘ C_in。其中，C_out 是一个距离为 d_out 的里德-所罗门码，而 C_in 的距离为 d_in。在本视频中，我们关心的是如何高效解码这个级联码。

让我们从一个初步尝试开始。

以下是级联码的结构。我们有一个级联码的码字。然后，一些错误会被添加进来。具体来说，字母表 Σ_in 中的某些符号会被破坏。假设有 E 个错误发生了，但我们不知道是哪些。

有一个非常自然的解码算法。实际上，你现在可以暂停视频，思考一下你会如何尝试解码这样的码。

好的，也许你想到了类似这样的方法。

以下是解码步骤：

第一步：使用内码 C_in 解码每一个块。也就是说，对于每个块，我们希望找到 C_in 中与这个块尽可能接*的码字 c‘。
第二步：从解码得到的 c‘ 反向推导出原始消息，进而得到对应的外码符号 α ∈ Σ_out。我们对所有块执行此操作，最终得到所有外码符号的猜测值。
第三步：使用外码 C_out 的解码器，从我们得到的符号中尝试恢复原始消息。

这是一个非常自然的算法。我们有两个问题：它高效吗？它正确吗（即能否真正纠正错误）？

首先，我断言它是高效的。第一步，因为 C_in 非常短，我们可以通过暴力搜索高效解码。第二步只是数据转换，是高效的。第三步，因为 C_out 是里德-所罗门码，我们可以使用Welch-Berlekamp等算法高效解码。所以，这个算法是高效的。

它正确吗？我断言，是的，在一定条件下它是正确的。更准确地说，我断言这个算法在错误数 E 不超过 d_in * d_out / 4 时有效。这里，d_in 是内码距离，d_out 是外码距离。

需要注意，乘积 d_in * d_out 是级联码的设计距离。在理想情况下，我们可能希望解码能力达到其距离的一半，即 d_in * d_out / 2。而我们证明的条件比这个少了一个因子2。我们稍后会再讨论这一点。

现在来证明这个断言。

证明：
首先，我们称一个块为“坏块”，如果其中的错误数量太多，以至于内码无法正确解码。即，一个块是坏块，如果其中的错误数 > ⌊(d_in - 1)/2⌋。

如果总共有 E 个错误，那么坏块的数量最多为 E / ⌊(d_in - 1)/2⌋。这是因为在最极端的情况下，每个坏块恰好有这么多错误，而其他块没有错误。

如果一个块不是坏块，那么内码 C_in 可以成功解码它。这意味着，在算法第二步中，我们能得到正确的外码符号。

现在考虑外码 C_out 的解码器。只要错误符号的数量（即坏块的数量）不超过 ⌊(d_out - 1)/2⌋，外码解码器就能成功。

利用坏块数量 ≤ E / ⌊(d_in - 1)/2⌋ 这一事实，我们看到，如果 E ≤ ⌊(d_in - 1)/2⌋ * ⌊(d_out - 1)/2⌋，外码解码器就能成功。这便证明了我们的断言，因为满足此条件的 E 也满足 E ≤ (d_in * d_out) / 4。

很好。所以，只要错误不太多，这个算法就有效。这确实实现了我们过去几个视频所追求的目标。我们得到了具有高效编码和解码算法的、显式的、渐*好的二进制码。其思想是，使用里德-所罗门码作为外码，使用达到吉尔伯特-瓦尔沙莫夫界的非显式码作为内码来构建级联码。之所以这是显式且最终算法高效，是因为内码非常短，我们可以对其使用高效的“暴力”算法。

让我们暂停片刻，庆祝一下目标的达成。

庆祝够了，因为现在我们要转向一个新的目标。

正如我们在前面的幻灯片中看到的，我们本希望做得比那个断言更好一些。断言表明我们可以解码到设计距离的 1/4。但实际上，我们应该能做到设计距离的 1/2。所以，这将是我们新的目标。

我们希望得到接*Zyablov界的显式二进制码。不仅仅是渐*好，而且要具有我们目前所知显式码中最好的权衡，并且具有高效解码算法，能纠正多达 (D-1)/2 个错误，其中 D 是码的设计距离。

为了获得如何实现这个新目标的直觉，让我们快速看一下在刚才分析的简单算法中，我们遗漏了什么。

我断言我们遗漏了一个因子2。并且我断言，我们可以通过以下观察找到这个因子2。

观察：当我们将损坏的码字块解码为内码的一个块时，我们不仅知道了纠正后的内码码字是什么，还知道了我们在进行这次纠正时修正了多少个错误。

为了理解这个观察为何重要，让我们考虑两个极端例子，看看对手如何破坏我们之前看到的解码算法。

例子1：对手在每个块中引入 0 个错误或恰好 d_in/2 个错误。也就是说，对手试图通过仅仅将每个它选择破坏的块破坏到刚好成为“坏块”的程度，来用其错误预算制造尽可能多的坏块。

在这种情况下，我们的算法解码这些坏块时可能会得到错误答案。根据计算，我们将得到 E / (d_in/2) 个错误块。这正是我们几页幻灯片前证明中的计算。

然而，如果对手真的采用这种策略，我们实际上可以做得更好。因为当我们纠正一个被破坏的块时（假设它被破坏了 d_in/2 个符号），由于内码距离为 d_in，即使我们纠正到了错误的码字，我们也至少改变了 d_in/2 个符号。另一方面，对于未受影响的块，我们什么也不会改变。

所以，如果对手采用此策略，我们正确的做法是：当我们发现纠正某个块时需要改变很多符号时，就直接将该整个块标记为“擦除”。这样，我们就能分辨出哪些块是错误的。如果你记得本课程最初的内容，一个距离为 D 的码可以处理 D-1 个擦除，而只能处理 (D-1)/2 个错误。也就是说，我们能处理的擦除数量是错误数量的两倍。这就是我们寻找的因子2。

例子2：对手在每个块中引入 0 个错误或 d_in 个错误。也就是说，对手要么不碰一个块，要么引入足够多的错误，使其变成另一个完全不同的有效内码码字。这样，我们甚至完全不知道出了什么问题，一切看起来都像是合法的码字。

在这种情况下，当解码一个特定块时，我们可能根本不会做任何改变，因为它已经是另一个有效码字了。这样，我们就不会检测到任何我们想标记为擦除的情况。另一方面，如果对手想这么做，他们必须在每个块上堆积两倍多的错误，这意味着他们只能破坏一半数量的块。看，我们的因子2又出现了。

我们在这里看到的是，至少在以上两个极端情况下，我们应该能够处理的错误数量，是我们几页幻灯片前所证明断言的两倍。这将实现我们的新目标。

本节课中我们一起学*了级联码的一个基础解码算法，它能在错误数不超过设计距离 1/4 时有效工作。我们还通过分析对手的两种极端策略，发现了算法有潜力将解码能力提升到设计距离的 1/2。下一次，我们将看到如何将这些例子变得更精确，并设计出真正实现这一目标的算法。

026：级联码解码（第二部分）🎯

在本节课中，我们将继续学*如何解码级联码，目标是纠正最多达到其设计距离一半的错误。

概述

上一节视频结束时，我们提出了一个解码级联码的初步算法。但该算法只能纠正最多达到设计距离四分之一（D/4）的错误。然而，我们仍然希望达到设计距离的一半（D/2），这源于对两种极端情况的分析。

在第一种极端情况下，攻击者在每个“坏块”中引入的错误不多。我们之所以能成功，是因为可以通过纠正大量错误来识别出哪些是坏块，然后将它们视为删除（erasure），这让我们节省了一个因子2。

在第二种极端情况下，攻击者在每个坏块中引入了大量错误。这同样对我们有利，因为坏块的数量不多，这同样允许我们节省一个因子2。

因此，我们希望通过在这两种极端情况之间进行“插值”，从而在一般情况下也能节省这个因子2。这就是本节视频要采用的策略。

里德-所罗门码的有用事实

为了实现这种插值，我们将利用关于里德-所罗门码的以下有用事实。

有用事实：如果 2E + S < D_out，其中 D_out 是外码（里德-所罗门码 C_out）的距离，那么我们可以从 E 个错误和 S 个删除中高效地解码里德-所罗门码 C_out。

这个事实的证明是一个有趣的练*。提示是：你可以将高效的里德-所罗门码解码器当作一个黑盒来使用。

这个有用事实将允许我们在删除和错误之间进行插值，直观上，这相当于在上述两种极端情况之间进行插值。

初步算法构想

更具体地说，以下是我们将要使用的算法。请注意，这还不是最终算法，我们稍后会对其进行修改。

算法输入一个接收到的字 W = (W_1, W_2, ..., W_{N_out})，其中每个 W_i 是字母表 Σ_in 上长度为 N_in 的向量。我们承诺接收字 W 与某个级联码字 C 的汉明距离严格小于 (D_in * D_out) / 2。

算法步骤如下：

对于 i 从 1 到 N_out（即对于接收字的每个块）：
- 对内码 C_in 在该块上进行解码。令 W_i' 为内码 C_in 中与块 W_i 最接*的码字。
接下来，我们将做一些看似奇怪的操作：抛一枚硬币，进行随机化处理。
- 以概率 p_i = min(1, (2 * d_H(W_i, W_i')) / D_in)，我们将参数 β_i 设置为 ⊥（表示删除）。
- 否则（以概率 1 - p_i），我们选择 β_i，使得内码对 β_i 的编码等于 W_i'（即我们修正后的块）。
完成对所有符号的处理后，我们得到一个向量 (β_1, β_2, ..., β_{N_out})，其中一些是 Σ_out 中的元素，另一些是 ⊥（删除）。
最后，我们在这个向量上运行外码 C_out 的解码器（即利用前述“有用事实”中能处理删除和错误的解码器），并返回其结果。

这个算法实现了我们之前的直觉：如果我们需要纠正大量错误（即 W_i 离 W_i' 很远），那么攻击者很可能在这个块上做了手脚，我们应将其视为删除。否则，我们假设一切正常，将其视为（可能正确的）解码结果。

算法的关键性质

你可能会问，为什么是这个特定的概率表达式？为什么使用随机化算法？答案在于以下断言。

断言：β_i 等于 ⊥ 的期望数量，加上两倍的 β_i 不正确的期望数量，其和严格小于外码的距离 D_out。

特别地，这意味着至少在期望上，我们送入外码解码器的字 (β_1, ..., β_{N_out}) 中，删除数量加上两倍错误数量的总和严格小于 D_out。而这正是该解码器能够成功解码所需的条件。

直观上，这个断言表明，至少在期望上，外码的解码器会成功。这个概率 p_i 的选择正是为了使这个断言成立。

从随机化到确定性算法

然而，断言只保证了“期望上”成功，我们需要的是一个总能工作的解码器，而不仅仅是期望上。

一种策略是多次重复该随机算法，以高概率获得正确结果。但我们将采用另一种方法：去随机化这个随机算法，从而得到一个确定性的算法。

首先，我们减少算法中的随机性。原算法中，每个 β_i 是否被标记为删除是独立决定的。现在，我们改为：

均匀随机地选择一个参数 θ ∈ [0, 1]。
对于每个块 i，如果 θ < p_i，则设置 β_i = ⊥；否则，设置 β_i 使得其编码为 W_i'。

这本质上等价于原算法，只是将随机性移到了循环外部，对每个 β_i 的决策使用了同一个随机源 θ。可以证明，修改后的算法仍然满足前述断言。

接下来是关键的去随机化步骤：我们不再随机选择 θ，而是穷举所有可能的 θ 值。对于每个 θ，我们运行上述流程，得到外码解码器输出的候选码字 X̃。如果 X̃ 与接收字 W 足够接*，我们就返回 X̃ 作为答案。

为什么这能行？因为根据断言，在 θ 的期望意义上，我们能得到正确答案。这意味着存在某个 θ 值能让我们得到正确答案。因此，如果我们穷举所有 θ，就一定能找到这个正确的 θ，并通过检查找到正确答案。

离散化处理

但 θ 在区间 [0, 1] 上有不可数无穷多个值，无法真正穷举。我们需要对其进行离散化。

关键在于，在这个算法中，θ 的具体值并不重要，重要的是它与每个概率 p_i 的比较结果（即 θ < p_i 是否成立）。考虑数轴 [0, 1]，上面有 N_out 个点 p_1, p_2, ..., p_{N_out}。这些点将区间划分为至多 N_out + 1 个子区间。对于落在同一个子区间内的所有 θ，它们在算法中的行为是完全相同的。

因此，我们不需要穷举所有 θ，只需从这 N_out + 1 个子区间中各选一个代表值（例如区间的中点或端点），然后穷举这 N_out + 1 个代表值即可。这完全等价于穷举整个连续区间。

最终算法：福尼广义最小距离解码器

整合以上步骤，我们得到最终算法：

计算所有概率 p_i = min(1, (2 * d_H(W_i, W_i')) / D_in)。
根据这些 p_i 值，确定 N_out + 1 个有代表性的 θ 值（例如所有 p_i 和 0、1 排序后，相邻值的中点）。
对于每一个代表性的 θ 值：
- 对于每个块 i：
  - 如果 θ < p_i，设置 β_i = ⊥。
  - 否则，设置 β_i 使得其编码为 W_i'。
- 在外码 C_out 上运行能处理删除和错误的解码器，输入为 (β_1, ..., β_{N_out})，得到候选码字 X̃。
- 如果 d_H(W, X̃) < (D_in * D_out) / 2，则返回 X̃。

这个算法被称为福尼广义最小距离解码器。它能够高效地解码级联码，纠正最多达到其设计距离一半的错误。

算法效率分析

让我们简要分析该算法的运行时间，主要开销在于：

内码解码：需要对 N_out 个块中的每一个进行解码。在我们的构造中，内码长度 N_in = O(log N_out)。即使使用暴力解码（遍历所有内码码字），其时间复杂度也是 O(2^{K_in} * N_in)。由于 K_in = O(log N_out)，所以 2^{K_in} 是 N_out 的多项式级。因此，每个块的内码解码时间是 N（总码长）的多项式。
外码解码：运行里德-所罗门码解码器，其时间复杂度也是多项式级的。
循环：外层需要循环 N_out + 1 次（即尝试所有代表性的 θ）。

综合来看，整个算法的总运行时间是总码长 N 的多项式，因此是高效的。

总结与成果

🎉 成功！ 我们已经达成了新目标：现在我们拥有了显式的二进制码，其性能接*Zyablov界，并且拥有高效的解码算法，可以纠正最多达到其设计距离一半的错误。

我们通过级联码实现了这一目标：

外码：里德-所罗门码。
内码：达到吉尔伯特-瓦尔沙莫夫界的某个码。由于内码的块长很短（对数级），我们可以高效地找到并处理它。

解码过程需要一些技巧（福尼算法），并非我们最初设想的那么简单，但我们最终成功了。

当前知识图谱

总结一下我们目前关于二进制码的知识，以相对距离为横轴，码率为纵轴：

吉尔伯特-瓦尔沙莫夫界：告诉我们存在具有某种折衷关系的码，但我们不知道它们具体是什么，也不知道如何高效解码。
Zyablov界：告诉我们存在具有更好折衷关系的码。
本节成果：我们不仅证明了Zyablov界所承诺的码存在，而且可以显式地构造它们，并且能够高效地解码它们。这非常酷！

本节课我们一起学*了如何通过福尼广义最小距离解码算法，高效地解码级联码至其设计距离的一半，这是构造具有良好性能的显式纠错码的关键一步。

027：伴随式解码、压缩感知与群组检测 📚

在本节课中，我们将学*线性纠错码的解码问题，并探讨它与另外两个重要问题——压缩感知和群组检测——之间的深刻联系。我们将看到，尽管这些问题的应用场景和数学基础各不相同，但它们共享一个核心的数学模型。

伴随式解码问题 🔍

上一节我们介绍了线性纠错码的基本概念。本节中，我们来看看一个具体的解码问题：伴随式解码。

伴随式解码，就是利用奇偶校验矩阵来解码线性纠错码的问题。具体定义如下：

假设 H 是我们的奇偶校验矩阵，它是一个定义在有限域 F_q 上的 (n-k) × n 矩阵。假设我们有一个权重（非零元素个数）不超过 t 的误差向量 e。

那么，伴随式解码问题就是：给定 H 与 e 的乘积（这个乘积被称为“伴随式”），以及奇偶校验矩阵 H，恢复出误差向量 e。

我们的目标是，在能够完成上述解码的同时，使码的维度 k（即码率）尽可能大。

用公式描述这个过程：

接收到的可能是被污染了的码字：c̃ = c + e，其中 c 是原始码字，e 是误差向量。
计算伴随式：H * c̃ = H * (c + e) = Hc + He = 0 + He = He。
若能根据 H*e 和 H 解出 e，则原始码字为 c = c̃ - e。

因此，解决伴随式解码问题，意味着我们能纠正码 C（H 的零空间）中的最多 t 个错误。我们之前在海明码解码器中见过这个范式，伯利坎普-梅西算法解码里德-所罗门码时也使用了相同的范式。

压缩感知问题 📡

上一节我们定义了伴随式解码。本节中，我们来看一个在形式上非常相似，但应用场景截然不同的问题：压缩感知（或称稀疏恢复）。

以下是压缩感知问题的描述。它与上一页幻灯片上的问题非常相似，请你暂停视频，尝试找出它们之间的区别。

区别主要在于：

一些符号上的变化：矩阵名称从 H 变为 Φ，行数从 n-k 变为 m，向量 e 变为 x。
术语变化：矩阵不再称为“奇偶校验矩阵”，而是“感知矩阵”；输出不再称为“伴随式”，而是“观测值”。
最关键的改变是：数域从有限域 F_q 变为了复数域 C（或实数域 R）。

问题的目标依然是使矩阵的行数 m 尽可能小。

我们关心这个问题的原因来自于信号处理。许多自然产生的数据是“稀疏”的，即其大部分分量为零或接*零。例如：

许多自然图像在适当的基（如离散小波变换基）下表示是稀疏的。
音频数据在合适的变换域下也常常是稀疏的。

如果我们能用 Φ * x 这样的线性方式观测或测量稀疏数据 x，并且 m 远小于 n，同时我们能从 Φ * x 高效地恢复 x，那么我们就无需存储整个 x，只需存储 m 个观测值即可。这在流算法、信号处理和医学成像等领域有重要应用。有趣的是，在复数域或实数域上解决这个问题，有时比在有限域上更容易。

群组检测问题 🧪

现在，我们来看第三个在句法结构上与伴随式解码极其相似的问题：群组检测。

为了解释这个问题，我们引入布尔代数 B。其元素为 {0, 1}，但运算“+”代表布尔或（OR），“*”代表布尔与（AND）。在这个定义下，我们可以提出完全相同形式的问题。

同样，这里除了数域从 C 变为布尔代数 B，以及一些术语变化（矩阵现在称为“混合设计”矩阵）外，问题形式完全一致。

我们关心这个问题的原因来自于实际应用，它最初被用于疾病检测。场景如下：

假设有 N 个人，其中 t 人生病，但我们不知道具体是谁。
方案一：对每个人单独进行血液检测，共需 N 次检测。
方案二（群组检测）：只进行 m 次检测（m << N）。在每次检测中，混合多个人的血样。一次检测的结果为阳性，当且仅当参与该次检测的混合样本中含有至少一个病人的血样。

那么，如何将此场景转化为我们的数学模型呢？

以下是建立模型的过程：

构造一个 m × n 的矩阵 Φ（混合设计矩阵）。行代表 m 次检测，列代表 n 个人。
如果第 j 个人参与了第 i 次检测，则在矩阵的 (i, j) 位置放 1，否则放 0。
构造一个列向量 x，其长度为 n。如果第 j 个人生病，则 x 的第 j 个分量为 1，否则为 0。这是一个只有 t 个 1 的稀疏向量。
在布尔代数下计算 y = Φ * x。这里乘法是 AND，加法是 OR。
结果向量 y 的第 i 个分量，就表示第 i 次检测是否为阳性（1 为阳性，0 为阴性）。

因此，我们的目标——通过尽可能少的检测次数 m，从检测结果 y 中找出哪些人生病——就等价于从 Φ * x 和 Φ 中恢复稀疏向量 x，并希望 m 尽可能小。这正是我们之前定义的问题形式。

群组检测在 20 世纪 40 年代被引入，用于检测美国士兵的疾病。此后，它在高通量基因筛选、无线通信等众多领域找到了用武之地。

总结与联系 🔗

本节课中，我们一起学*了三个不同领域的重要问题。

我们看到了同一个核心问题的三种不同表现形式：

给定一个“矮胖”矩阵与一个“长”的稀疏向量的乘积，以及该矩阵的描述，恢复出那个稀疏向量。

具体来说：

在有限域上，这是伴随式解码问题，用于纠错码。
在复数域/实数域上，这是压缩感知（稀疏恢复）问题，用于信号处理等领域。
在布尔代数上，这是群组检测问题，用于从大规模群体中检测稀有特征。

这些问题各有不同，需要不同的算法和解决方案。然而，正如你所想象的，相同的数学技巧可能会在三个领域中都出现。在接下来的视频中，我们将聚焦于群组检测，并看到来自编码理论（特别是里德-所罗门码）的思想，如何被用来获得群组检测问题的优秀解决方案。

028：分离矩阵

在本节课中，我们将学*分离矩阵的定义，并理解它如何为群组检测问题提供解决方案。我们还将证明，一个 t-分离的矩阵可以可靠地识别出最多 t 个阳性个体。

分离矩阵的定义

上一节我们介绍了群组检测的概念。本节中，我们来看看分离矩阵，它将为我们提供工具，以理解基于里德-所罗门码的群组检测解决方案。

首先，回顾一下布尔代数 B，它包含元素 {0, 1}，其中“+”表示布尔或运算，“×”表示布尔与运算。同时，Φ 是一个池化矩阵，这意味着它是一个 M × N 的矩阵，其中 M 对应测试的数量，N 对应待检测的物品或人数。当且仅当我们将第 j 个人放入第 i 次测试时，矩阵 Φ 在 (i, j) 位置上的值为 1。

以下是 t-分离矩阵的定义：

对于一个池化矩阵 Φ，如果对于任意大小为 t 的列索引子集 Λ ⊆ {1, ..., N}，以及任意不在 Λ 中的列索引 j，都存在至少一行 i ∈ {1, ..., M}，使得：

Φ[i, j] = 1 （第 j 列在第 i 行有 1）

并且对于所有 l ∈ Λ，Φ[i, l] = 0 （Λ 中所有列在第 i 行都是 0）

那么，我们称矩阵 Φ 是 t-分离 的。

分离矩阵的重要性

为什么我们关心矩阵的分离性？事实证明，一个 t-分离的矩阵可以构建一个能够检测出最多 t 个阳性物品（或病人）的池化检测方案。

更正式地说，有以下定理：

定理：如果池化矩阵 Φ 是 t-分离的，那么作为一个池化检测方案，它可以识别出最多 t 个阳性物品。

这意味着，对于任何权重（即“1”的个数）不超过 t 的布尔向量 x（长度为 N），给定布尔代数下的乘积 Φ × x，我们都可以恢复出 x。

让我们通过一个算法来证明这个定理。这个算法将根据 Φ × x 的结果来恢复 x。

以下是恢复算法：

对于每一个 j ∈ {1, ..., N}（即对于矩阵的每一列）：

如果所有包含物品 j 的测试结果都是阳性，那么判定物品 j 为阳性。

否则，判定物品 j 为阴性。

这个算法非常直观。它遍历所有可能的物品，并检查：如果某个物品参与的所有测试都呈阳性，那么它很可能是阳性；反之，只要它参与的任意一次测试呈阴性，就证明它不是阳性。

证明：

如果物品 j 确实是阳性的，那么算法显然会判定其为阳性。
假设物品 j 是阴性的。令 Λ 为真实的阳性物品集合（大小 ≤ t），且 j ∉ Λ。
根据 t-分离性的定义，存在某一行 i，使得 Φ[i, j] = 1 且对于所有 l ∈ Λ，Φ[i, l] = 0。
这意味着：物品 j 参与了测试 i，并且测试 i 中没有任何阳性物品。
因此，测试 i 的结果将是阴性的，这为“物品 j 不是阳性”提供了证明。
根据算法逻辑，当发现物品 j 参与的某次测试为阴性时，就会判定 j 为阴性。

因此，算法是正确的，定理得证。

新的目标与已知结果

这为我们设定了一个新的目标：设计 t-分离的池化矩阵 Φ，并且在给定总人数 N 和最大阳性数 T 的情况下，使得测试次数 M 尽可能小。

以下是已知的两个最佳构造方案：

基于里德-所罗门码的构造，可以达到 M = O(T² log_T² N)。
另一种构造可以达到 M = O(T² log N)。一个有趣的练*是：可以证明，以一个适当的概率随机生成矩阵，只要 M 大约为这个数量级，该矩阵就有很高的概率是 t-分离的。

这两种结果各有优劣，适用于不同的参数范围。据我们所知，它们都尚未达到理论最优值。目前已知的最佳下界是 M ≥ Ω(T² log_T N)，因此上述构造与下界之间还存在一些差距。

此外，还存在比我们刚才看到的“遍历所有元素”方法快得多的群组检测算法，有些算法的运行时间甚至接*测试次数 M 的线性级别，并且也基于编码理论。

总结

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

t-分离矩阵的正式定义，它要求对于任何 t 个列的集合和其外的任一列，都存在一行能将该列与那 t 个列区分开。
证明了 t-分离矩阵可以构建一个能可靠识别最多 t 个阳性物品的群组检测方案，并给出了具体的恢复算法。
了解了当前关于构造 t-分离矩阵以最小化测试次数 M 的已知最佳结果，其中一种高效构造基于里德-所罗门码。

在下一节视频中，我们将重点介绍这种基于里德-所罗门码的构造，即著名的 Kautz-Singleton 构造。

029：Kautz-Singleton构造

在本节课中，我们将学*如何利用编码理论来构建高效的组合测试矩阵。具体来说，我们将介绍一种名为Kautz-Singleton的构造方法，它使用里德-所罗门码来生成具有良好性质的分离矩阵，从而以接*最优的测试次数解决组合测试问题。

回顾与目标

在上一节视频中，我们介绍了组合测试问题，并了解到分离矩阵可以解决它。本节中，我们来看看一个利用里德-所罗门码来获得分离矩阵的优秀解决方案，即Kautz-Singleton构造。

回顾上一节末尾的目标：我们希望设计一个测试矩阵 Φ，它使用 M 次测试来检测 N 个物品，使得 Φ 是 t-分离 的，并且在给定 N 和 t 的情况下，M 尽可能小。

今天，我们将看到一个构造，其 M = O(t² log_t² N)。正如上一节所见，这几乎是理论最优的。

Kautz-Singleton构造原理

以下是该构造的工作原理。

我们从一个任意的码开始。设 C 是一个 q元码，其码长为 n，维数为 k，最小距离为 d。

设物品总数 N = qᵏ，测试总数 M = q × n。

我们稍后会选择这些参数 n, k, d, q，但现在我们先让它们保持为变量，以便理解各部分如何组合。

给定这个码 C，我们将按以下方式构建测试矩阵。

首先，我们在有限域 F_q 上形成一个矩阵。这个矩阵的每一列都是码 C 的一个码字。因此，矩阵的尺寸是 n × N，定义在 F_q 上。每一列是 C 的一个码字，我们将所有不同的码字并排排列作为列，从而得到这个矩阵。

注意，尺寸是吻合的：C 的每个码字长度为 n，总共有 qᵏ 个这样的码字，而我们已经定义 N = qᵏ，所以所有可能的码字都是这个矩阵的列。

然而，这个矩阵不是二进制的。为了用于组合测试设计，我们需要将其转换为二进制矩阵。

转换方法如下：我们将 F_q 中的每个符号替换为一个长度为 q 的小二进制向量。也就是说，我们将矩阵中的每个符号“膨胀”为一个指示向量。

具体操作是，将 F_q 中的元素 αᵢ 映射为第 i 个标准基向量 eᵢ。例如，如果 α₁ 映射为 (1, 0, 0, …, 0)，α₂ 映射为 (0, 1, 0, …, 0)，依此类推，直到 α_q 映射为 (0, 0, …, 0, 1)。

这意味着，原始矩阵中的每一列将被转换为一组“膨胀”后的向量，每个向量中恰好有一个“1”，用于指示原始矩阵中对应位置是哪个域元素。

最终，我们将得到一个二进制矩阵，其尺寸为 M × N，其中 M = q × n。

构造的分离性定理

我们声称，只要码 C 具有良好的距离，这样得到的矩阵就是一个好的组合测试设计。以下是相关的定理。

定理：在刚刚描述的Kautz-Singleton构造中，如果码 C 的距离 d 满足：
d > n(t-1)/t
那么由此得到的矩阵 Φ 是 t-分离 的。

定理证明

我们需要证明以下性质：对于码 C 中任意大小不超过 t 的子集 Λ，以及对于任意不在 Λ 中的码字 c ∈ C，都存在一个位置索引 i (1 ≤ i ≤ n)，使得 cᵢ 的值不等于 Λ 中任何码字 w 在位置 i 的值 wᵢ。

这实际上是 t-分离 定义在该特定构造下的翻译。如果上述性质成立，那么在矩阵的对应“层”（即膨胀后的行）中，码字 c 对应的列在该位置会有一个“1”，而 Λ 中所有码字对应的列在该位置都是“0”，从而满足了分离矩阵的定义。

现在来证明这个性质。

考虑 Λ 中的码字和码字 c。根据码距离的定义，Λ 中的任意一个码字 w 与 c 最多在 n - d 个位置上相同（因为它们在至少 d 个位置上不同）。

Λ 中最多有 t 个码字。因此，所有 Λ 中的码字与 c 可能相同的位置总数，最多为 t × (n - d)。

根据定理条件 d > n(t-1)/t，我们可以推导出：
t × (n - d) < t × [n - n(t-1)/t] = t × (n/t) = n

这意味着，所有 Λ 中的码字与 c 可能相同的位置总数，严格小于总位置数 n。因此，必然存在至少一个位置 i，使得 c 在该位置的值与 Λ 中所有码字在该位置的值都不同。这正是我们需要寻找的 i。

证明完毕。

因此，为了得到一个好的组合测试矩阵，我们只需要一个具有良好距离的码。

应用里德-所罗门码

幸运的是，我们确实知道一种具有良好距离的码：里德-所罗门码。

现在，让我们选择一些参数来实例化这个定理，从而构建一个好的组合测试矩阵。

回顾一下，根据构造，我们有：

物品数 N = qᵏ
测试数 M = q × n

我们选择一个里德-所罗门码 C，使其距离 d = n - k + 1。事实上，我们选择使用所有 q 个评估点的RS码，这意味着其码长 n = q。

现在我们需要选择参数 k 和 q。

首先，我们需要码距 d 严格大于定理要求的 n(t-1)/t。因此，我们选择 k，使得：
d = n - k + 1 = n(t-1)/t + 1
这样严格不等式就能满足。

由于我们设 n = q，代入上式：
q - k + 1 = q(t-1)/t + 1
进行代数运算后可得：
k = q / t

现在，物品数 N = qᵏ = q^{q/t}。
重新排列这个等式，可以得到：
q = t × log_q N

测试数 M = n × q = q² （因为 n = q）。
将 q 的表达式代入：
M = q² = t² × (log_q N)²

我们希望用 t 和 N 来表示 M。注意到 q = √M，因此：
M = t² × (log_{√M} N)²
可以验证，这个等式意味着：
M = O( t² (log_t N)² )

这正是我们想要展示的结果。

总结

回到我们设计 t-分离 测试矩阵且 M 尽可能小的目标，我们现在已经看到了一个构造，其测试次数 M = O( t² (log_t N)² )。正如前一节提到的，这个值几乎是理论最优的。

本节课中，我们一起学*了编码理论技术在组合测试中的应用。我们看到了利用里德-所罗门码的一种具体方法，即Kautz-Singleton构造。实际上，编码理论技术还有许多其他方式可以帮助解决组合测试及其扩展和变体问题，我们可能在后续的视频中看到其中一些。

030：随机信道

📋 概述

在本节中，我们将学*随机信道模型。之前我们考虑的是由对手引入的错误，本节我们将快速了解错误随机引入的场景。

📡 随机信道模型

我们考虑以下错误模型。发送方爱丽丝有一个长度为 K 的消息 X，她将其编码成长度为 n 的码字 C。然后，码字 C 通过一个信道 W，得到一个被破坏的、长度为 n 的码字 C̃，其字母表可能变为 Σ‘。接收方鲍勃收到这个被破坏的码字，并希望能解码以恢复爱丽丝的消息 X。

这里的 W 是一个离散无记忆信道。

“离散”意味着输入和输出字母表都是有限的。“无记忆”意味着信道 W 独立地破坏码字中的每个符号，与其他符号无关。换句话说，W 由一个概率分布定义，描述了基于输入符号 X 得到输出符号 Y 的概率。

我们将其记为 W(Y|X)。这是给定输入 X 时，输出为 Y 的概率。其中，Y 属于输出字母表 Σ‘，X 属于输入字母表 Σ。我们假设 W 对码字 C 的每个符号独立地起作用。

🔧 信道示例

以下是两个常见的随机信道示例。

1. 二进制对称信道

我们将其记为 BSC_p，其中 p 是介于 0 和 1 之间的参数。该信道由以下概率分布给出：

P(Y|X) = p,     如果 X ≠ Y
         1 - p, 如果 X = Y

其中，X 和 Y 都属于字母表 {0, 1}。二进制对称信道的作用是：输入 C 的每一位以概率 p 被独立地翻转，以概率 1-p 保持不变。

2. 二进制擦除信道

我们将其记为 BEC_p，其中 p 是擦除概率。该信道由以下条件概率分布给出：

P(Y|X) = p,       如果 Y = ⊥ (擦除)
         1 - p,   如果 Y = X
         0,       其他情况

其中，输出字母表 Σ‘ 为 {0, 1, ⊥}，输入字母表 Σ 为 {0, 1}。二进制擦除信道以概率 p 独立地擦除每个比特。

🎯 成功概率与信道容量

由于 W 是无记忆信道，即独立破坏每个符号，鲍勃无法指望每次都成功解码。存在一个虽小但为正的概率，所有符号都会被严重破坏。

因此，我们不追求在所有情况下都成功（这是对抗性错误模型的要求），而是希望以高概率成功。

我们有以下正式定义：设 W 是一个信道，C 是一个具有编码和解码映射的码。我们说，对于所有可能的消息 X，码 C 在信道 W 上的失败概率至多为 δ（0到1之间的数），如果满足：

P[ 解码器( W( 编码器(X) ) ) ≠ X ] ≤ δ

在对抗性错误模型中，我们的目标是研究码率和距离之间的最佳权衡。对于随机信道，我们同样想知道码率与在该信道上纠正错误能力之间的最佳权衡，并使用失败概率来定义它。我们想知道在失败概率非常小的情况下，通过该信道通信所能达到的最佳码率。

事实证明，存在这样一个极限，称为信道的容量。香农证明，每个离散无记忆信道 W 都有一个容量 C（一个介于0和1之间的数）。容量的意义是：对于低于该容量的码率，可以使失败概率趋*于零；而对于高于该容量的码率，则不可能。

此外，容量在信息论中有一个很好的表达式。具体来说，C 是输入随机变量 X 与输出随机变量 Y 之间的互信息 I(X;Y)，在所有可能的输入分布上取得的最大值。

📝 总结

本节课我们一起学*了随机信道模型。我们介绍了离散无记忆信道的概念，并分析了两个具体例子：二进制对称信道和二进制擦除信道。与对抗性模型不同，在随机信道中我们追求以高概率成功解码，并引入了失败概率和信道容量的概念。信道容量定义了可靠通信的速率上限。在接下来的视频中，我们将更正式地阐述关于二进制擦除信道的香农定理并概述其证明。

031：二进制对称信道的容量 📊

在本节课中，我们将学*香农关于二进制对称信道的噪声信道编码定理，并概述其证明过程。

概述

上一节我们介绍了信道容量的非正式定义。本节中，我们将正式阐述并概述二进制对称信道容量的定理及其证明。

定理陈述

首先，快速回顾上一节的设定。我们有一个发送方爱丽丝和一个接收方鲍勃。与通常设定不同的是，我们有一个引入噪声的随机信道 W。本节假设 W 是参数为 P 的二进制对称信道 BSC(P)。这意味着 W 以概率 P 独立地翻转每个比特。

信道容量定义为可实现可靠通信的最高速率。即，如果速率低于容量，则失败概率趋*于0；如果速率高于容量，则失败概率将远离0。

我们将形式化并概述以下定理的证明：

定理：参数为 P 的二进制对称信道的容量为 1 - H₂(P)，其中 H₂(P) 是二进制熵函数。

更精确的定理陈述如下：

对于所有介于0和1/2之间的参数 P，以及所有介于0和 (1/2 - P) 之间的 ε，以下成立：

存在某个常数 δ > 0，使得对于所有足够大的 n 和 K，如果 K ≤ (1 - H₂(P) - ε) * n（即码率不超过此值），则存在一种编码算法和解码算法（特别地，存在一个码），使得对于所有消息 X ∈ {0,1}^K，失败概率（即解码器出错且未返回实际消息的概率）极小，满足 ≤ 2^{-δn}。
存在某个常数 δ > 0，使得对于所有足够大的 n 和 K，如果 K ≥ (1 - H₂(P) + ε) * n（即码率大于此值），则对于所有编码和解码映射（特别地，对于所有码），都存在某个输入 X，使得解码器很可能出错，即解码器输出不等于正确消息 X 的概率 ≥ 1/2。

简而言之，第一部分说明如果速率略低于 1 - H₂(P)，则失败概率极小；第二部分说明如果速率略高于 1 - H₂(P)，则失败概率很大（至少1/2）。

证明概述

本节我们将概述该定理的证明。需要说明的是，这不是证明此定理的最佳方法。最佳方法应使用信息论，但本系列视频不涵盖信息论。因此，我们将概述一个基于基本原理的证明，旨在使您相信其正确性。我们鼓励您学*更多信息论知识，以了解此结果及其对任意信道 W 的推广的正确表述。

第一部分证明思路（可达性）

对于定理的第一部分（可达性），我们不会深入细节，仅简述思路：使用完全随机的码。即，从 {0,1}^n 中随机选择一个集合作为码 C，为其选择一个随机编码映射，然后选择解码映射（例如，选择最接*的码字）。这基本可行，但可能需要剔除少数可能靠得太*的码字。这是一个有趣的练*，您可以尝试实现这个想法。

第二部分证明思路（逆命题）

现在，让我们重点讨论第二部分的证明思路。第二部分表明，如果速率过高，那么无论使用什么码，在二进制对称信道上的失败概率都会相当高。

实际上，我们将证明其逆否命题：如果失败概率太小，那么速率也必须很小。

以下是基本思路：

假设码的失败概率小于 1/2。对于每个消息 X，定义集合 D_X 为所有满足 解码器(y) = X 的 y ∈ {0,1}^n。这将整个空间 {0,1}^n 划分为多个区域，每个 D_X 对应一个区域。

接下来，考虑消息 X 的编码码字通过二进制对称信道后的情况。以该码字为中心，考虑一个半径为 P * n 的汉明球。当码字通过 BSC(P) 后，期望大约有 P 比例的比特被翻转。因此，输出有很大概率落在一个以 P * n 为中心的“环带” S_X 内。

由于我们假设失败概率很小（小于 1/2），因此 S_X 中的大部分点必须包含在 D_X 中。否则，如果 S_X 大部分位于 D_X 之外，那么当码字通过信道后，输出很可能落在 D_X 之外，从而导致解码失败。

这意味着对于每个 X，区域 D_X 的体积至少（在某个常数因子内）与 S_X 的体积相当。而 S_X 的体积又*似等于半径为 P * n 的汉明球的体积，该体积约为 2^{n * H₂(P)}。

因此，每个 D_X 的体积至少约为 2^{n * H₂(P)}。由于整个空间 {0,1}^n 被这些互不相交的 D_X 区域所划分，因此我们能容纳的 D_X 区域数量（即可编码的消息数 K）最多为总空间体积除以每个 D_X 的最小体积。

计算可得，码 C 的大小最多约为 2^{n * (1 - H₂(P))}。因此，码率 R = (log₂ |C|) / n 最多约为 1 - H₂(P)。通过仔细处理证明中的*似和常数，最终可以得出：如果失败概率小于 1/2，则码率 R ≤ 1 - H₂(P) + ε。这就完成了第二部分的证明概述。

与最坏情况纠错的联系

这个定理及其证明可能让您联想到汉明界。确实，这个结果基本上与汉明界完全对应。

为了将随机错误与最坏情况错误的结果放在一起比较，我们可以绘制下图（通常横轴是相对距离 δ，这里换成了错误比例 P。请注意，对于最坏情况错误，一个距离为 Δ 的码可以纠正最多 Δ/2 比例的错误，因此从 δ 到 P 的转换需要将所有值除以2）。

汉明界（红色虚线）是针对最坏情况错误的不可实现性结果。它表明，对于纠正 P 比例最坏情况错误的构造，其码率不能优于这条曲线。
香农定理（蓝色实线）表明，对于随机错误，完全相同的界限也成立。我们无法获得比这更好的构造。
然而，与最坏情况错误情形不同的是，这个界限是可达的。香农定理指出，存在（可能是非高效的）构造可以达到或接*这个界限。

这与最坏情况错误形成了鲜明对比。对于最坏情况错误，我们有汉明界这样的不可实现性结果，以及吉尔伯特-瓦尔沙莫夫界和乍博洛夫界这样的可实现性结果，但它们之间存在一个巨大的“未知区域”。而对于随机错误，不存在这种不确定性。曲线 1 - H₂(P) 就是确切的答案，即二进制对称信道的容量。我们无法获得比这更好的速率，但可以无限接*它。

遗留问题与下节预告

这个结果很简洁，但也自然引出一个问题：关于效率。我们刚刚概述的定理是一个存在性结果，并未讨论高效算法。那么，对于随机错误的高效算法呢？我们是否会遇到类似最坏情况错误那样的效率鸿沟，还是能够达到这个 1 - H₂(P) 的界限？我们将在下一个视频中回答这个问题。

总结

本节课中，我们一起学*了香农关于二进制对称信道的噪声信道编码定理。我们正式定义了信道容量，并概述了定理的证明，了解到二进制对称信道的容量为 1 - H₂(P)。这个结果清晰地划分了可靠通信的可能与不可能区域，并与最坏情况纠错中的汉明界相联系，揭示了随机错误模型下通信极限的完整图景。

032：BSC的高效算法 🚀

在本节课中，我们将学*如何通过级联码，使用高效算法在二进制对称信道上达到信道容量。我们将证明一个核心定理：对于任意参数P和ε，存在一个显式的二进制线性码，其速率接*信道容量，并且具有高效的编码与解码算法。

定理概述 📋

对于任意介于0和1/2之间的P，以及任意介于0和1 - H(P)之间的ε（其中H(P)是二进制熵函数，代表参数为P的BSC的信道容量），以及任意足够大的n，存在一个二进制线性码C ⊆ F₂ⁿ，其速率至少为1 - H(P) - ε。这意味着该码在BSC上几乎达到了容量。此外，该码满足以下条件：

C是显式码，可在多项式时间内构造。
具有高效的编码算法，编码时间为O(n²)。
具有高效的解码算法，解码时间为多项式时间加上一个与n成线性关系的项，且解码失败概率在n上呈指数级小。

级联码框架 🧩

为了证明这个定理，我们将使用级联码。级联码包含一个内码C_in和一个外码C_out。我们需要管理许多参数，以下是参数表：

参数	描述	设定/目标
γ	待定参数	稍后确定
C_in	内码（二进制）	维度k_in，码长n_in
C_out	外码（字母表大小为2^{k_in})	维度k_out，码长n_out
R_in	内码速率	≈ 1 - H(P) - ε/2
R_out	外码速率	≈ 1 - ε/2
T_in	内码解码时间	稍后确定
T_out	外码解码时间	稍后确定
P_fail_in	内码在BSC上的失败概率	≤ γ/2
δ_out	外码距离	= 2γ

上一节我们介绍了定理和级联码的基本框架，本节中我们来看看级联码的速率如何满足要求。

速率分析 📈

假设我们能获得具有上述速率的内码和外码，那么级联码的速率R_concatenated为两者速率的乘积：
R_concatenated = R_in * R_out = (1 - H(P) - ε/2) * (1 - ε/2)
展开后可以验证，该值至少为1 - H(P) - ε。因此，在速率方面我们已经达到了定理的要求。

解码算法与时间分析 ⏱️

现在，我们来讨论将使用的解码算法及其时间分析。这个算法与我们之前讨论应对最坏情况错误时的级联码解码算法类似，但对于随机错误，它可以直接工作。

以下是解码算法的步骤：

输入：接收到的、被BSC损坏的级联码字。我们将其按内码块长度分块，得到y₁, y₂, ..., y_{n_out}。
内码解码：对每个块y_i，运行内码C_in的解码器，得到解码结果y_i‘。理想情况下，大多数块能被正确解码。
重组外码字：将所有y_i‘组合起来，并将其视为外码C_out字母表上的一个接收向量y‘。
外码解码：对外码向量y‘运行外码C_out的解码器，最终得到原始消息。

以下是该算法的时间复杂度：

解码时间：O(n_out * T_in(n_in) + T_out(n_out))。其中第一项源于需要运行n_out次内码解码，第二项是运行一次外码解码。
编码时间：我们将选择内码为线性码，因此整个级联码也是线性的。线性码的编码只需乘以生成矩阵，因此编码时间为O(n²)，满足定理要求。

解码失败概率分析 📉

接下来，我们分析该解码算法的失败概率。我们设定外码C_out的距离为2γ，内码C_in在BSC上的解码失败概率至多为γ/2。

解码算法失败的概率，至多是“被内码解码器错误解码的块数超过 γ * n_out”的概率。因为如果错误解码的块数不超过γ * n_out，那么外码接收向量y‘中错误的符号数就不超过γ * n_out，这小于外码距离2γ的一半，因此外码解码器可以成功纠正这些错误。

为了量化这个概率，我们定义随机变量X_i：如果第i个块被错误解码，则X_i=1，否则为0。根据内码性质，P(X_i = 1) ≤ γ/2。由于BSC信道对各比特的干扰是独立的，因此这些X_i也相互独立。

解码失败的概率满足：
P(解码失败) ≤ P( Σ_{i=1}^{n_out} X_i > γ * n_out )
注意，γ * n_out至少是随机变量和ΣX_i的期望值E[ΣX_i] ≤ (γ/2) * n_out的两倍。

此时，我们可以使用切尔诺夫界来估计这个尾概率。切尔诺夫界指出，对于独立随机变量和，其值超过期望值两倍的概率呈指数衰减：
P( ΣX_i > 2 * E[ΣX_i] ) ≤ exp( - (γ * n_out) / 6 )
因此，解码失败的概率至多为exp( -Ω(γ * n_out) )。

内码与外码的选择 🔍

在分析了算法框架和性能之后，我们需要具体选择内码和外码。

内码C_in的选择

对于内码，我们将通过穷举搜索找到一个好的线性码。一个理论依据是：一个随机线性码能以高概率在BSC上达到容量。更精确地说，一个速率为1 - H(P) - ε的随机线性码，在BSC上的失败概率约为2^{-Ω(ε² * n)}。

基于此，为了满足内码失败概率≤ γ/2的要求，我们需要选择内码维度k_in满足：
k_in = Θ( log(1/γ) / ε² )

构造时间：穷举所有可能的生成矩阵，需要时间2^{O(n_in²)}。由于n_in = O(k_in)，这可以写为2^{O(log²(1/γ) / ε⁴)}。
解码时间：通过穷举搜索寻找最*码字，解码时间T_in为2^{O(k_in)} = 2^{O(log(1/γ) / ε²)}。

外码C_out的选择

我们不会直接使用里德-所罗门码，因为那会导致外码码长n_out = 2^{k_in}，从而使整体构造时间成为最终码长n的拟多项式时间，并且γ无法取为常数。

取而代之，我们将使用之前在Zyablov边界中构造的级联码。具体来说，我们以一个里德-所罗门码为外码，以一个良好的二进制线性码为内码，构造一个级联码。然后，我们调整这个级联码的分块大小，使其字母表大小恰好为2^{k_in}，以便与我们选择的内码C_in进行级联。

这个构造的外码C_out具有以下性质：

速率：R_out ≥ 1 - O( √γ * log(1/γ) )
距离：δ_out = 2γ（通过构造保证）
解码时间T_out：多项式时间（基于之前的构造）。
构造时间：多项式时间。

我们需要外码速率约为1 - ε/2。令1 - O( √γ * log(1/γ) ) = 1 - ε/2，可以推导出，选择γ = O(ε³)即可满足要求。

参数汇总与定理验证 ✅

现在，我们汇总所有参数选择，并验证定理的各个部分。

速率：如前所述，R_concatenated ≥ 1 - H(P) - ε。✅
编码时间：级联码是线性的，编码时间为O(n²)。✅
解码时间：
T_decode = O(n_out * T_in + T_out) = O(n * 2^{O(log(1/γ)/ε²)} + poly(n))
由于γ = O(ε³)，2^{O(log(1/γ)/ε²)}是一个仅依赖于ε的常数C_ε。因此，解码时间为poly(n) + C_ε * n。✅
构造时间：
T_construct = 2^{O(log²(1/γ)/ε⁴)} + poly(n_out)
同样，第一项是仅依赖于ε的常数，第二项是n的多项式。因此，构造时间为poly(n) + C‘_ε。✅
失败概率：
P_fail ≤ exp( -γ * n_out / 6 ) = exp( -C‘’_ε * n )
其中C‘’_ε是仅依赖于ε的常数。因此，失败概率为2^{-Ω_ε(n)}，在n上指数级小。✅

至此，我们完成了定理的证明。

总结与展望 🎯

本节课我们一起学*了如何在二进制对称信道上使用级联码实现达到容量的高效通信。

核心成果：我们证明了一个显式的、可高效编码和解码的二进制线性码，可以几乎达到BSC的信道容量。这与处理最坏情况错误时复杂的结果形成了鲜明对比。
关键工具：我们使用了级联码框架，内码通过随机编码论证找到，外码采用了基于Zyablov边界的构造，并利用切尔诺夫界分析了随机错误下的解码失败概率。
意义：对于BSC上的随机错误，香农定理给出的容量界限同时是不可突破的极限、非构造性的存在证明以及可高效实现的构造性证明。这为实际通信系统设计提供了坚实的理论基础。

需要指出的是，我们的构造中，为了达到任意小的ε，所需的码长n会非常大（与ε的某种负指数幂相关）。在实际中，可以使用极化码等更先进的构造来改善对ε的依赖关系。但无论如何，本节课展示的理论框架揭示了在随机错误模型下实现信道容量的美妙可能性。

033：列表译码

在本节课中，我们将学*一个名为“列表译码”的新主题。

概述 📖

列表译码是传统“唯一译码”概念的一种推广。在唯一译码中，接收方需要从接收到的、可能包含错误的码字中，精确地恢复出发送方发送的原始信息。而在列表译码中，接收方被允许输出一个包含多个候选信息的“短列表”，只要原始信息包含在这个列表中即可。这种放宽的要求，使得通信双方能够容忍更多的错误。

列表译码的定义 📐

设 P 是一个介于 0 和 1 之间的参数，L 是一个大于等于 1 的整数。

我们说一个码 C ⊆ Σ^n 是 (P, L) 列表可译的，如果对于所有 y ∈ Σ^n，满足以下条件的码字 c ∈ C 的数量最多为 L：

条件：码字 c 与接收字 y 的相对距离不超过 P。

在这个定义中，L 被称为列表大小，P 被称为列表译码半径（有时简称为半径）。

理解定义：几何视角与通信视角 🔍

这个定义可以从两个角度来理解：几何视角和通信（Alice-Bob）视角。

几何视角

假设 Σ^n 是我们的整个空间，码 C 是其中的一些点（码字）。定义表明，如果码 C 是 (P, L) 列表可译的，那么对于空间中的任意一点 y，以 y 为中心、半径为 P * n 的汉明球内，所包含的码字数量不会超过 L。

通信视角（Alice-Bob模型）

在通信模型中，发送方 Alice 和接收方 Bob 之间有一个噪声信道。我们假设这是一个对抗性信道，最多可以损坏 P 比例的符号。

Alice 将消息 x 编码为码字 c 并发送。
Bob 接收到一个被损坏的码字 y。
在列表译码中，Bob 的任务不是精确恢复 x，而是输出一个短列表 ℒ = {x₁, x₂, ..., x_L}，并保证 Alice 发送的原始消息 x 在这个列表中。

从几何视角来看，Bob 可以通过找出所有落在以 y 为中心、半径为 P 的球内的码字（最多 L 个），来构造这个列表 ℒ。

列表译码与唯一译码的关系 🔗

列表译码推广了我们之前学*的唯一译码。实际上，当列表大小 L = 1 时，列表译码就退化为唯一译码。

关系公式：一个码是 (P, 1) 列表可译的，等价于 说该码的最小距离至少为 2P。

我们之前已经深入研究了如何获得良好的最小距离。因此，可以将列表译码视为当 L 大于 1 时，对唯一译码问题的一种推广。

为什么研究列表译码？ 🤔

研究列表译码主要有以下几个原因：

以下是几个关键原因：

更高的纠错能力：正如我们将在后续课程中看到的，如果允许 Bob 返回一个短列表，Alice 和 Bob 能够容忍的错误比例（P）可以显著提高。在某些情况下，即使 Bob 只需返回一个大小固定的列表，他们也能容忍接*两倍的错误。这在唯一译码的背景下是非常有用的。
实际应用场景：Bob 可能拥有一些额外的“边信息”来帮助他从列表中确定唯一答案。或者，在某些密码学假设下，Alice 可以将这些边信息作为码字的一部分发送给 Bob。
广泛的组合学应用：列表可译码本身是一种非常有用的组合对象。它在伪随机性、计算复杂性理论和算法设计等领域都有重要应用。我们可能在后续视频中看到一些这样的联系。

核心研究问题 ❓

对于列表译码，我们可以提出与唯一译码类似的核心问题：

以下是三个主要的研究方向：

理论极限：在列表大小 L、码率 R 和列表译码半径 P 之间，可能存在的最佳权衡关系是什么？
显式构造：如何通过显式的编码构造来达到（或接*）这个最佳权衡？
高效算法：如何设计高效的列表译码算法？即，Bob 在收到字 y 后，如何高效地恢复出所有在半径 P 范围内的（最多 L 个）码字？

挑战与机遇 ⚡

在唯一译码（即 L = 1）且针对最坏情况错误时，我们已经看到，即使是第一个问题（确定 P 和 R 的最佳权衡）也非常困难。

对于二进制码，P 和 R 在 L=1 时的最佳权衡关系至今仍未完全解决。因此，将这个问题推广到 L > 1 并期望得到更好的结果，看起来似乎是在自找麻烦。

但事实证明，当允许 L 稍大一些（例如一个较大的常数，或随 n 缓慢增长）时，我们实际上可以精确确定 P 和 R 之间的最佳可能权衡关系。这个最佳权衡曲线，看起来就像我们在之前关于随机错误视频中看到的最佳权衡曲线。

这个关于列表译码中 P 和 R 最佳权衡的结论，被称为列表译码容量定理。我们将在下一个视频中详细学*它。

总结 📝

本节课我们一起学*了列表译码的基本概念。我们了解到列表译码是唯一译码的推广，它允许译码器输出一个候选列表，从而有可能容忍更多的错误。我们给出了列表可译码的正式定义，并从几何和通信两个角度进行了解释。最后，我们探讨了研究列表译码的意义，并引出了其核心研究问题及著名的列表译码容量定理，为后续学*奠定了基础。

034：列表译码容量定理 📊

在本节课中，我们将学*列表译码容量定理。该定理精确地刻画了列表可译码的码在码率 R 和译码半径 P 之间的最佳权衡关系。

定理概述

列表译码容量定理非正式地指出，列表译码的容量，即码率 R 与半径 P 之间可能的最佳权衡，由公式 R = 1 - H_Q(P) 给出，其中 H_Q 是 Q 元熵函数。

更正式地，我们有以下定理。

令 Q ≥ 2，令 0 < P < 1 - 1/Q，并令 ε > 0。则以下两点成立。

第一点：如果码率 R 略低于阈值 1 - H_Q(P)，例如 R = 1 - H_Q(P) - ε，那么存在具有该码率、译码半径达到 P 的良好列表可译码。具体而言，存在一个 Q 元码族，它们是 (P, O(1/ε)) 列表可译的。这里的 P 是列表译码半径，O(1/ε) 是列表大小 L。这表明，如果码率不太大，仅略低于此容量，那么存在在该码率下的码，使得任何半径为 P * N 的汉明球内最多包含 O(1/ε) 个码字。

第二点：如果码率略高于该容量，即 R = 1 - H_Q(P) + ε，那么任何具有半径 P 和列表大小 L 的列表可译码族，其列表大小 L 必须是指数级大的，至少为 Q^(Ω(n))。这第二点表明，如果码率过大，仅略高于容量，那么我们无法期望在列表译码能力上有任何像样的保证。在任何半径为 P * n 的汉明球内，总是会有指数数量的码字。

在证明这个陈述之前，让我们先解释一下这里的数量。它可能看起来有些熟悉。让我们回到之前看到的图。这里，P（错误比例）在 x 轴上，R（码率）在 y 轴上。我们看到列表译码容量定理给出的曲线 1 - H_Q(P)（此图针对 Q=2）与二元对称信道的汉明界和香农定理的曲线完全相同。

这里的启示是：如果鲍勃被允许在最坏情况错误的设置下返回一个短列表，那么爱丽丝和鲍勃可以做到与处理随机错误时一样好，尽管错误是最坏情况的。具体来说，我们可以让 P 无限接* 1/2，同时仍然保持正的码率，并拥有一个良好的列表可译码。

另一方面，普洛特金界指出，对于最坏情况错误，如果我希望 P 那么大（实际上，任何大于 1/4 的值），那么我就无法实现唯一译码。至少对于二元码，无法从 P 比例的最坏情况错误中唯一译码。

因此，这表明，如果爱丽丝和鲍勃愿意做出牺牲，只返回一个很短的列表，他们就能在可容忍的错误量方面获得巨大的增益。

证明第一部分：存在性

现在，让我们来证明列表译码容量定理。我们将从第一点开始，即存在良好的列表可译码。

我们将使用概率方法进行证明。我们将随机选取一个完全随机的码，并证明它以高概率满足要求。

令 Enc: Σ^K → Σ^N 为一个完全随机的编码映射。我们希望证明，只要码率略低于 1 - H_Q(P)，那么码 C（即这个随机编码映射的像）就是 (P, L) 列表可译的，且 L 不会太大。

为了证明这一点，让我们思考一下“不是列表可译的”意味着什么。这意味着存在某个集合 Λ，包含 L+1 条消息，它们全部被映射到某个汉明球内。也就是说，假设这里有 L+1 条消息，我的码 C（这个随机编码映射的像）在列表译码上失败，如果所有这些消息都映射到某个接收字 y 附*的点。

更详细地说，让我们固定这样一个 Λ 和这样一个 y。现在，计算这个坏事件发生的概率。任何一点落入这个球的概率，就是球的体积除以整个空间的体积。由于编码映射是完全随机的，这个点落入球的事件、那个点落入球的事件等等，都是独立的。因此，我可以计算所有这些点都落入球的概率，只需将这个概率提升到 L+1 次方。

现在，我们可以使用汉明球体积的便捷*似公式，得出这个概率小于等于 2^{-n * (1 - H_Q(P)) * (L+1)}。

现在我们需要对所有可能的 Λ 和所有可能的 y 进行并集界限。所以，存在这样的 Λ 和 y 使得坏事件发生的概率，根据并集界限，至多是：C(Q^K, L+1)（可能的集合 Λ 的数量）乘以 Q^N（可能的 y 的数量）再乘以这个概率。

现在，我将用 Q^{K*(L+1)} 来界定这个二项式系数 C(Q^K, L+1)。同时，我将利用 K = R * n 这一事实，将整个式子界定为 Q^{n * (R + 1 - H_Q(P)) * (L+1) + 1}。

现在，我们可以利用码率不太大的假设，说这个式子至多是 Q^{n * (-ε) * (L+1)}。只要 L 足够大，这就是 Q^{-Ω(n)}。具体来说，我们可以取 L = O(1/ε)，并且 L 仍然足够大。

因此，我们得出结论：一个随机码 C 以高概率是 (P, L) 列表可译的，特别是，这样的码存在。这就证明了列表译码容量定理的第一点。

证明第二部分：下界

上一节我们证明了良好列表可译码的存在性。本节中，我们来证明第二点，即任何码率稍大的码都必须有非常大的列表大小。也就是说，必须存在某个汉明球包含大量码字。

假设 C 就是这样一个码，其码率略大于 1 - H_Q(P)。我们需要证明，存在某个 y，使得以 y 为中心、半径为 P * N 的汉明球内包含大量码字。

我们的策略再次使用概率方法。我们将随机选择一个 y，并证明这个数量的期望值很大。这将意味着存在某个 y 使得这个数量很大。

为此，让我们考虑固定码 C 中的某个特定码字 c。现在，计算在随机选择 y 的情况下，c 落在这个汉明球内的概率。这里 c 是固定的，汉明球的中心是随机的，但我们也可以反过来思考：将汉明球视为固定的，而 c 是随机的。那么，这个事件发生的概率再次是汉明球的体积除以整个空间的体积。和之前一样，这大约是 Q^{-n * (1 - H_Q(P))}。

这只是针对单个码字。但现在我们可以利用这一点，结合期望的线性性质，来计算这个数量的期望值。我们有：随机 y 对应的汉明球内码字数量的期望值，根据期望的线性性质，等于码中所有码字 c 的概率（关于随机 y）之和。我们刚刚计算过，这个概率大约是 |C| * Q^{-n * (1 - H_Q(P))}。

|C| 有多大？C 的大小是 Q^K，即 Q^{R*n}。我们假设 R 至少这么大。所以，这个期望值至少是 Q^{n * (1 - H_Q(P) + ε)} * Q^{-n * (1 - H_Q(P))}。现在一些项抵消了，这正好等于 Q^{ε * n}，这确实是 Q^{Ω(n)}，正如我们所声称的。

这表明，在随机 y 的期望下，以 y 为中心的汉明球包含指数级多的码字，特别是，这样的 y 必然存在。这就证明了第二点，从而完成了整个定理的证明。

总结与展望

本节课中，我们一起学*了列表译码容量定理。该定理告诉我们，在假设列表大小是一个足够大的常数的情况下，列表译码在码率 R 和错误半径 P 之间的正确权衡关系。

然而，正如我们刚刚看到的，这个证明绝对不是构造性的，也没有提供高效的算法。在下一个视频中，我们将开始探讨如何通过显式构造来实现这个目标，或者至少实现一些非平凡的结果。

035：Johnson界

在本节课中，我们将学*Johnson界。该定理指出，任何具有良好距离的码，也具有良好的列表可译性。

上一节我们介绍了列表译码容量定理，本节中我们来看看Johnson界如何从距离的角度给出列表可译性的保证。

Johnson界定理陈述

设 J_Q(Δ) 为以下量：

J_Q(Δ) = (1 - 1/Q) * (1 - √(1 - QΔ/(Q-1)))

令 C ⊆ Σ^N 是一个字母表大小为 Q、相对距离至少为 Δ 的码。

那么，Johnson界定理指出：如果列表译码半径 P 小于 J_Q(Δ)，则码 C 是半径为 P、列表大小为 Q * Δ * N^2 的列表可译码。

从定性角度看，Johnson界表明：如果一个码具有良好的距离，那么它就具有良好的列表可译性。我们注意到，这个被称为Johnson半径的量 J_Q(Δ) 是随 Δ 增大而增大的。这意味着，随着距离 Δ 变大，我们能保证列表大小可控的译码半径 P 也会变大。虽然我们可能希望列表大小比 N^2 更好（例如常数级），但对我们而言，任何关于 N 的多项式大小的列表都被认为是“可控的”。

与列表译码容量定理的定量比较

从定量角度看，Johnson界的表达式有些复杂。在本节剩余部分，我们将尝试定量比较Johnson界与上一节学*的列表译码容量定理。我们不会在本视频中证明Johnson界，但可以查阅讲义了解相关证明。现在，我们专注于理解这个量的含义以及它与已知结论的关系。

让我们从二进制情况开始，即 Q = 2。

二进制情况 (Q=2)

列表译码容量定理指出：如果码率 R < 1 - H_2(P) - ε，则存在一个码率为 R、列表大小为 O(1/ε) 的二进制码，它是 (P, L) 列表可译的。为了便于定量比较，我们暂时不关心具体的列表大小 L，只要它是多项式大小即可，并用星号(*)标记为“可控列表大小”。

Johnson界在二进制情况下的表述是：如果 P < 1/2 * (1 - √(1 - 2Δ))，那么任何距离为 Δ 的二进制码都是 (P, L) 列表可译的，且列表大小 L 可控。

为了比较这两个定理，我们需要将Johnson界也转化为一个关于码率 R 的陈述。我们可以利用已知的最佳码率-距离关系，即Gilbert-Varshamov界。

以下是具体步骤：

Gilbert-Varshamov界指出，存在一个码率为 R 的码，其相对距离 Δ 满足 R = 1 - H_2(Δ)，或者说 Δ = H_2^{-1}(1 - R)。
将这个 Δ 的表达式代入Johnson界关于 P 的条件中。
然后，我们解出 R，得到一个形如“如果码率 R 足够小，则存在列表可译码”的陈述。

经过推导，我们得到：如果 R < 1 - H_2(2P(1-P))，则存在一个码率为 R 的二进制码，它是 (P, L) 列表可译的，且列表大小 L 可控。

现在，我们可以直接比较这两个陈述了，因为它们都具有“如果码率不太大，则存在列表可译码”的形式。

让我们将这两条曲线绘制在一起进行比较：

列表译码容量定理给出的曲线是：R = 1 - H_2(P)
Johnson界（结合GV界）给出的曲线是：R = 1 - H_2(2P(1-P))

正如预期，Johnson界给出的结果比列表译码容量定理要差。这不可能更好，因为容量定理既是存在性结果也是不可能性结果。然而，Johnson界确实允许我们将列表译码半径 P 一直提高到 1/2 并仍然获得正码率，这与容量定理一致。此外，Johnson界在某种意义上更通用，因为它不仅是一个存在性结果，还提示了如何实现：我们只需要构造一个具有良好距离的码。

大字母表情况 (Q 很大)

对于更大的 Q，我们可以重复这个练*。现在考虑 Q 很大（例如大于等于 N）的参数范围。

在这种设定下：

列表译码容量定理*似为：如果 R < 1 - P，则存在一个 Q 元码，它是 (P, L) 列表可译的。
Johnson半径*似为：J_Q(Δ) ≈ 1 - √(1 - Δ)。

同样，为了比较，我们需要将Johnson界转化为关于码率的陈述。对于大字母表，我们不需要借助Gilbert-Varshamov界，因为我们有能达到最佳码率-距离权衡的码，即Reed-Solomon码。

以下是具体步骤：

对于Reed-Solomon码，有 R = 1 - Δ。
将 Δ = 1 - R 代入*似的Johnson半径条件 P < 1 - √(1 - Δ)。
解出 R，得到与容量定理可比较的形式。

经过推导，我们得到：如果 R < (1 - P)^2，则存在一个码率为 R 的 Q 元Reed-Solomon码，它是 (P, L) 列表可译的，且列表大小 L 可控。

再次绘制这两条曲线进行比较：

列表译码容量定理（大Q）给出的是一条直线：R = 1 - P
Johnson界（结合RS码）给出的是一条抛物线：R = (1 - P)^2

我们再次看到，Johnson界不如列表译码容量定理好。然而，它也有一些优点：

它和容量定理一样，能保证列表可译性一直达到 P = 1 - 1/Q（在大Q下接*1）。
列表译码容量定理是非构造性的（使用了随机码），而对于大Q，达到Johnson界曲线的码正是我们熟悉的Reed-Solomon码，因此我们有了明确的构造。
下一讲，我们将学*如何对Reed-Solomon码进行高效的列表译码，直至这个界。

总结

本节课中我们一起学*了Johnson界。该定理将码的距离属性与列表可译性联系起来，指出任何具有良好相对距离 Δ 的码，在小于 J_Q(Δ) 的译码半径 P 下都是列表可译的，且列表大小是多项式级的。我们将其与列表译码容量定理进行了比较，发现虽然Johnson界给出的码率-半径权衡不如容量定理最优，但它具有构造性明确的优点（特别是对于大字母表，可直接使用Reed-Solomon码），并且同样允许译码半径接*理论最大值。这为实际构造列表可译码提供了重要的指导。

036：关于二元多项式的有用事实 📚

在本节课中，我们将学*关于二元多项式的一些关键事实。这些知识是后续设计里德-所罗门码列表解码算法的基础。

什么是二元多项式？ 🤔

首先，我们来定义什么是二元多项式。在域 FQ 上的一个二元多项式，是指一个包含两个变量 X 和 Y 的多项式 Q。我们用符号 FQ[X, Y] 来表示所有这类二元多项式的集合。

这些多项式具有以下形式：

Q(X, Y) = Σ α_ij * X^i * Y^j

其中，系数 α_ij 属于域 FQ。

关于二元多项式，有几个重要的术语：

X 次数 (mx)：指多项式中 X 变量的最高次数。
Y 次数 (my)：指多项式中 Y 变量的最高次数。
单项式的总次数：对于单项式 X^i * Y^j，其总次数为 i + j。
多项式的总次数：指多项式中所有出现的单项式的最大总次数。

将二元多项式视为一元多项式 🔄

上一节我们介绍了二元多项式的定义，本节中我们来看看它的一个重要视角。对于域 FQ 上的任意二元多项式 Q(X, Y)，我们实际上可以将其视为一个以 Y 为变量的一元多项式，而其系数本身又是以 X 为变量的一元多项式。

也就是说，我们可以将 Q(X, Y) 写成如下形式：

Q(X, Y) = Σ_{j=0}^{my} Q_j(X) * Y^j

其中，每个 Q_j(X) 是一个以 X 为变量的一元多项式，其次数至多为 mx。

以下是一个简单的例子：
假设 Q(X, Y) = (X^2 - Y) * (X - Y)。
展开后，我们可以按照 Y 的幂次合并同类项，得到：
Q(X, Y) = X^3 * Y^0 + (-X - X^2) * Y^1 + 1 * Y^2
此时，Q_0(X) = X^3, Q_1(X) = -X - X^2, Q_2(X) = 1。

这种看待二元多项式的方式非常有用，因为一元多项式有许多良好的性质，当我们以这种方式看待二元多项式时，这些性质同样适用。

一个关键事实及其推论 🧠

基于上述视角，我们可以得到一个关键事实及其重要推论。

关键事实：
假设 Q(X, Y) 是域 FQ 上的一个二元多项式，F(X) 是一个以 X 为变量的一元多项式。
如果 Q(X, F(X)) ≡ 0（即恒等于零多项式），那么这等价于说多项式 (Y - F(X)) 可以整除 Q(X, Y)。

这类似于一元多项式的情况：如果 α 是 Q(Y) 的根（即 Q(α) = 0），那么 (Y - α) 整除 Q(Y)。这里只是将常数根 α 替换成了多项式 F(X)。

举例说明：
沿用之前的例子 Q(X, Y) = X^3 - (X + X^2)Y + Y^2。
如果我们代入 Y = X^2，得到 Q(X, X^2) = X^3 - X^3 - X^4 + X^4 = 0。
根据上述事实，这意味着 (X^2 - Y) 整除 Q(X, Y)，这确实是成立的，因为 Q(X, Y) 原本就是由 (X^2 - Y) * (X - Y) 定义的。

推论：
设 Q(X, Y) 是域 FQ 上的一个二元多项式，其次数 deg_y(Q) = D（即 Y 的次数为 D）。
那么，最多存在 D 个多项式 F(X)，使得 Q(X, F(X)) ≡ 0。

这个推论可以理解为：低次（指 Y 的次数）的二元多项式没有“太多”的“根”（这里“根”指的是代入后使多项式恒为零的多项式 F(X)）。

推论证明（基于关键事实）：
假设存在超过 D 个（比如 D+1 个）不同的多项式 F_i(X) 使得 Q(X, F_i(X)) ≡ 0。
根据关键事实，每个 (Y - F_i(X)) 都整除 Q(X, Y)。因此，它们的乘积 Π_{i=1}^{D+1} (Y - F_i(X)) 也整除 Q(X, Y)。
然而，这个乘积多项式的 Y 次数是 D+1，而被除数 Q(X, Y) 的 Y 次数仅为 D，这产生了矛盾。因此，假设不成立，这样的多项式 F(X) 最多只有 D 个。

总结 📝

本节课中我们一起学*了关于二元多项式的几个核心概念和有用事实：

我们定义了二元多项式及其相关术语（次数等）。
我们学会了将二元多项式 Q(X, Y) 重新组织为以 Y 为变量、系数为 X 的多项式的一元多项式形式。
我们掌握了一个关键事实：如果 F(X) 是 Q(X, Y) 的“根”，那么 (Y - F(X)) 整除 Q(X, Y)。
基于此，我们推导出一个重要推论：一个 Y 次数为 D 的二元多项式，最多有 D 个多项式“根” F(X)。

这些结论为后续理解里德-所罗门码的列表解码算法奠定了重要的理论基础。在接下来的课程中，我们将利用这些工具来设计具体的解码算法。

037：列表解码RS码的问题 📚

在本节课中，我们将学*列表解码里德-所罗门码的问题设定。我们将了解如何将解码问题转化为寻找与接收到的数据点高度匹配的低次多项式，并设定一个可实现的目标：解码到约翰逊界。

问题设定

上一节我们介绍了列表解码的基本概念，本节中我们来看看针对里德-所罗门码的具体问题。

假设这个大的区域代表所有可能的码字空间 F_qⁿ，而这些红点代表某个里德-所罗门码的码字。设 C 为该里德-所罗门码，其定义如下：

C = { (f(α₁), f(α₂), ..., f(αₙ)) | f ∈ F_q[x], deg(f) < k }

其中，α₁, ..., αₙ 是有限域 F_q 中 n 个不同的元素，作为评估点。该码的码长为 n，维度为 k，码率为 R = k/n。

列表解码问题可以描述为：给定一个接收到的字 y = (y₁, y₂, ..., yₙ) ∈ F_qⁿ，我们希望高效地找到所有与 y 足够接*的码字 c ∈ C。

解码半径的选择

那么，“足够接*”具体指多*呢？让我们通过一个图示来理解。

我们知道，里德-所罗门码的相对最小距离是 1 - R。如果我们观察一个半径为 ½(1 - R) 的汉明球，根据唯一解码理论，该球内最多只包含一个码字。

列表解码的目标是观察一个稍大的球，并希望这个球内的码字数量不会太多，以至于我们仍然可以高效地列出它们。这个球的半径不能太大，否则球内可能包含指数级数量的码字，我们无法期望一个多项式时间算法来输出它们。

约翰逊界为我们提供了一个合适的半径。它指出，如果我们观察一个半径为 1 - √R 的球，那么我们可以保证球内的码字数最多是多项式级别的。

因此，我们的目标设定如下：给定接收字 y，我们希望高效地找到所有满足以下条件的码字 c ∈ C：

Δ(y, c) ≤ 1 - √R

其中 Δ 表示相对汉明距离。

等价的多项式表述

上述问题可以等价地转化为一个多项式插值问题。

具体来说，给定 y，我们希望高效地找到所有次数小于 k 的多项式 f(x) ∈ F_q[x]，使得对于至少 √R * n 个索引 i，有：

f(αᵢ) = yᵢ

换句话说，我们寻找那些在足够多的评估点（比例至少为 √R）上与接收到的数据 y 一致的低次多项式。

如果能实现这个目标，我们就说可以高效地将里德-所罗门码列表解码到约翰逊界。

总结

本节课中我们一起学*了列表解码里德-所罗门码的问题框架。我们明确了目标：给定接收向量 y，在多项式时间内，找到所有与 y 的相对汉明距离在 1 - √R 以内的码字，这等价于寻找与 y 在至少 √R * n 个点上一致的低次多项式。在接下来的课程中，我们将探讨实现这一目标的具体算法。

038：苏丹算法

在本节课中，我们将学*一种用于列表解码里德-所罗门码的算法——苏丹算法。该算法虽然不能完全达到约翰逊界，但能让我们解码到远超半距离的错误，为后续改进奠定基础。

算法灵感：伯利坎普-韦尔奇算法的双变量视角

上一节我们介绍了伯利坎普-韦尔奇算法，它是一种能高效唯一解码里德-所罗门码至半距离的算法。本节中，我们来看看如何将其重新表述为双变量多项式形式，从而为列表解码提供灵感。

假设我们有一个里德-所罗门码，并接收到一个码字 Y ∈ F_q^n。伯利坎普-韦尔奇算法的第一步是找到两个多项式 E(x) 和 B(x)，使得对于所有 i ∈ [n]，满足：

E(α_i) * y_i = B(α_i)

其中，E(x) 是错误定位多项式，B(x) 等于 F(x) * E(x)，而 F(x) 是我们要找的原始编码多项式。

第二步是返回 F(x) = B(x) / E(x)。

为了将其推广到列表解码，我们可以用双变量多项式来等价地描述这个算法：

插值步骤：找到一个双变量多项式 Q(x, y)，其形式为 Q(x, y) = E(x) * y - B(x)，并满足对于所有 i，有 Q(α_i, y_i) = 0。
求根步骤：找到所有满足 Q(x, F(x)) ≡ 0（即恒等于零多项式）的 F(x)，并返回它们。

这种双变量视角为我们提供了更多的灵活性，因为我们可以放松对 Q(x, y) 形式的严格限制，允许其具有更一般的结构，这将有助于实现列表解码。

苏丹算法定理 📜

基于上述灵感，我们得到苏丹算法定理：

设 α_1, ..., α_n 是域 F_q 中互不相同的估值点，n 和 k 是固定参数。存在一个多项式时间算法（苏丹算法），对于任意输入 Y ∈ F_q^n，该算法返回一个列表 ℒ。此列表包含所有满足以下条件的多项式 F(x) ∈ F_q[x]：F(x) 与 Y 在超过 2√(nk) 个位置 i 上一致，即 F(α_i) = y_i。

这意味着我们可以列表解码到一个半径 ρ = 1 - 2√R，其中 R = k/n 是码率。虽然这尚未达到约翰逊界给出的 1 - √R，但已经远超半距离。我们将在下一节中看到如何改进它以达到约翰逊界。

苏丹算法步骤 🛠️

以下是苏丹算法的具体步骤，输入为接收到的码字 Y。

步骤一：插值

首先，我们需要找到一个双变量多项式 Q(x, y)。

以下是具体约束条件：

Q(x, y) 关于 x 的次数至多为 L。
Q(x, y) 关于 y 的次数至多为 n/L。
对于所有 i ∈ [1, n]，满足 Q(α_i, y_i) = 0。

其中，参数 L 被设定为 √(n * k)。与伯利坎普-韦尔奇算法的双变量版本相比，关键区别在于 Q(x, y) 的结构限制更宽松，它不必是 E(x)y - B(x) 的形式，只需满足上述次数约束即可。

步骤二：求根

第二步与之前描述的类似：

找出所有满足 Q(x, F(x)) ≡ 0（即恒等于零多项式）的多项式 F(x) ∈ F_q[x]，其次数小于 k。
返回这些 F(x) 的列表。

步骤一：如何实现插值？ 🤔

现在我们来解答第一个问题：如何高效地找到满足条件的多项式 Q(x, y)？

答案是：通过建立并求解线性方程组。我们将 Q(x, y) 的系数作为未知变量，将 Q(α_i, y_i) = 0 的条件作为线性约束。

以下是变量与约束数量的计算：

变量数量：等于 Q(x, y) 中单项式 x^i y^j（其中 i ≤ L, j ≤ n/L）的个数，即 (L+1) * (n/L + 1)。
约束数量：等于点的个数 n。

只要变量数量大于约束数量，就存在非零解。代入 L = √(nk) 计算：
(L+1) * (n/L + 1) = n + n/L + L + 1 > n
由于 n/L 和 L 均为正数，不等式成立。因此，我们可以通过求解这个线性系统来高效地完成步骤一。

步骤二：为何有效？ ✅

接下来解答第二个问题：为什么返回所有使 Q(x, F(x)) ≡ 0 的 F(x) 是一个好主意？这能解决我们的列表解码问题吗？

是的，这是有效的。我们可以证明，任何与接收码字 Y 在足够多位置上一致的正确多项式 F(x)，都会满足这个条件。

证明思路如下：

假设 F(x) 是一个次数小于 k 的多项式，并且它在超过 2√(nk) 个点 i 上满足 F(α_i) = y_i。
构造一个单变量多项式 R(x) = Q(x, F(x))。
分析 R(x) 的次数：根据 Q 的次数限制和 F 的次数，可证 deg(R) < L + k*(n/L) = 2√(nk)。
分析 R(x) 的根：在那些满足 F(α_i) = y_i 的点上，有 R(α_i) = Q(α_i, y_i) = 0。因此，R(x) 有超过 2√(nk) 个根。
一个非零多项式的根数不能超过其次数。这里 R(x) 的次数小于其根的数量，这迫使 R(x) 必须是零多项式，即 Q(x, F(x)) ≡ 0。

因此，任何与 Y 高度一致的正确编码多项式 F(x) 都会被步骤二返回。

步骤二：如何高效实现及列表大小 📏

最后，我们探讨如何高效执行步骤二，以及返回的列表会有多大。

首先，列表大小是受控的。根据之前课程中的一个有用结论，满足 Q(x, F(x)) ≡ 0 的多项式 F(x) 的数量，最多不超过 Q(x, y) 关于 y 的次数，即 n/L。

代入 L = √(nk)，得到最大列表大小为 √(n/k) = √(1/R)，其中 R 是码率。如果码率 R 是常数，那么列表大小也是一个常数，这对于高效算法至关重要。

关于如何高效地找到所有这些 F(x)，虽然本视频不深入讨论具体算法细节，但可以确信存在多项式时间的算法（例如，通过将问题转化为关于 F(x) 系数的线性系统，或使用特定的多项式因式分解技术）来完成这一“求根”步骤。

总结 📝

本节课中我们一起学*了苏丹算法，这是一种用于列表解码里德-所罗门码的强大工具。

我们首先从伯利坎普-韦尔奇算法的双变量多项式视角获得了灵感。
接着，我们介绍了苏丹算法定理，它允许我们解码到半径 ρ = 1 - 2√R 的错误。
然后，我们详细阐述了算法的两个核心步骤：插值（通过解线性系统找到双变量多项式 Q）和求根（找出所有使 Q(x, F(x)) ≡ 0 的 F(x)）。
我们证明了步骤一的可行性（变量数多于约束数），以及步骤二的有效性（正确的 F(x) 必然满足条件）。
最后，我们指出返回的列表大小是多项式有界的（最多 √(1/R) 个），并且步骤二可以在多项式时间内完成。

苏丹算法让我们能够列表解码到远超半距离，虽然尚未达到理论极限的约翰逊界，但已经是一个重大突破。在下一节课中，我们将看到如何改进这个算法，最终达到约翰逊界。

代数编码导论：4：Guruswami-Sudan算法

在本节课中，我们将学*Guruswami-Sudan算法。这是对上一节介绍的Sudan算法的改进，使我们能够高效地列表解码Reed-Solomon码，直至达到Johnson界。

在上一节中，我们介绍了Sudan算法，它能高效地列表解码Reed-Solomon码，解码半径接*Johnson界。本节中，我们将看到一种名为Guruswami-Sudan算法的改进版本，它能将解码半径完全提升至Johnson界。

首先，我们简要回顾一下高效解码Reed-Solomon码的背景。假设我们收到一个码字y。Berlekamp-Welch算法允许我们高效地进行唯一解码，其解码半径可达距离的一半，对于Reed-Solomon码，即(1 - R)/2。在这个半径内，保证最多只有一个码字，Berlekamp-Welch算法可以找到它。

在上一节中，我们看到的Sudan算法能够高效地列表解码，其解码半径更大，达到1 - 2√R。当码率R较小时，这个半径大于唯一解码半径。根据Johnson界，在这个更大的半径球内，最多只有多项式数量的码字，Sudan算法提供了一种高效找到它们的方法。

本节中，我们将尝试改进Sudan算法。我们将分两步进行。第一步，我们将看到一个用于教学目的的算法，它可以将解码半径略微提高到1 - √(2R)。第二步，我们将进一步将半径提高到1 - √R，即Johnson界。这最终的算法就是Guruswami-Sudan算法。

第一步改进：引入(1, k)度

我们的第一个改进，目标是达到半径1 - √(2R)，其关键在于改变我们衡量双变量多项式Q的“度”的方式。

为此，我们做出以下定义。

定义：单项式x^i y^j的 (1, k)度 定义为 i + k * j。

类似地，双变量多项式Q的 (1, k)度 定义为出现在该多项式中任何单项式的(1, k)度的最大值。

现在，基于这个定义，以下是达到1 - √(2R)的改进算法。与Sudan算法一样，它包含两个步骤：插值步骤和求根步骤。

步骤1：插值
找到一个双变量多项式Q(x, y)，使其(1, k)度满足：
(1, k)-deg(Q) ≤ √(2 * k * n)
同时，要求对于所有i从1到n，满足：
Q(α_i, y_i) = 0

步骤2：求根
返回所有满足Q(x, f(x)) ≡ 0的多项式f。

接下来，我们简要分析这个算法。证明思路与Sudan算法基本相同。

首先，我们需要证明步骤1是可行的（即这样的Q存在且可高效求解），然后证明步骤2是有效的。

可行性分析（步骤1）
我们需要证明，满足上述(1, k)度限制的多项式Q，其系数数量（变量数）大于约束条件数量。

变量数：一个(1, k)度至多为D的多项式，其系数数量严格大于 D² / (2k)。
约束数：我们有n个约束条件 Q(α_i, y_i) = 0。

在本算法中，我们设 D = √(2 * k * n)。因此，变量数 > (√(2kn))² / (2k) = n，恰好等于约束数n。由于变量数大于约束数，我们可以通过求解线性系统来完成步骤1。

有效性分析（步骤2）
我们需要证明，如果某个多项式f与接收字y在足够多的位置上一致，那么它将被算法返回。

定义 R(x) = Q(x, f(x))。我们希望证明R(x)恒等于0。我们通过证明R(x)的度数不高，但却有很多根来实现。

R(x)的度数：deg(R) ≤ (1, k)-deg(Q) ≤ √(2 * k * n)。
R(x)的根：如果f(α_i) = y_i，那么由插值条件Q(α_i, y_i)=0可知，R(α_i)=0。如果这样的i的数量 t > √(2 * k * n)，那么R(x)就有超过√(2 * k * n)个根。

由于一个非零多项式的根数不能超过其次数，而这里根数t大于次数上界√(2kn)，这迫使R(x)必须是零多项式。因此，f会被步骤2返回。

综上所述，这个改进算法能够高效地列表解码Reed-Solomon码，达到错误比例 p = 1 - √(2R)。列表大小L也是一个合理的值。

这样，我们成功将Sudan算法中的因子2从根号外移到了根号内，这是一个明确的改进。但我们还没有达到最终目标1 - √R，还需要另一个√2的改进。

第二步改进：引入重根

我们下一个改进是考虑重根。

定义：双变量多项式Q(x, y)在点(a, b)处有重数为r的根，如果多项式Q(x+a, y+b)不包含任何总次数严格小于r的单项式。

示例：假设Q(x, y) = (x - α_i)² * (y - y_i)。那么它在点(α_i, y_i)处有重数为3的根。因为Q(x+α_i, y+y_i) = x² * y，它没有总次数小于3的项。

为什么关心重数？直观上，它允许我们“用更少的代价获得更多的根”。在证明中，一个重数为r的根在“低次多项式不能有太多根”的分析中，可以算作r个根，这将为我们带来优势。

Guruswami-Sudan算法

现在，我们介绍完整的Guruswami-Sudan算法。

首先选择参数r（小写）。增大r将在解码半径和列表大小之间进行权衡：r越大，越接*Johnson界，但列表大小也会增加。

设t是一个参数，满足：
t > √( k * n * (1 + 1/r) )
t表示我们希望返回的与y至少在t个位置上一致的多项式f的数量。当r趋于无穷时，t趋*于√(k * n)，这正是Johnson界对应的值。

算法同样包含两步：

步骤1：插值
找到一个双变量多项式Q，其(1, k)度D为：
D = √( k * n * r * (r+1) )
并且要求对于所有i从1到n，满足：
Q(α_i, y_i) = 0 且重数为r。
这是与之前版本的关键区别：要求Q在这些点上以重数r消失。

步骤2：求根
返回所有满足Q(x, f(x)) ≡ 0的多项式f。
这样的f最多有D/k个，大约为 r / √R。只要r是常数且码率R是常数，列表大小就是常数。实际上，为了使t*似为√(k*n)，取r为关于n和k的多项式即可，此时列表大小也是多项式的。

算法分析

我们声称此算法能以错误比例 p = 1 - √((1+1/r) * R) 和列表大小 L = O(r / √R) 高效列表解码Reed-Solomon码。证明仍需说明步骤1可行且步骤2有效。

步骤1的可行性
我们需要计算约束数和变量数。

约束数：要求一个多项式在一点以重数r消失，带来的约束条件数量最多为 C(r+1, 2) = r(r+1)/2。对于n个点，总约束数 ≤ n * r(r+1)/2。
变量数：与之前相同，> D² / (2k)。

代入 D = √( k * n * r * (r+1) )，可得变量数 > [k * n * r * (r+1)] / (2k) = n * r(r+1)/2，这正好等于约束数上界。因此，我们可以通过求解线性系统完成步骤1。

步骤2的有效性
定义 R(x) = Q(x, f(x))。假设f在至少t个位置i上满足f(α_i) = y_i。

R(x)的度数：deg(R) ≤ (1, k)-deg(Q) = D = √( k * n * r * (r+1) )。
R(x)的根（计重数）：可以证明，对于每个满足f(α_i) = y_i的i，(x - α_i)^r 整除 R(x)。这是因为Q在(α_i, y_i)有重数r的根。因此，R(x)至少被 ∏ (x - α_i)^r 整除，这个乘积多项式的次数为 t * r。

根据“低次多项式不能有太多根（计重数）”的原理，如果R(x)非零，其次数必须至少为 t * r。

现在比较：

算法要求 t > √( k * n * (1 + 1/r) )，所以 t * r > r * √( k * n * (1 + 1/r) ) = √( k * n * r * (r+1) )。
而R(x)的度数上界正是 √( k * n * r * (r+1) )。

因此，t * r 严格大于 R(x)的度数上界。这意味着R(x)不可能有t * r那么高的次数，所以它必须是恒等于零的多项式。因此，任何与y在至少t个位置上一致的f都会被步骤2返回。步骤2是有效的。

综上所述，Guruswami-Sudan算法是正确的，并且可以高效实现（步骤1解线性系统，步骤2有多项式时间方法）。

总结

本节课中，我们一起学*了Guruswami-Sudan算法，它给出了一个高效列表解码Reed-Solomon码直至Johnson界的算法。

我们从Sudan算法开始，它未能完全达到Johnson界，只达到了1 - 2√R。
我们进行了第一次改进，引入了(1, k)度的概念，这节省了一个√2因子，将半径提升到1 - √(2R)。
然后我们进行了第二次改进，引入了重根的概念，这使我们最终达到了1 - √R，即Johnson界。

你可能会想，是否有可能超越Johnson界进一步扩大解码半径？我们在之前的课程中看到，列表解码容量定理是超越Johnson界的。然而，对于Reed-Solomon码，能否高效地列表解码直至容量界，在很大程度上仍然是一个开放问题。不过，目前达到Johnson界已经是一个非常好的结果了。

代数编码理论导论：1：列表恢复（List Recovery）介绍

在本节课中，我们将学*列表解码（List Decoding）的一个推广概念——列表恢复（List Recovery）。

列表恢复的定义如下。首先选择参数：大写的 L 和小写的 l，要求 L ≥ l，且两者均为大于等于1的整数。再选择一个介于0和1之间的参数 P。对于一个定义在字母表 Σ 上、长度为 N 的编码 C，如果对于所有大小不超过 l 的子集序列 S₁, S₂, ..., S_N（其中每个 S_i ⊆ Σ），满足以下条件的码字 c ∈ C 的数量不超过 L，则称该编码是 (P, l, L) 列表可恢复的。

条件为：码字 c 与列表序列不一致的位置数量最多为 P × N 个。用公式表示，即满足以下条件的码字数量不超过 L：
|{ i | c_i ∉ S_i }| ≤ P × N

为了理解这个定义，我们可以想象一个场景。假设有一个未知的码字 c 属于编码 C。我们不知道它的具体内容，但知道关于其每个符号的一些约束信息。例如，我们知道第一个符号 c₁ 可能来自列表 S₁ = {A, B, C}，第二个符号 c₂ 可能来自列表 S₂ = {B, D, F}，依此类推，直到第 N 个符号。我们的任务是，在编码 C 中找出所有满足这些约束的码字，即那些至少在一部分（具体是 1-P 比例）的位置上，其符号值落在对应列表中的码字。列表可恢复性要求这样的码字数量不超过 L 个。

现在，让我们对这个定义做几点观察。

以下是关于列表恢复定义的几点观察：

列表恢复是列表解码的推广。具体来说，(P, 1, L) 列表恢复 等价于 (P, L) 列表解码。如果不理解，可以暂停思考一下。
当 P=0 时，列表恢复依然有意义。此时，我们要求与所有列表完全一致的码字数量不超过 L。这是一种常见情况，此时我们省略参数 P，直接称之为 (l, L) 列表可恢复。
参数 L 必须大于等于 l。即使定义中没有明确要求，这也是必然的。原因如下：对于任何编码，我都可以构造出大小为 l 的列表序列，使得至少有 l 个码字完全符合这些列表。构造方法是：任意选取 l 个码字，对于第 i 个位置，将所选 l 个码字在该位置的符号集合作为列表 S_i。这样，这 l 个被选中的码字自然满足所有列表约束。因此，定义中的 L 不可能小于 l。

上一节我们介绍了列表恢复的定义及其与列表解码的关系。本节中我们来看看一个自然产生的问题：我们之前关于列表解码的结论能否推广到列表恢复？

答案是肯定的。例如：

存在列表恢复的容量定理（List Recovery Capacity Theorem）。
存在列表恢复的约翰逊界（Johnson Bound for List Recovery）。

这些结论的证明思路与列表解码中的相应证明类似。作为一个有趣的练*，你可以尝试通过模仿列表解码容量定理的证明，来推导列表恢复的容量定理。

另一个我们为列表解码（特别是里德-所罗门码）看到的重要结果是古鲁斯瓦米-苏丹算法（Guruswami-Sudan algorithm）。你可能会问，这个算法能否扩展到列表恢复？

答案同样是肯定的。我们将在下一个视频中详细探讨这一点。

本节课中我们一起学*了列表恢复的概念，它是列表解码的推广。我们明确了其定义、关键参数，并指出了它与列表解码的关系。我们还了解到，列表解码中的许多核心结论，如容量定理和高效的解码算法，都可以相应地推广到列表恢复的设定中。

041：RS码的列表恢复

在本节课程中，我们将探讨列表恢复问题在里德-所罗门码上的具体应用。我们将学*如何高效地找到所有满足大部分约束条件的低次多项式。

问题定义

上一节我们介绍了列表恢复的一般概念，本节中我们来看看如何将其具体应用于里德-所罗门码。

设有一组互不相同的求值点 α₁, α₂, …, αₙ ∈ 𝔽_q。同时，我们被给予一组列表 S₁, S₂, …, Sₙ，每个列表 Sᵢ 都是 𝔽_q 的子集，且大小至多为 ℓ。

那么，针对里德-所罗门码的列表恢复问题，其目标是找到所有满足以下条件的多项式 f(x) ∈ 𝔽_q[x]：

多项式的次数 deg(f) ≤ k - 1。
对于至少 (1 - ρ)n 个索引 i，有 f(αᵢ) ∈ Sᵢ。

如果存在这样的多项式，并且其数量 L 是可管理的，我们就称该里德-所罗门码是 (ρ, ℓ, L)-列表可恢复的。我们的目标是以多项式时间（关于 n）高效地找到所有这些多项式。

问题可视化

我们可以将这个问题可视化如下。想象一个坐标平面，横轴和纵轴都代表域 𝔽_q。我们在横轴上标出求值点 α₁, α₂, …。对于每个求值点 αᵢ，我们在纵向上有一个允许值的集合 Sᵢ（大小至多为 ℓ）。我们的目标是找到所有那些图像点 (αᵢ, f(αᵢ)) 大部分都落在对应竖条 Sᵢ 内的低次多项式 f。

解决方案：Guruswami-Sudan算法

那么，我们如何高效地解决这个问题呢？实际上，我们已经掌握了答案。

回想一下我们在之前视频中学到的Guruswami-Sudan算法。该算法解决了以下问题：

定理：给定 M 个点 (αᵢ, yᵢ) 和一个参数 r ≥ 1，存在一个高效算法（Guruswami-Sudan算法），可以找到所有满足以下条件的多项式 f(x) ∈ 𝔽_q[x]：

deg(f) ≤ k - 1
f(αᵢ) = yᵢ 对于至少 √(Mk(1 + 1/r)) 个索引 i 成立。

并且，这样的多项式数量至多为 r√(M/k)。

请注意，此定理中的点 (αᵢ, yᵢ) 的 αᵢ 不需要互不相同，且点的总数 M 可以大于码长 n。

从列表解码到列表恢复

这个定理如何帮助我们解决列表恢复问题呢？它直接导出了以下推论：

推论：一个长度为 n、维度为 k、码率为 R = k/n 的里德-所罗门码，是高效 (ρ, ℓ, L)-列表可恢复的，其中：

ρ < 1 - √(Rℓ(1 + ε))，对于任意 ε > 0。
列表大小 L = O( (1/ε) √(ℓ / R) )。

让我们分析一下这个半径 ρ。如果忽略 ε，它表明 ρ 可以达到 1 - √(Rℓ)。这很像列表解码的约翰逊界（Johnson Bound），后者给出的半径是 1 - √(R)。这里的区别在于平方根下多了一个 ℓ，这正是列表恢复版本的约翰逊界。

关于列表大小 L，由于要使 ρ 非负，需要 R ≤ 1/ℓ，因此 √(ℓ / R) ≥ √(ℓ²) = ℓ。这意味着 L 确实与 ℓ 成线性关系，符合预期。

推论证明简述

以下是该推论的简要证明思路：

构造点集：给定输入列表 Sᵢ = {yᵢ₁, yᵢ₂, …, yᵢ_ℓ}，我们构造一个包含 M = ℓn 个点的集合。具体方法是，对于每个求值点 αᵢ，我们生成 ℓ 个点：(αᵢ, yᵢ₁), (αᵢ, yᵢ₂), …, (αᵢ, yᵢ_ℓ)。
应用定理：对这个包含 M 个点的集合应用Guruswami-Sudan定理，并取参数 r = 1/ε。
建立联系：我们需要满足定理中的“大量一致”条件。计算表明，当错误比例 1 - ρ 小于 √(Rℓ(1 + ε)) 时，条件成立。移项后即得到 ρ < 1 - √(Rℓ(1 + ε))。
确定列表大小：定理保证输出的多项式数量（即列表大小 L）至多为 r√(M/k) = (1/ε) √( (ℓn) / (Rn) ) = O( (1/ε) √(ℓ / R) )。

为何重要？🎯

你可能会问，我们为什么关心列表恢复？事实证明，列表恢复有大量应用。

在接下来的几节视频中，我们将看到列表恢复在流算法中的一个具体应用，展示其强大的实用性。

本节总结

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

将列表恢复问题具体定义到里德-所罗门码上。
认识到Guruswami-Sudan算法可以直接用于解决列表恢复问题。
推导出了里德-所罗门码的列表恢复能力约翰逊界：ρ < 1 - √(Rℓ)，并能以多项式时间输出大小可控的候选列表。
了解到列表恢复是后续重要应用（如流算法）的基础工具。

042：大数据流中的频繁项检测 🎯

在本节课中，我们将要学*一个与代数编码理论看似无关，但后续会展示其联系的重要问题：大数据流中的频繁项检测问题。我们将介绍该问题的定义、一个经典的解决方案——Count-Min Sketch数据结构，并探讨其潜在的改进方向。

问题定义：什么是频繁项？ 📊

上一节我们介绍了课程背景，本节中我们来看看“频繁项”问题的具体定义。

我们有一个输入流，包含 M 个来自一个巨大宇宙 U（大小为 N）的元素：x1, x2, ..., xM。所谓“流”，意味着数据依次流过，一旦过去就无法再次访问，除非我们将其记录下来。

我们的目标是输出一个列表，其中包含所有在流中出现次数“很多”的元素。这里“很多”定义为出现次数大于等于 ε * M，其中 ε 是一个介于0和1之间的参数。由于总共只有 M 个元素，这样的“频繁项”最多只有 1/ε 个。

这个问题在现实中很常见，例如，网络路由器需要快速识别出最常出现的流量类型。

简单方案与空间挑战 💾

为什么我们不直接想一个简单的解决方案呢？以下是两种直观的方法：

存储所有元素：保存所有 M 个 x，最后再统计。这需要 O(M) 的空间。
存储直方图：为宇宙 U 中的每个可能元素维护一个计数器。这需要 O(N) 的空间。

这两种方案在 M 或 N 非常大时，空间开销都过于巨大。我们的挑战在于，希望使用远小于 N 和 M 的空间（例如 polylog(N, M) 级别）来解决这个问题。

然而，研究表明，如果要求精确地、确定性地找出所有频繁项，至少需要 Ω(N) 的空间。这意味着在严格定义下，该问题在亚线性空间内是不可能解决的。

*似频繁项检测问题 ✅

当一个问题不可能解决时，我们可以重新定义一个可行的新问题。

于是我们引入了*似频繁项检测问题。输入流不变，但我们对输出放宽了要求：

允许算法有微小的失败概率。
允许返回的列表略大于真实的频繁项集合。

具体而言，我们希望输出一个集合 S，使得以高概率（如 >99%）满足以下两点：

包含性：所有出现次数 ≥ εM 的元素 x 都一定在 S 中。
紧凑性：集合 S 的大小不超过 2/ε（最多比真实频繁项集合大一倍）。

以这种方式定义后，该问题可以在亚线性空间内解决。所需的空间复杂度为 O(log(M) * log(N) / ε)。其解决方案就是 Count-Min Sketch 数据结构。

Count-Min Sketch 数据结构 🏗️

上一节我们定义了可解的问题，本节中我们来看看其经典解决方案——Count-Min Sketch。这是一个非常巧妙的数据结构。

首先设定一个参数 T。该数据结构包含以下部分：

数据结构存储
我们存储 T 个数组 A1, A2, ..., AT。每个数组的长度约为 4/ε。你可以将每个数组位置想象成一个“桶”。

同时，我们准备 T 个哈希函数 h1, h2, ..., hT。每个哈希函数 hi 负责将宇宙 U 中的元素映射到数组 Ai 的某个桶中。

更新操作
当流中出现一个元素 x 时，我们进行以下操作：
对于每个 i 从 1 到 T：

计算 hi(x)，得到它在数组 Ai 中的目标桶索引。
将该桶内的计数器加 1。

所有数组的计数器初始值均为 0。

查询与估计
为了找出频繁项，我们首先需要估计每个元素出现的频率。
对于宇宙中的任意元素 y，我们按以下方式估计其出现次数 count(y)：

查看 y 在 T 个数组中分别被哈希到的桶：A1[h1(y)], A2[h2(y)], ..., AT[hT(y)]。
读取这些桶中的计数器值。
取这些计数器中的最小值作为 count(y) 的估计值。公式表示为：
估计值(y) = min{ A1[h1(y)], A2[h2(y)], ..., AT[hT(y)] }

原理直观解释
为什么取最小值？因为桶计数器可能被其他哈希到同一桶的元素“污染”而偏高。最小值是所有估计中最不可能被高估的（尽管可能被低估）。如果一个元素是频繁项，我们希望至少有一个哈希函数能将其映射到一个相对“干净”（碰撞少）的桶，从而获得一个接*真实值的估计。

最后，我们扫描所有元素，返回估计值最大的那 2/ε 个元素作为候选频繁项集合 S。

参数与性能
可以证明，如果设置参数 T = O(log N)，每个数组长度 L = 4/ε，那么上述方案能以高概率成功解决*似频繁项检测问题。

Count-Min Sketch 的潜在改进方向 🔧

尽管 Count-Min Sketch 是一个非常优雅高效的数据结构，我们仍可以思考其改进空间。以下是两个可能的改进方向：

1. 确定性方案
当前的 Count-Min Sketch 是随机化的，其正确性依赖于随机选择的哈希函数，并有一个小的失败概率。我们可能希望找到一个确定性的方案，在保持亚线性空间的同时，获得类似的保证，并且100%正确。

2. 更快的查询时间
当前方案在查询时需要遍历整个宇宙 U 中的所有元素来计算估计值并找出最大的那些。虽然空间是亚线性的，但查询时间是 O(N)，对于巨大的宇宙来说可能太慢。我们可能希望在保持亚线性空间的同时，也能实现亚线性的查询时间。

总结与下节预告 📚

本节课中我们一起学*了大数据流处理中的经典问题——频繁项检测。

我们首先了解了精确检测在亚线性空间下的不可能性。
接着，我们定义了可行的*似频繁项检测问题。
然后，详细介绍了解决该问题的 Count-Min Sketch 数据结构，包括其结构、更新和查询操作。
最后，我们探讨了该数据结构在确定性和查询效率方面可能的改进方向。

在下一节课中，我们将看到如何利用里德-所罗门码的列表恢复特性，以非常巧妙的方式来实现这些改进。

043：列表恢复的应用

在本节课中，我们将探讨列表恢复的几种应用，并重点概述其在“频繁项问题”中的一个应用思路。列表恢复作为列表解码的推广，其应用范围远超编码理论本身，在伪随机性、密码学和算法设计等领域均有重要价值。

列表恢复的应用概述

上一节我们介绍了列表恢复的基本概念。本节中我们来看看列表恢复的广泛应用。

列表恢复之所以有用，是因为它不仅是列表解码的推广，还在编码理论内外有大量应用。在编码理论内部，列表恢复本身就是一个重要工具。列表恢复最初被定义的原因之一，就是可以利用列表可恢复码及其算法来设计更好的列表可解码码。通过操作列表可恢复码，我们可以获得比早期方法更优的列表可解码码。

然而，列表恢复的应用远不止于编码理论。它与伪随机性中的许多概念相关，例如提取器、扩展器和浓缩器等。列表恢复也出现在密码学的多种应用中。此外，在算法设计领域，例如在分组测试、压缩感知以及我们将在本节重点讨论的频繁项问题中，列表恢复也扮演着关键角色。

今天，我们主要讨论频繁项问题的应用。关于其他应用的指引，请查阅课程讲义。

需要说明的是，本节内容将较为概略，旨在让大家体会列表恢复在编码理论之外的用途，因此不会深入细节或计算具体参数。有兴趣的观众可以自行深入研究。

应用一：使用RS码替代哈希函数

首先，我们快速回顾上一节介绍的Count-Min Sketch数据结构。我们有T个数组。当处理输入流（例如 X, X, Y, X, Y, Z, X, Y, Y）时，每个项会被哈希到相应数组的桶中，并增加对应计数器的值。

例如，如果X被哈希到这些位置，在处理完整个流后，我们看到了4个X，那么这些计数器会显示为4。注意，我们并不存储X本身。我们可能看到4个Y和一个Z。如果想估计Y出现的次数，我们会查看Y被哈希到的所有桶，并取这些桶中计数的最小值，在这个例子中结果是4，即正确答案。

为了返回所有频繁项，算法需要遍历全集中的所有项并找出计数最高的项。然而，正如上一节末尾提到的，这个方法速度很慢，因为需要遍历整个可能很大的全集。

接下来，我们将看到两种利用列表恢复来改善这个问题的方法。第一种方法还会得到一个确定性的构造，这非常巧妙。

以下是第一种方法。我们将使用与Count-Min Sketch完全相同的数据结构，但用里德-所罗门码替代随机哈希函数。更精确地说，我们在域F_q中固定一些不同的评估点α_1到α_n。

现在考虑一个码率约为ε/10的里德-所罗门码，其中ε是频繁项问题定义中的参数。同时，我们设n等于q，这样就得到了一个全长的里德-所罗门码。

回顾之前证明的关于里德-所罗门码列表恢复的定理，我们可以发现这个里德-所罗门码是高效列表可恢复的，其参数为：p=0，l=1/ε，L的数量级为O(1/ε)。具体来说，我们有以下推论：

推论：对于一个码率为R的RS码，若满足 l ≤ 1/(1-R-γ)，则该码是 (ζ, l, L)-列表可恢复的，其中 L = O(l/γ)。将 l 设为 1/ε，γ 设为 1，即可得到上述结论。

这里的常数10并非特定值，只是一个调整因子，用于确保计算中的取整等操作不会出错。

这样，我们就得到了列表可恢复的里德-所罗门码。现在，我们将实施Count-Min Sketch算法，但使用这个RS码代替哈希函数。具体做法如下：

首先，我们将全集U中的每个对象与一个次数小于等于k-1的多项式相关联。这意味着U的大小是 q^k，即大约 q^(εn/10)。因此，n最多是 log(|U|) / ε。特别地，如果我们的操作时间是n的多项式，那也就是|U|的多项式对数时间，这对我们是有利的。

接下来，我们用多项式在特定评估点的取值来替代Count-Min Sketch中的随机哈希函数。具体地，我们定义哈希函数 h_j(f) = f(α_j)，其中f是代表全集某项的多项式，j从1到n。

于是，数据结构变成了：有n个数组（T=n），每个数组对应一个评估点α_j。每个数组有q个桶，对应域F_q中的值β_1到β_q。

当处理输入流中的一系列项（例如多项式f出现多次，然后是多项式g，再是f，接着是h，一堆g等等）时，对于每个项（如f），我们计算它在所有评估点的值。假设 f(α_1) = β_2，我们就在第一个数组的β_2桶中为f增加计数。f(α_2)可能是另一个β值，我们就在对应数组的对应桶中增加计数。我们对流中的所有项都如此处理，最终得到所有桶的计数器。

现在，我们不使用原来缓慢的查询算法。取而代之的是，我们将运行一个列表恢复算法。具体来说，对于第i个数组，我们定义集合S_i，包含所有满足以下条件的β值：对应桶的计数器值大于εm（m是流的总长度）。这样，S_i最多包含1/ε个元素，因为否则整个数组中的总项数就会超过m。

关键观察：如果某个多项式g是频繁项（即在流中出现至少εm次），那么在每个数组中，g(α_i)对应的桶的计数至少为εm。这意味着对于所有i，g(α_i)都会出现在集合S_i中。而这正是里德-所罗门码列表恢复算法要解决的问题：给定输入列表S_i，算法返回所有满足“对于所有i，g(α_i) ∈ S_i”的低次数多项式g。因此，算法将返回g以及任何其他频繁项。

总结这个应用：

更新操作：与之前相同。
查询操作：运行列表恢复算法。
由于S_i的大小不超过1/ε，而我们恰好设置了参数l=1/ε，因此算法可行，并保证返回的列表大小不超过O(1/ε)。虽然最初定义频繁项问题时要求返回最多2/ε个项，但这里的数量级是相*的。精确计算参数是一个很好的练*。

最重要的是，所有操作（存储、运行时间等）都是n的多项式，而n是log(|U|)/ε，因此也就是|U|的多项式对数时间。在这个意义上，我们取得了成功。如果仔细计算参数，会发现这个方案比原始Count-Min Sketch的参数稍差一些，但我们获得了两个好处：第一，这是一个确定性方案而非随机化方案；第二，我们有一个高效的（即多项式时间）查询算法来找出所有频繁项。

应用二：使用多个小型Count-Min Sketch

接下来是第二个想法，它同样利用里德-所罗门码的列表恢复来加速Count-Min Sketch的查询时间，但思路不同。

我们重新开始。首先，我们选择一个列表可恢复的里德-所罗门码，其参数为：l=2/ε，L=O(1/ε)，p=0（实际上，为了严谨，p应设为一个小的常数，但大体思路不变）。和之前一样，我们将全集与所有次数≤k-1的多项式集合相关联。

现在，我们将使用一个不同的数据结构：不是单个Count-Min Sketch，而是一组小型的Count-Min Sketch。我们将初始化n个小型的Count-Min Sketch。这里说“小型”，是指它们用于一个更小的全集，即域F_q。

和之前一样，我们设q等于n，而n是O(log(N)/ε)，其中N是原始全集的大小。这意味着每个小型Count-Min Sketch的全集大小仅为原始全集大小的对数级别。因此，即使使用像暴力遍历整个小全集这样的“慢”算法，也能在log(N)的多项式时间内快速完成查询。

接下来，我们将使用列表恢复来将这些具有快速查询能力的小型结构“组合”成一个处理大全集的结构。具体方法如下：

更新操作：假设我们有一个来自大全集的项f，需要更新我们的数据结构。

首先，我们用里德-所罗门码对f进行编码，即计算f在所有评估点上的值：f(α_1), ..., f(α_n)。
然后，我们用这些值去更新每一个小型的Count-Min Sketch：用f(α_1)更新第一个，用f(α_2)更新第二个，依此类推。

查询操作：

我们让每个小型Count-Min Sketch运行它们自己的查询算法。因为它们很小，所以可以在多项式时间内完成。
每个小型结构会输出一个列表，我们将其命名为S_1到S_n。
最后，我们的查询算法就是：对这些列表S_i运行列表恢复算法。

直观理解：如果多项式f是一个频繁项，那么f(α_1)会在第一个坐标上频繁出现。虽然其他多项式g也可能在α_1处与f取值相同，但f(α_1)肯定会出现很多次。因此，我们希望第一个小型Count-Min Sketch能捕捉到这一点，使f(α_1)出现在S_1中。同理，对于其他评估点也是如此。最终，如果f是频繁项，那么对于所有i，f(α_i)都会出现在许多S_i列表中。而这正是列表恢复要解决的问题。

每个列表S_i的大小，根据Count-Min Sketch的保证，不超过2/ε，这恰好是我们之前设置参数l时的值。因此，一切都能配合工作。

同样，为了精确，需要考虑p不为0的情况，并调整其他小常数，但整体框架不变。q和n仍然是log(N)级别，所有操作都是其多项式时间。

这个想法确实可行，并提供了一个快速的查询算法。再次说明，本节不详细计算参数，有兴趣可以自行练*。结果表明，与原始Count-Min Sketch相比，我们确实需要付出一些代价：空间占用会稍多一些，更新时间也会稍长。然而，查询时间却快得多。原因在于，查询时只需要运行每个小型结构的查询算法（因为它们很小，所以很快），然后再运行列表恢复算法（该算法运行时间是n的多项式，即N的多项式对数时间）。最终，我们实现了亚线性的空间和亚线性的查询时间。

需要注意的是，这个算法仍然是随机化的，因为其基础构件（小型Count-Min Sketch）是随机化的。

总结与课程回顾

本节课中我们一起学*了列表恢复在频繁项问题上的两种应用。

这两种利用列表恢复加速频繁项算法的方法，其核心思想是：列表恢复可以成为一个非常有用的工具。在这个具体情境中，它允许我们加速Count-Min Sketch的查询算法，代价是增加了少量空间和稍慢的更新操作。

虽然本节没有详细计算具体参数，但需要指出，为了应用这些想法，在空间和更新时间上确实存在一些开销。实际上，在频繁项问题领域，存在一些比这些方法更优的前沿工作，并不依赖于列表恢复。然而，本节介绍的方法非常巧妙，并且很好地展示了列表恢复如何成为算法设计中的一个强大工具。

列表恢复的故事告诉我们，编码理论中的思想可以灵活地应用于计算机科学的其他领域，解决实际问题。

044：折叠里德-所罗门码

在本节课中，我们将介绍折叠里德-所罗门码。这是一种里德-所罗门码的变体，能够高效地进行列表译码，直至达到列表译码容量。

概述

首先，让我们回顾一下列表译码的背景。对于一个码率为 R 的码，我们考虑在唯一译码和列表译码下，分别能纠正多大的错误比例 P。

P 的取值范围是从 0 到 1。我们知道，对于错误比例 P ≤ (1 - R)/2，可以高效地对里德-所罗门码进行唯一译码。然而，一旦超过这个界限，唯一译码就变得不可能，我们必须转向列表译码。

在之前的课程中，我们了解到可以使用 Guruswami-Sudan 算法高效地对里德-所罗门码进行列表译码，直至达到约翰逊界，即 P = 1 - √R。然而，列表译码容量定理指出，理论上存在可以列表译码至 P = 1 - R 的码。这个结果是存在性的，并未提供高效的构造算法。

在 P = 1 - √R 到 P = 1 - R 这个区间内，存在一个理论可行但缺乏显式构造和高效算法的空白。本课程的目标就是填补这个空白。我们将展示如何显式构造一种码，并给出高效算法，使其能够列表译码至接*容量 1 - R 的错误比例 P。这种码就是折叠里德-所罗门码。

在本节视频中，我们将定义折叠里德-所罗门码。在后续课程中，我们将学*如何高效地对其进行列表译码。

折叠操作

为了定义折叠里德-所罗门码，我们首先需要定义折叠操作。这是一个可以应用于任何码的操作。

对于一个向量 c ∈ Σ^n，我们定义其 M 次折叠，记作 fold_M(c)，如下所示：

fold_M(c) 将是一个属于 (Σ^M)(n/M) 的向量（这里假设 M 整除 n）。操作方式是将符号按 M 个一组进行“折叠”打包。

具体来说，如果原始向量 c 是：

c = (c₀, c₁, c₂, ..., c_{n-1})

那么经过 M 次折叠后，我们得到的新向量是：

fold_M(c) = ( (c₀, c₁, ..., c_{M-1}), (c_M, c_{M+1}, ..., c_{2M-1}), ..., (c_{n-M}, ..., c_{n-1}) )

我们没有改变向量的坐标内容，只是改变了它们的打包方式。

折叠码的定义

现在，对于一个码 C ⊆ Σ^n，我们可以定义其 M 次折叠码，即 C 中所有码字的折叠结果的集合：

fold_M(C) = { fold_M(c) | c ∈ C }

以下是关于折叠码的一些观察：

折叠码的字母表是 Σ^M。
折叠码的码长是 N = n / M（我们用大写 N 表示折叠码的码长，保留小写 n 给原始码）。
折叠操作不改变码率。直观上，这是因为我们没有改变传输的信息量，只是改变了打包方式。形式上可以证明：
```
Rate(fold_M(C)) = (log_{|Σ^M|} |C|) / (n/M) = (log_{|Σ|} |C|) / n = Rate(C)
```

折叠里德-所罗门码的定义

顾名思义，折叠里德-所罗门码就是将折叠操作应用于里德-所罗门码的结果。

正式定义如下：设 C 是一个里德-所罗门码，其定义在有限域 F_q 上，码长为 n = q-1，维度为 k，其估值点为 1, γ, γ², ..., γ^{n-1}，其中 γ 是 F_q 的一个本原元。假设 M 整除 n。

那么，对应于原始里德-所罗门码 C 的 M 次折叠里德-所罗门码（缩写为 FRS）就是 C 的 M 次折叠：

FRS = fold_M(C)

换句话说，一个折叠里德-所罗门码的码字（对应一个次数小于 k 的多项式 f）如下所示：

码长：N = n / M
字母表：F_q^M
第 i 个符号（i = 0, ..., N-1）是一个长度为 M 的向量：
```
( f(γ^{iM}), f(γ^{iM+1}), ..., f(γ^{iM+M-1}) )
```

如前所述，这个码的码率仍然是 R = k / n。折叠里德-所罗门码看起来与标准里德-所罗门码区别不大，但正如我们将要看到的，我们将能够为其设计出高效、直至达到容量的列表译码算法。直观上，通过增大字母表，我们使得列表译码问题变得稍微容易了一些。

主要定理

更正式地，我们将证明以下定理：

设 ε 为某个大于 0 的常数。那么存在折叠里德-所罗门码，其字母表 Σ = F_q^M（对于某个 q 和 M），码长 N，码率 R，使得该码是 (P, L) 列表可译码的，其中：

P = 1 - R - O(ε)，非常接*列表译码容量。
列表大小 L 是 n 的多项式（假设 ε 是常数）。

此外，我们不需要将折叠参数 M 取得非常大（否则字母表会过于巨大）。我们可以选择 M，使得字母表大小仍然是码长 N 的多项式（假设 ε 是常数）。

关于此定理的一些说明：

P 的值是最优的。它趋*于列表译码容量定理指出的上限 1 - R。
列表大小 L 并非最优。理想情况下，我们希望它只是一个依赖于 ε 的常数。实际上，折叠里德-所罗门码确实可以达到不依赖于 N 的常数列表大小，即 L = C(ε)，但这超出了本系列视频的讨论范围。
字母表大小也非最优。理想情况下，我们希望它也是仅依赖于 ε 的常数。但当前的结果已经足够好，它填补了我们之前提到的理论空白，使我们能够高效地将折叠里德-所罗门码列表译码至接*容量 1 - R 的错误比例 P。

在接下来的几节课中，我们将证明这个定理。

总结

本节课我们一起学*了折叠里德-所罗门码。我们首先定义了通用的折叠操作以及折叠码，然后将其应用于里德-所罗门码，得到了折叠里德-所罗门码。最后，我们陈述了关于折叠里德-所罗门码可以达到列表译码容量的主要定理。在后续课程中，我们将深入探讨如何实现这一高效译码算法。

045：折叠里德-所罗门码的列表解码（初步）📚

在本节课中，我们将学*折叠里德-所罗门码列表解码的一个初步结果。这个结果虽然不能直接证明我们在上一视频末尾陈述的最终定理，但它为我们提供了一个起点，并展示了证明完整定理所需的核心思想。

定理陈述 📝

假设 C 是一个折叠参数为 M 的折叠里德-所罗门码，其长度 N 等于原始里德-所罗门码长度 n 除以 M，即 N = n / M。

那么，该折叠里德-所罗门码 C 是 (p, L) 列表可解码的，其中：

列表解码半径 p 为：
```
p = M/(M+1) * (1 - M * R)
```
列表大小 L 是合理的。
解码算法可以在多项式时间内运行。

这个结果本身并不十分理想，因为我们希望 p 接* 1 - R，但无论 M 如何选择，上述公式都无法达到这个目标。然而，其证明过程将阐明后续证明完整定理所需的关键思路。

算法概述 🛠️

我们将通过给出一个具体的解码算法来证明这个定理。该算法分为两个主要步骤，这与我们之前见过的韦尔奇-伯利坎普算法、苏丹算法以及格里瓦米-苏丹算法的结构类似。

算法输入与输出

输入：
1. 一个接收到的单词 y。它的形式与折叠码字相同：第一个符号是一个小向量 (y_0, ..., y_{M-1})，第二个符号是 (y_M, ..., y_{2M-1})，依此类推。
2. 两个参数 t 和 D，我们稍后会确定其具体值。
输出：
一个列表 L，其中包含所有满足以下条件的多项式 f（定义在有限域 F_q 上，且次数最多为 k-1）：
```
对于超过 t 个索引 i，有：
(y_{Mi}, y_{Mi+1}, ..., y_{Mi+M-1}) = (f(γ^{Mi}), f(γ^{Mi+1}), ..., f(γ^{Mi+M-1}))
```
这里，t 是算法输入的一个参数，γ 是域中的本原元。

算法步骤详解 🔍

第一步：插值

在第一步中，我们需要找到一个具有特定形式的 M+1 元多项式 Q。

以下是第一步的具体要求：

多项式形式：Q 的变量是 x, y_1, ..., y_M，其形式为：
```
Q(x, y_1, ..., y_M) = A_0(x) + y_1 * A_1(x) + y_2 * A_2(x) + ... + y_M * A_M(x)
```
其中：
- A_0(x) 的次数最多为 D + k - 1。
- 对于 j = 1, ..., M，A_j(x) 的次数最多为 D。
插值约束：对于所有 i 从 0 到 n-1，多项式 Q 必须在以下点上取值为零：
```
Q( γ^{Mi}, y_{Mi}, y_{Mi+1}, ..., y_{Mi+M-1} ) = 0
```
这个约束模仿了格里瓦米-苏丹算法中对 Q 的要求：变量 x 代表码字的第一个评估点，而 y_j 则取接收单词对应位置的值。

第二步：寻找根

在第二步中，我们需要找到多项式 Q 的特定“根”。具体来说，我们需要找到所有次数最多为 k-1 的多项式 f，使得当我们将 Q 中的变量进行如下替换后：

将 y_j 替换为 f(γ^j * x)（即 f(γ * x), f(γ^2 * x), ..., f(γ^M * x)）

得到的是一个关于 x 的一元多项式 R(x)，并且 R(x) 恒等于零。

然后，算法将所有这样的多项式 f 作为列表返回。

算法可行性分析 ✅

与这类算法一样，我们需要回答两个关键问题：第一步是否可行？第二步是否是一个好主意（即能否保证找到所有应被解码的码字）？

第一步的可行性：系数与约束计数

我们通过比较多项式 Q 的系数（变量）数量和插值约束（方程）数量来分析。

变量数量：即 Q 中所有系数的总数。
- A_0(x) 的系数数量：D + k（因为次数最多为 D + k - 1）。
- 每个 A_j(x)（j=1..M）的系数数量：D + 1。
- 总变量数 = (D + k) + M * (D + 1) = (M+1)D + (M + k)。
约束数量：即插值点的数量，等于 n。

为了使线性方程组有非零解，我们需要变量数大于约束数。通过后续对参数 D 的巧妙选择（见下文），可以确保这一条件成立。因此，第一步是可行的。

第二步的有效性：低次多项式根的数量

我们需要证明：任何与接收单词 y 在超过 t 个位置上一致的正确码字多项式 f，都会使得第二步中构造的多项式 R(x) 恒等于零。

论证如下：

R(x) 的次数：由于 Q 的特殊形式以及 f 的次数限制，可以证明 R(x) 的次数最多为 D + k - 1。
R(x) 的根：每当 f 与 y 在第 i 个符号上一致时，根据第一步的插值约束，γ^{Mi} 就是 R(x) 的一个根。因此，如果一致的位置数超过 t，则 R(x) 至少有 t+1 个根。
结论：一个次数最多为 D + k - 1 的多项式，如果其根的数量超过了它的次数，那么它必须是零多项式。因此，只要我们选择的参数 t 满足 t ≥ D + k - 1，就能保证所有应被解码的 f 都会使 R(x) ≡ 0，从而被算法找到。

参数选择与定理证明 📐

为了使整个论证成立，我们需要精心选择参数 t 和 D。

选择 D：我们令
```
D = floor( (n - k) / (M + 1) )
```
这个选择恰好能保证第一步中变量数大于约束数的条件。
选择 t：我们令
```
t = N * ( 1/(M+1) + (M*R * M)/(M+1) )
```
其中 R = k/n 是原始码的码率，N = n/M 是折叠码的长度。这个选择确保了 t ≥ D + k - 1，从而满足了第二步有效性的条件。

现在，让我们完成定理的证明。算法成功返回了所有与接收单词 y 在超过 t 个符号上一致的多项式 f。换句话说，算法能处理所有错误符号数不超过 N - t 的情况。

因此，算法的列表解码半径 p，即能容忍的最大错误比例，为：

p = (N - t) / N = 1 - t/N

将上面选择的 t 代入并化简，即可得到定理中声明的表达式：

p = M/(M+1) * (1 - M * R)

至此，我们完成了对这个初步定理的证明。

总结与展望 🎯

本节课中，我们一起学*了折叠里德-所罗门码列表解码的一个基础算法及其证明。我们了解到：

算法通过两步走：先插值一个多元多项式 Q，再寻找能使某个衍生一元多项式 R(x) 为零的所有候选多项式 f。
其核心思想依然是比较系数与约束的数量，以及利用低次多项式不能有太多根这一事实。
通过精心选择参数 D 和 t，我们证明了算法能以 p = M/(M+1) * (1 - M * R) 的半径进行列表解码。

然而，正如开头所指出的，这个结果中的解码半径 p 并不令人满意，它无法接*理想的 1 - R。在下一个视频中，我们将改进这个想法，引入更强大的技术，以获得我们真正想要的、接*信道容量的列表解码结果。

046：折叠RS码的列表译码（第二部分）🎯

在本节课中，我们将改进上一视频的结果，学*如何将折叠里德-所罗门码的列表译码半径提升至列表译码容量。具体来说，我们将证明一个关键定理，并详细解析其背后的算法和参数选择。

定理陈述与参数解析 📊

我们将证明以下定理：选择整数参数 S 和 M，满足 1 ≤ S ≤ M。设 C 是一个码率为 R 的 M 折叠里德-所罗门码。那么，C 可以在多项式时间内进行列表译码，译码半径为 P，列表大小 L 至多为 Q^S。此外，列表中的码字实际上包含在一个维度为 S 的仿射子空间中。

其中，译码半径 P 的公式为：

P = (1 - S/M) * (1 - (K-1)/(N*(M-S+1)))

这里，Q 是原始里德-所罗门码的域大小。

为了理解这个定理的意义，让我们分析参数选择。如果我们选择 S ≈ 1/ε 且 M ≈ 1/ε²（其中 ε 是一个小参数），那么：

P ≈ (1 - ε) * (1 - (1+ε)R) ≈ 1 - R - O(ε)。这意味着译码半径 P 可以无限接*列表译码容量 1-R。
列表大小 L ≈ Q^(1/ε)。由于 Q ≈ n（原始RS码长），且 n = N * M（N 是折叠码的码长），代入 M ≈ 1/ε²，可得 L 是折叠码码长 N 的多项式大小（当 ε 为常数时）。

因此，通过选择常数 ε，我们能够以多项式列表大小和多项式时间，高效地实现接*容量界的列表译码。

算法改进的直观思路 💡

在上一节的算法中，接收字 Y 与候选码字 F 在一个位置 i 上的一致，会为我们的插值多项式 Q 带来一个根。

本节我们将改变策略，让一次一致带来多个根。我们不再像之前那样使用 M 个变量，而是只使用 S 个变量 y₁, …, y_S 来构造插值多项式 Q(x, y₁, …, y_S)。我们要求 Q 在一系列“滑动窗口”上为零。

具体来说，对于每个位置 i，我们要求 Q 在点 (γ^(Mi+j), Y_{Mi+j}, Y_{Mi+j+1}, …, Y_{Mi+j+S-1}) 上为零，其中 j 从 0 取到 M-S。这样，每个窗口的宽度是 S。

这样做的结果是：如果接收字 Y 与码字 F 在第 i 个位置一致，那么我们将为相关的多项式 r(x) 获得 M-S+1 个根，而不仅仅是一个。虽然这增加了插值的约束条件数量，但根数量的显著增加对后续论证更有利。

改进的列表译码算法 ⚙️

我们的算法依旧分为两步：插值和求根。

第一步：插值

我们插值一个具有以下形式的多项式：

Q(x, y₁, …, y_S) = a₀(x) + Σ_{i=1}^{S} y_i * a_i(x)

其中，deg(a₀) ≤ D + K - 1，且对于 i ≥ 1，有 deg(a_i) ≤ D。

我们要求 Q 满足所有滑动窗口的消失条件：

Q(γ^(Mi+j), Y_{Mi+j}, Y_{Mi+j+1}, …, Y_{Mi+j+S-1}) = 0

对于所有 i（从 0 到 N-1）和所有 j（从 0 到 M-S）。

参数 D 和 T 的选择如下：

D = floor( (N*(M-S+1) - (K-1)) / (S+1) )
T = floor( (D + K - 1) / (M - S + 1) )

通过比较变量数（多项式系数个数）和约束数（消失条件个数），可以证明这样的多项式 Q 总是存在的。

第二步：求根

这一步的目标是找到所有满足以下条件的次数小于 K 的多项式 F(x)：

r(x) = Q(x, F(x), F(γx), …, F(γ^(S-1)x)) ≡ 0

与之前不同，我们不再直接进行多项式分解。我们将证明，如果 F 对应的折叠码字与接收字 Y 在超过 T 个位置上一致，那么 r(x) 必然恒等于零。

论证的关键在于比较 r(x) 的次数和根的数量：

次数：deg(r) ≤ D + K - 1。
根的数量：每个一致的位置 i 会贡献 M-S+1 个根。因此，如果一致位置数 > T，则根的总数 > T * (M-S+1)。
根据我们对于 T 的选择，有 D + K - 1 ≤ T * (M-S+1)。这意味着根的数量超过了多项式的次数，因此 r(x) 必须是零多项式。

高效求解与列表大小控制 🔍

现在我们需要高效地找到所有使 r(x) ≡ 0 的 F(x)。我们将条件 r(x) ≡ 0 转化为一个关于 F 的系数 f₀, f₁, …, f_{K-1} 的线性方程组。

通过展开 r(x) 并令其各项系数为零，我们可以得到一个 K × K 的线性系统 M · f = v。关键在于，矩阵 M 是下三角矩阵，其对角线元素是 B₀(1), B₀(γ), B₀(γ²), …, B₀(γ^{K-1})，其中 B₀(x) 是一个次数至多为 S 的多项式。

这个结构带来了巨大优势：

求解效率：下三角系统可以在 O(K²) 时间内高效求解。
控制列表大小：方程组的解空间维度等于矩阵 M 的零空间维度。由于 M 是下三角矩阵，其零空间维度恰好等于其对角线上零元素的个数。而对角线上的零元对应着多项式 B₀(x) 在点集 {1, γ, …, γ^{K-1}} 中的根。因为 deg(B₀) ≤ S，所以这样的根最多有 S 个。

因此，解空间的维度至多为 S，这意味着满足条件的多项式 F 的个数（即列表大小 L）至多为 Q^S。并且，所有这些解构成一个维度至多为 S 的仿射子空间。

总结 📝

本节课我们一起学*了如何将折叠里德-所罗门码的列表译码推到容量界。

我们引入了一个使用更少变量（S个）的插值多项式，通过“滑动窗口”技术将一次一致转化为多个根。
我们证明了改进后的算法可以在多项式时间内，列表译码至半径 P ≈ 1 - R - O(ε)，列表大小 L 为多项式量级（≈ Q^(1/ε)）。
算法的核心在于将求根问题转化为一个特殊的线性系统，并利用其下三角结构高效求解，同时利用多项式根的数量限制来严格约束最终列表的大小。

这项工作填补了之前约翰逊界（1 - √R）与列表译码容量界（1 - R）之间的空白，展示了折叠码在实现高效、大容量列表译码方面的强大能力。

047：局部可纠正码

在本节课中，我们将开始学*编码理论中的一个新主题：局部性。具体来说，我们将讨论局部可解码码和局部可纠正码。

概述

我们将首先介绍局部可纠正码的基本设置和动机，然后探讨其定义，并解释为什么最初的朴素定义不可行。接着，我们将给出正确的、基于随机化的定义。最后，我们会简要介绍其他几种局部性概念，为后续课程打下基础。

局部可纠正码的基本设置

以下是局部可纠正码的基本场景。和往常一样，发送者爱丽丝有一个她想发送给接收者鲍勃的消息 X，该消息属于字母表 Σ 的 k 次幂集合。

她的做法是将消息 X 编码为某个码字 C，该码字属于字母表 Σ 的 n 次幂集合，然后将其发送给鲍勃。和往常一样，过程中会发生一些不好的事情。

对我们来说，通常发生的坏事是，有 ρ 比例的符号会被恶意地篡改。图中描绘了一个坏人，他将篡改 ρ 比例的符号，从而给我们一个被破坏的码字 C̃。

到目前为止，这与我们之前讨论的内容完全相同。

不同之处在于，现在鲍勃实际上并不想恢复爱丽丝的全部消息。相反，鲍勃只想恢复爱丽丝消息的一部分，或者可能是码字的一部分。在这个例子中，也许鲍勃只想要码字的第七个符号 C[7]。

敏锐的观众会意识到，如果爱丽丝和鲍勃使用的是纠错码，他们应该没问题。鲍勃可以读取整个被破坏的码字，修复错误，将其纠正以恢复原始码字 C，然后只看第七个符号。然而，这似乎有些浪费。鲍勃将要做很多工作，恢复爱丽丝发送的整个码字，却只是为了丢弃几乎所有内容，只保留第七个符号。

如果没有错误，鲍勃会直接查看第七个符号。如果他得到的码字 C 是一个数组，他可以在常数时间内完成，并且会很高兴。

问题是，如果坏人非常恶意，恰好篡改了第七个符号呢？

因此，我们的目标是让鲍勃做点别的事情。

我们希望鲍勃做的事情更接*于“直接查找第七个符号”，而不是“读取整个码字、进行解码、然后丢弃几乎全部内容”。

我们希望鲍勃能够做到的是，只查询这个码字的少数几个不同位置（可能包括也可能不包括第七个符号），并从这少数几个位置中，推导出他想要的信息。如果鲍勃能做到这一点，我们就说底层编码是一个局部可纠正码。

局部可纠正码的定义（初步尝试）

首先是一个快速警告：这不是最终的定义。我们需要稍作修改才能得到一个我们喜欢的定义。但让我们从这个开始。

这个定义说，一个码 C ⊆ Σ^n 是 (ρ, Q) 局部可纠正的，或者说它是一个 LCC，如果存在某个算法 B（这里的 B 代表鲍勃），使得以下条件对所有长度为 n 的接收字 W 成立：

W 接*某个码字。即，存在某个码字 C，使得 C 和 W 之间的（相对）汉明距离至多为 ρ。
对于所有位置 i，当我以查询访问 W 的方式运行这个算法，输入为 i 时，该算法至多对 W 进行 Q 次查询，并返回 C[i]，即码字的第 i 个符号。

这里，符号 B^{W}(·) 表示算法 B 可以访问一个包含 W 的数组。它可以在 O(1) 时间内访问 W 的任何系数 W[j]。这样的一次访问称为一次查询，我们的保证是至多进行 Q 次查询。

让我们画图说明这个定义。

和之前一样，我们有一个码字 C。然后某个坏人出现并破坏了这个码字。假设坏人至多破坏了 ρ 比例的位置，这将把码字 C 变成某个接收字 W，使得 W 和 C 之间的汉明距离（或相对汉明距离）至多为 ρ。

坏人还会想出一个索引 i，并要求鲍勃在给定这个被破坏的码字的情况下，恢复原始码字的第 i 个索引。

鲍勃，也就是我们的算法 B，拥有对这个字 W 的查询访问权。他最多可以进行 Q 次查询，方式任意。假设他查询这个位置、这个位置等等。注意，鲍勃可能会查询到被破坏的符号，他并不知道。

然后，鲍勃的工作就是按照对手的要求，恢复 C[i]。

我们的希望是 Q 不要太大，并且我们能够容忍一个常数比例的误差。也就是说，我们希望 Q 是 o(n)（即当 n 趋于无穷时，Q/n 趋于 0），并且希望 ρ 是 Θ(1)（即 ρ 是一个常数）。如果我们能做到这一点，那将非常棒。这意味着鲍勃可以用很少的信息恢复很少的信息，而不是为了恢复很少的信息而必须读取大量信息并花费大量时间解码。

为什么朴素定义不可行

然而，不幸的是，用这类参数实现这个定义是不可能的。你能看出为什么吗？如果看不出来，现在可以暂停视频思考一下。

之所以不可能，是因为如上所述，算法 B（即鲍勃）是确定性的。如果我是对手，我不会像之前那样做。相反，我会这样做：我知道每当我要鲍勃恢复 C[i] 时，他都会查询这些特定的位置。作为对手，我可以破坏一个常数比例的位置，而鲍勃查询的位置少于常数比例。我不会浪费我的“预算”去破坏鲍勃不会查询的位置。我只会破坏所有那些位置。这样一来，鲍勃只会得到垃圾信息。

因此，虽然这个定义非常理想，但不幸的是，它是不可能的。

局部可纠正码的正确定义

为了使它成为可能，并仍然允许鲍勃做一些有趣的事情，我们将允许鲍勃随机化他的查询。更准确地说，以下是局部可纠正码的实际定义。不同之处已用红色高亮显示。

我们说一个码 C ⊆ Σ^n 是一个 (ρ, Q, γ) 局部可纠正码 或 LCC，如果以下条件成立：
我们希望存在一个随机化算法 B，使得对于所有接*某个码字 C 的接收字 W（即 Δ(C, W) ≤ ρ），以及对于所有位置 i ∈ [n]，算法 B 拥有对 W 的查询访问权。它仍然最多进行 Q 次查询，但现在这些查询可以是随机的。我们仍然希望拥有查询访问权 W 的 B 在输入 i 时输出码字的第 i 个符号 C[i]。但现在我们允许一个小的失败概率，这个失败概率就是参数 γ。因此，我们希望这在查询的随机性上以至少 1 - γ 的概率成立。

现在的情况如下图所示。

我们拥有和之前相同的设置。但现在鲍勃在进行查询之前被允许抛一些硬币（做随机选择）。想象一下这是一枚正在抛出的硬币。鲍勃抛一些硬币，做出一些随机选择，基于这些随机选择，鲍勃将最多进行 Q 次查询。和之前一样，他应该得出 C[i]，但现在他只需要以高概率做到这一点。

注意，这一次，对手无法像上一张幻灯片那样玩同样的把戏，因为当他提出 i 和他的错误时，他并不知道鲍勃的硬币会如何落地。

好的，这就是局部可纠正码的定义。正如我们将在后续视频中看到的，实际上有可能获得具有非平凡参数的局部可纠正码。

其他局部性概念简介

在讨论具体构造之前，我想简要提一下其他几种局部性概念。

局部性广义上指的是鲍勃通过只查询码字的少数几个位置来局部获取一小部分信息的能力。有许多不同类型的编码以各种不同的方式展现出局部性。

我们刚刚看到的是局部可纠正码的定义。在这种情况下，鲍勃可以在存在最坏情况错误的情况下（至少以高概率）恢复任何符号 C[i]。

有一个非常相关的概念叫做局部可解码码 或 LDC。在这种情况下，鲍勃不想恢复任何 C[i]，而是想恢复任何 X[i]，即爱丽丝想要发送的消息的任何单个符号，同样是在存在最坏情况错误的情况下。注意，如果你的编码是系统码，那么消息符号会作为码字符号的一部分出现。在这种情况下，局部可纠正码比局部可解码码更强。

还有局部可测试码的概念，鲍勃只想进行几次查询，以判断码字是否看起来合法。

另一个概念是局部可修复码 或 局部可恢复码 或 LRC。在这种情况下，鲍勃希望仅通过几次查询来恢复 X[i] 或 C[i]（取决于上下文），但这是在存在最坏情况擦除而非最坏情况错误的情况下。

当然还有更多概念，但幻灯片上没地方了。从这些定义的激增可以看出，局部性在各个领域都有应用。

一个自然的例子是在存储中。也许你只想要数据的一小部分，但解码整个码字会很浪费。这就是局部可修复码有用的场景。LCC、LDC 和 LTC 等也有许多不同的应用，尤其是在复杂性理论和密码学中。我们将在后面的视频中看到这些不同类型局部性的一些应用。

总结

在本节课中，我们一起学*了局部可纠正码。我们首先了解了其应用场景和动机：接收者希望高效地恢复码字中的单个符号，而不是解码整个码字。我们发现了一个朴素的确定性定义是不可行的，因为对手可以针对性的破坏算法必然查询的位置。因此，我们引入了基于随机化算法的正确定义，该算法通过随机选择查询位置，以高概率正确恢复目标符号，从而挫败对手的针对性攻击。最后，我们还简要介绍了局部可解码码、局部可测试码和局部可修复码等其他局部性概念，认识到局部性在编码理论及相关领域具有广泛的应用价值。

在接下来的几个视频中，我们将探索具有非平凡参数的局部可纠正码的一些构造。

048：哈达玛码的局部校正

在本节课中，我们将学*第一个局部可校正码的例子——哈达玛码。我们将了解哈达玛码的定义、性质，并学*一个仅需两次查询即可对其进行局部校正的算法。

哈达玛码的定义

哈达玛码的维度为 M，长度为 2^M，其定义如下：

它是所有形如 F(α₁), F(α₂), …, F(α_{2^M}) 的向量的集合。

其中，αᵢ 是域 F₂^M 中的所有点，而函数 F 具有以下形式：

F(x₁, x₂, …, x_M) = Σ_{i=1}^M f_i * x_i

这个函数可以看作是系数向量 f 与变量向量 x 的内积。由于 f_i 有 2^M 种可能的取值，因此这样的函数 F 也有 2^M 个，所以该码的维度为 M。码的长度为 2^M，因为共有 2^M 个评估点。

因此，该码的码率为 M / 2^M，这个值非常小。就码率而言，这不是一个很好的码。

然而，这个码的距离特性非常好。你可以验证，该码的距离是 2^{M-1}，或者说相对距离是 1/2。因此，该码的距离非常大。

这个码适用于那些需要很大距离而对码率要求不高的应用场景。

哈达玛码作为局部可校正码

我们讨论哈达玛码的原因是，它恰好也是一个局部可校正码，其查询复杂度仅为 2。

接下来，我们将通过给出一个局部校正算法来证明哈达玛码是一个局部可校正码。

问题设定

该算法的输入包括：

对一个被损坏的码字 G 的查询访问权限。
我们想要评估的某个坐标的索引 α。

更具体地说：

G 是一个函数，它接收 F₂^M 中的输入，并输出 F₂ 中的一个比特。G 接*我们码中的某个函数 F，即 G 与 F 之间的汉明距离（两个函数不同的点数）最多为 p * 2^M，其中参数 p 严格小于 1/4。
F 对应我们的码字，其形式符合哈达玛码的定义。
我们的目标是输出对 F(α) 的一个猜测，并且希望这个猜测以较高的概率正确。

局部校正算法

以下是校正算法，非常简单：

随机选择一个 β ∈ F₂^M。
返回 G(β) + G(β + α)。

该算法仅对损坏的码字 G 进行了两次查询：在点 β 和 β + α。然后，它将这两个查询结果相加并输出。

算法正确性分析

我们的码字对应一个函数 F，其形式为：
F(x) = Σ_{i=1}^M f_i * x_i = <f, x>

当我们随机选择 β 时：

F(β) ≠ G(β) 的概率至多为 p（根据假设）。
同样，F(β + α) ≠ G(β + α) 的概率也至多为 p，因为对于固定的 α，β + α 在 F₂^M 中也是均匀随机的。

如果我们“幸运地”同时满足 F(β) = G(β) 和 F(β + α) = G(β + α)，那么算法的输出将是：
G(β) + G(β + α) = F(β) + F(β + α) = <f, β> + <f, β + α> = <f, β> + <f, β> + <f, α> = <f, α> = F(α)

这正是我们想要的结果。

根据并集界，我们“幸运”的概率至少为 1 - 2p。因此，算法的失败概率至多为 2p。

定理总结

我们已经证明了以下定理：
长度为 2^M 的哈达玛码，对于任何 p，都是一个 (p, 2, 2p) 局部可校正码。

特别地，当 p < 1/4 时，失败概率 2p < 1/2，这提供了非平凡的校正保证。

算法观察

我们的算法和分析之所以有效，是因为两个查询各自单独来看，其分布都是均匀随机的。然而，这两个查询合在一起并不是独立的，它们高度相关：它们的和始终等于我们想要查询的值 α。

这将是局部可校正码中的一个常见主题：

每个查询单独来看应该是均匀随机的（或接*均匀随机），否则对手可能会针对性地破坏它。
然而，通过构造查询的联合分布，使得每个查询单独是随机的，但联合分布并非均匀随机，我们就能在“欺骗”对手的同时，为自己获取有用的信息。

延伸思考

这个定理可能引出一个问题：我们有一个查询复杂度仅为 2 的优秀局部可校正码，但其码率非常糟糕。我们可能会问：能否做得更好？

即，是否存在一个参数 p 为常数、失败概率 γ 非平凡的 2 查询局部可校正码，其码率比哈达玛码更好？具体来说，我们能否让码长渐进地小于 2^{消息长度}？

这听起来要求不高，但事实证明，对于 2 查询的局部可校正码，我们实际上无法做得比这好太多。

然而，如果我们允许查询复杂度略高于 2，我们将能够获得更好的结果。我们将在下一个视频中看到这一点。

总结

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

哈达玛码的定义和基本性质：它是一个码率低但距离大（相对距离为1/2）的线性码。
哈达玛码的局部校正：我们介绍了一个简单而高效的算法，仅需两次随机查询即可高概率地恢复码字中任意位置的值，证明了哈达玛码是一个 (p, 2, 2p) 局部可校正码。
算法背后的关键思想：利用查询点的随机性和相关性（其和固定为目标点）来对抗错误，同时保证校正的有效性。
对更高码率LCC的展望：我们认识到仅用两次查询难以显著提升码率，这为后续学*查询复杂度更高的局部可校正码做好了铺垫。

049：局部纠正里德-穆勒码

在本节课中，我们将学*里德-穆勒码的局部纠正算法。我们将看到，通过查询码字中沿一条随机线上的点，并利用里德-所罗门码的解码能力，可以高效地恢复被损坏码字中的单个符号。

定义与回顾

上一节我们介绍了里德-所罗门码，本节中我们来看看它的多元推广——里德-穆勒码。

首先，我们给出里德-穆勒码在任意域 Fq 上的定义。设 m 为变量个数，r 为总度数上限。

定义：参数为 (m, r) 的 q 元里德-穆勒码 RM_q(m, r) 定义如下：

令 α_1, …, α_{q^m} 为域 F_q^m 中所有向量（顺序任意但固定）。
考虑所有定义在 F_q 上、变量数为 m、总度数不超过 r 的多项式集合。
将每个这样的多项式在所有点 α_i 上求值，得到的向量即为一个码字。

用公式表示，码 C 为：
C = { (f(α_1), …, f(α_{q^m})) | f ∈ F_q[x_1, …, x_m], deg(f) ≤ r }

以下是关于此定义的两点说明：

与里德-所罗门码的关系：当 m = 1 时，里德-穆勒码退化为里德-所罗门码。具体来说，RM_q(1, r) 等价于定义在 F_q 上、码长 n = q、维度 k = r + 1 的里德-所罗门码。
与哈达玛码的关系：在 F_2 上、变量数为 m、次数为 1 的里德-穆勒码，与之前介绍的哈达玛码非常相似。主要区别在于哈达玛码仅考虑无常数项的线性多项式，而里德-穆勒码允许包含常数项。

因此，里德-穆勒码的定义统一并推广了我们之前见过的两种编码。

局部纠正的基本思想

本节我们将看到，里德-穆勒码是局部可纠正码。让我们从双变量（即 m = 2）的情形开始理解其核心思想。

我们可以将一个码字可视化为一个正方形网格，每个网格点对应一个求值点 (α, β) ∈ F_q × F_q。网格点 (α, β) 处存储的值是某个低次二元多项式 f 在该点的求值结果 f(α, β)。

假设我们想恢复被损坏码字中位置 (α, β) 的值 f(α, β)。一个敌手可能已经损坏了比例为 p 的符号，甚至可能包括我们想要查询的点。

为了恢复，我们考虑一条穿过点 (α, β) 的随机直线。在有限域上，这样一条直线可以参数化表示为：
L(z) = (α + σz, β + τz), 其中 (σ, τ) ∈ F_q^2 \ {(0,0)} 为随机选择的“斜率”。

关键观察在于：当我们把二元多项式 f 限制在这条直线 L 上时，我们得到了一个关于单变量 z 的多项式 h(z) = f(L(z))。由于 f 的总度数不超过 r，因此 h(z) 的次数也不超过 r。

现在，如果我们沿着这条直线查询被损坏的码字，得到的将是一个被轻微损坏的低次单变量多项式（里德-所罗门码字）的求值点集合。这正是我们熟悉的问题：从损坏的求值点中解码里德-所罗门码。

因此，基本思路是：查询沿一条随机直线的点，然后使用里德-所罗门解码器来纠正线上的错误，从而恢复出原点 (α, β) 的值。

双变量里德-穆勒码的局部纠正算法

基于上述思想，以下是针对域 F_q 上、次数为 r 的双变量里德-穆勒码的局部纠正算法。

算法输入：

对一个函数 g: F_q^2 → F_q 的查询权限。该函数 g 与某个次数 ≤ r 的多项式 f 在至少 (1-p) 比例的点上一致。
我们想要查询的点 (α, β)。

算法目标：以高概率输出 f(α, β) 的正确值。

算法步骤：

选择随机线：均匀随机地选择斜率 (σ, τ) ∈ F_q^2 \ {(0,0)}，构造穿过 (α, β) 的直线 L(z) = (α + σz, β + τz)。
查询线上点：对于所有 z ∈ F_q，查询 g(L(z))，得到序列 \tilde{h}(z) = g(L(z))。
里德-所罗门解码：在序列 \tilde{h} 上运行里德-所罗门解码器（例如 Berlekamp-Welch 算法），寻找一个次数 ≤ r 的多项式 h，使得 h 与 \tilde{h} 的汉明距离严格小于 (q - r)/2。
输出结果：如果找到这样的 h，则输出 h(0)。

算法原理：如果算法成功（即线上错误不多），那么找到的 h(z) 将等于 f(L(z))。因此，h(0) = f(L(0)) = f(α, β)，这正是我们想要的结果。

算法成功概率分析

算法并非总能成功。如果我们不幸选择了一条包含过多错误的直线，里德-所罗门解码就会失败。

成功条件：算法成功当且仅当直线 L 上的错误数量不超过 ⌊(q - r)/2⌋。这是次数为 r 的里德-所罗门码的解码半径。

成功概率下界：对于任意错误比例 p > 0，该算法成功的概率至少为 1 - (2p(q+1))/(q - r - 1)。

证明概要：

计算线上错误的期望值：线上点总数是 q。点 (α, β) 可能被损坏。对于其他 q-1 个点，由于直线是随机选择的，每个点都是 F_q^2 中的均匀随机点，因此该点被损坏的概率不超过 p。利用期望的线性性质，线上错误数量的期望值 E[errors] ≤ 1 + p(q-1) < pq + 1。
应用马尔可夫不等式：设 T = ⌊(q - r)/2⌋ 为最大可容忍错误数。算法失败（即错误数 > T）的概率为：
Pr[failure] ≤ E[errors] / T ≤ (pq + 1) / ((q - r - 1)/2) = (2p(q+1))/(q - r - 1)。

因此，算法成功的概率至少为 1 减去上述值。

一个重要推论

基于上述分析，我们可以得到一个具体的、具有良好参数的局部可纠正码。

推论：对于任意 p > 0，考虑定义在 F_q 上、变量数 m=2、次数 r = q/2 的里德-穆勒码。该码的码长 n = q^2，字母表为 F_q。
它是一个局部可纠正码，具有以下参数：

查询复杂度：q = √n。
可容忍错误比例：p（一个小于 1/4 的小常数）。
失败概率 γ：约等于 4p（当 n 很大时）。
码率 R：约等于 1/8。

说明：

查询复杂度：算法查询一条直线上的所有点，共 q 个。由于 n = q^2，故 q = √n。
失败概率：将 r = q/2 代入成功概率公式，得到失败概率上界约为 4p。
码率：维度 k 是满足 a + b ≤ q/2 的单项式 x1^a x2^b 的数量，其数量约为 q^2/8。因此码率 R = k/n ≈ (q^2/8) / q^2 = 1/8。

这个结果非常出色：我们得到了一个具有常数码率（约1/8）、能处理常数比例错误、且查询复杂度仅为 O(√n) 的局部可纠正码。虽然查询复杂度比哈达玛码的 2 要大，但它远小于 n，并且码率从指数级小提升到了常数级。

推广至多变量与参数权衡

上述“随机线”思想可以自然地推广到变量数 m > 2 的里德-穆勒码。通过选择 F_q^m 中的随机直线并执行相同操作，我们可以在不同的参数之间进行权衡。

下表展示了通过选择不同的变量数 m 和次数 r，里德-穆勒码所能达到的各类局部可纠正码的参数范围：

目标查询复杂度 (Q)	所需码长 (n) 与维度 (k) 的关系	对应里德-穆勒码参数选择
2	n ≈ 2^k (指数级)	m 任意, r = 1 (类似哈达玛码)
log n	n = poly(k) (多项式级)	m ≈ q / log q, r 相应选择
n^ε (小常数 ε)	n = O(k) (线性级，常数很大)	m 为常数，r 相应选择
√n	n ≈ 8k (线性级，常数较小)	m = 2, r = q/2 (本节案例)

以下是关于此表的几点说明：

查询复杂度为2：这对应于哈达玛码，其码长是指数级的，码率极低。
查询复杂度为log n：使用里德-穆勒码可以达到，且码长仅是维度的多项式倍。据我们所知，这是目前最好的构造。
查询复杂度为n^ε：通过选择合适的常数 m，可以让码长 n 与维度 k 呈线性关系，但系数随 ε 减小而急剧增大。
查询复杂度为√n：这就是我们本节详细讨论的双变量情况，在常数码率下实现了次线性的查询复杂度。

对于某些参数区间（例如查询复杂度为 n^ε），存在比基本里德-穆勒码更优的构造，可以获得接* 1 的码率。这通常通过对里德-穆勒码进行巧妙的推广来实现。

总结

本节课中我们一起学*了里德-穆勒码的局部纠正。

我们首先回顾并定义了多元域上的里德-穆勒码。
我们以双变量情形为例，阐述了其局部纠正的核心思想：通过查询一条随机直线，将多元多项式求值问题转化为单变量（里德-所罗门码）的解码问题。
我们给出了具体的局部纠正算法，并分析了其成功概率。
我们得到了一个重要的具体实例：一个码率约 1/8、查询复杂度 O(√n)、能容忍常数比例错误的局部可纠正码。
最后，我们看到了这一思想可推广至多变量，从而在不同的查询复杂度和码率/码长之间进行灵活的权衡，使得里德-穆勒码成为构建各类非平凡局部可纠正码的强大工具。

代数编码导论：1：动机：学*布尔函数

在本节课中，我们将学*如何将列表解码和局部解码的概念结合起来，探讨局部列表解码。我们将通过一个学*布尔函数的应用问题来引出这个主题。

在之前的课程中，我们介绍了列表解码和局部解码。本节中，我们来看看如何将这两个概念结合，形成局部列表解码。我们将通过一个学*布尔函数的应用问题来引出这个主题。

以下是本视频要讨论的核心问题。假设存在一个函数 G，它接收一个定义在 F₂ 上的长度为 M 的向量，并输出 +1 或 -1。你可以任意查询 G 在任意 X 上的值，但最初你并不知道 G 的具体形式。你的目标是尽可能快地学* G，或者至少学*它的一个*似 G̃。

理想情况下，你希望学*过程的时间复杂度是 M 的多项式。具体来说，你不能简单地查询 G 在所有 X 上的值，因为那样需要 2ᴹ 的时间，这不是 M 的多项式。显然，如果 G 可以是任意函数，那么查询它在某个 X 上的值并不能告诉我它在另一个 X 上的值。因此，我们必须对 G 施加一些结构，才能使学*成为可能。

一种有用的施加结构的方法是假设 G 在傅里叶域中是稀疏的。为了更清晰地定义这一点，我们需要一些额外的定义。

以下是定义在 F₂ 上的傅里叶变换，针对像上一张幻灯片中那样的函数 G。G 在 F₂ 上的傅里叶变换记为 Ĝ，它是另一个从 F₂ᴹ 到实数的函数，定义如下：

Ĝ(ω) = (1 / 2ᴹ) * Σ_{x ∈ F₂ᴹ} [ G(x) * (-1)^{<x, ω>} ]

如果你熟悉复数域上的傅里叶变换，这看起来可能有些熟悉。特别是，它类似于复数域上的离散傅里叶变换，只不过我们用 (-1)^{<x, ω>} 代替了 e^{-iπ...} 这样的项。

与复数域类似，这个定义也满足一些相似的性质。特别是，我们有一个逆变换，可以将 G(x) 写为：

G(x) = Σ_{ω ∈ F₂ᴹ} [ Ĝ(ω) * (-1)^{<x, ω>} ]

这些 Ĝ(ω) 被称为傅里叶系数。我们还有帕塞瓦尔定理，它表明傅里叶变换不影响 L² 范数。更精确地说：

(1 / 2ᴹ) * Σ_{x ∈ F₂ᴹ} G(x)² = Σ_{ω ∈ F₂ᴹ} Ĝ(ω)²

在这个设定中，由于 G(x) 是 ±1，所以左边恰好等于 1。

这就是傅里叶变换。如果你之前没见过这个定义，本视频中重要的是这个方程：我们可以将 G(x) 写成这些简单函数 (-1)^{<x, ω>} 的线性组合，系数就是傅里叶系数 Ĝ(ω)。这很好，因为这些函数非常简单易懂，允许我们将任何函数表示为简单易懂函数的线性组合。

现在，让我们回到学*布尔函数 G 的问题。如前所述，我们需要对 G 施加一些结构。

以下是我们要施加的结构。正如上一张幻灯片所示，我们可以将 G(x) 展开为那些简单函数的线性组合。我们假设只有少数系数是大的，而大多数系数是小的。也就是说，我们假设 G 是一个简单函数，本质上它只是不多于这些简单函数的线性组合。

在这种情况下，我们可以将 G *似地写为仅由那些大系数对应的函数组成的线性组合。也就是说，我们丢弃所有 |Ĝ(ω)| 小于某个常数 τ > 0 的项。我们的目标将是尽可能快地估计那些大的 Ĝ(ω)，同样希望时间复杂度是 M 的多项式。

更详细地说，以下是这个特定问题的目标。假设 τ 是某个大于零的常数。给定对 G(x) 的查询权限（G 具有这样的傅里叶展开，使得大多数傅里叶系数很小），我们希望返回一个由 （ω, y_ω） 对组成的列表 ℒ，使得如果傅里叶系数 Ĝ(ω) 很大（大于 τ），那么 ω 就出现在我们的列表中。此外，对于列表中出现的所有 ω，我们的估计值 y_ω 应*似等于 Ĝ(ω)。我们希望在 M 的多项式时间内找到这个列表。注意，这意味着列表本身的大小不能超过 M 的多项式，否则仅仅返回它就需要更长的时间。

如果我们能做到这一点，并且满足类似这样的假设，那么我们就能够估计这个展开式，从而估计这个函数。

讨论这个问题时，我们发现它与编码理论中的一个问题相关。为了将其转化为你可能认得出的编码理论问题，让我们开始调整这个目标。

我们要做的第一个简化源于以下观察：给定一个固定的 ω ∈ F₂ᴹ，我们可以从不太多的样本中相当快地估计出 Ĝ(ω)。原因是 Ĝ(ω) 的定义是一堆形如 G(x) * (-1)^{<x, ω>} 的项的平均值，每一项都是 ±1。我们可以通过采样 G(x) 来计算出其中任何一项。因此，我们可以通过随机抽取这些项的一个子集，采样它们，并取平均值来估计这个平均值。事实证明，如果你取不太多的样本，那么以高概率，这将是对这个平均值的一个相当好的估计。

这意味着我们的目标可以简化为仅仅找到使得 Ĝ(ω) 很大的 ω 的集合，因为一旦我们找到这个集合，我们就可以相当快地估计它们中的每一个。

更精确地说，我们可以如下修改我们之前的目标：首先，我不再需要返回 （ω, y_ω） 对，我可以只返回 ω。其次，我不需要在这里估计 Ĝ(ω)。我将通过允许对 G(x) 的查询访问是随机化的，来给自己多一点灵活性，并要求这个要求只以高概率成立。例如，对于每个傅里叶系数很大的 ω，我们希望 ω 以至少 2/3 的概率出现在这个列表中。像往常一样，这里的 2/3 是任意的；如果我们能以 2/3 的概率做到，我们只需重复几次就能以 0.99999 的概率做到。

以下是清理后的目标版本：给定对我们函数 G: F₂ᴹ → {±1} 的查询权限，找到一个列表 ℒ ⊆ F₂ᴹ，使得对于所有满足 |Ĝ(ω)| > τ 的 ω，ω 以至少 2/3 的概率最终出现在列表中。此外，我们希望在 M 的多项式时间内找到这个列表。特别是，列表的大小不能超过 M 的多项式。

我们仍然不太清楚这与编码理论有什么关系，尽管可能越来越接*了。我们正在寻找一个可能与某些函数高度一致的“事物”列表。为了使其精确，让我们进一步调整这个要求。

为简单起见，我将去掉绝对值。基本上，你可以做我现在要做的事情，只是前面加一个负号，然后把两者结合起来，就会得到绝对值。但我现在先忽略它们。

让我们考虑条件 Ĝ(ω) ≥ τ。我们可以写出 Ĝ(ω) 的定义，并看到这等价于这个大和大于等于 τ。现在，回想一下这里的 G(x) 是 ±1。这意味着这个和中的每一项也是 ±1，取决于 G(x) 是否等于符号翻转项 (-1)^{<x, ω>}。

这意味着我们可以这样写这个条件：我们可以用使得 g(x) 等于 (-1)^{<x, ω>} 的 x 的数量来替换这个和。在这种情况下，和中的项等于 1 减去使得 g(x) 不等于 (-1)^{<x, ω>} 的 x 的数量，此时和中的项等于 -1。注意，这正好等于 2ᴹ 减去那个数量，因为要么相等，要么不相等。

因此，我们可以将这个条件重写如下：即，我刚刚用 2ᴹ 减去那个数量替换了它。现在我们可以移动一些符号，得到以下条件：使得 g(x) 等于 (-1)^{<x, ω>} 的 x 的比例略大于二分之一，大于等于 1/2 + τ/2。

现在，我将定义一个新函数 g(x)，它是大 G(x) 的 0/1 版本。即，如果 G(x) = +1，则 g(x) = 0；如果 G(x) = -1，则 g(x) = 1。在这种记法下，上述条件等价于：使得 g(x) 等于 <x, ω> 的 x 的比例大于二分之一，具体来说，大于等于 1/2 + τ/2。

那么，这与编码理论有什么关系呢？基本上，这表示我们的目标是找到所有这样的 ω，使得评估向量 <x, ω> 与某个函数 g（我们称之为接收字 g）之间的一致率很高，略大于二分之一。换句话说，我们想找到所有 ω，使得如果我们考虑所有这些内积组成的向量，它与 g 的距离不太大。这听起来有点像列表解码。如果你还记得之前的视频，它可能有点像列表解码哈达玛码。

更详细地说，让我们回顾一下之前视频中哈达玛码的定义。H(m) 等于向量的集合：对于所有 ω ∈ F₂ᴹ，有 （<ω, x₁>, <ω, x₂>, ..., <ω, x_{2ᴹ}>），其中 x₁, x₂, ..., x_{2ᴹ} 是 F₂ᴹ 中所有点按某种顺序的枚举（顺序无关紧要）。也就是说，哈达玛码是所有向量的集合，这些向量由 F₂ᴹ 上的某个线性函数在所有点上的取值构成。

现在，我们可以用关于哈达玛码的编码理论目标来重新表述上一张幻灯片的目标。我们在上一张幻灯片看到，条件 Ĝ(ω) ≥ τ 等价于条件：使得 g(x) 等于 <x, ω> 的 x 的比例略大于二分之一，大于等于 1/2 + τ/2。

用哈达玛码的语言来说，另一种表述方式是：接收字 g（这里 g 表示在所有点上评估 G 得到的向量）与在哈达玛码下 ω 的编码（即这个向量）之间的相对距离略小于二分之一，小于等于 1/2 - τ/2，其中 τ > 0。

也就是说，我们被授予对接收字 g 的访问权限，并且我们想要找到所有形式为 ω 的编码的码字，使得 g 与 ω 的编码之间的距离至多为 1/2 - τ/2。我们希望以 M 的多项式时间完成这个任务。所以我们的目标是对哈达玛码进行列表解码：我们想要找到所有位于接收字某个球内的码字。

关键是我们希望仅通过少量查询在局部完成这个任务。特别是，我们这里的时间预算是 M 的多项式，这相对于码的块长度是亚线性的。记住，码的块长度是 2ᴹ。因此，我们甚至没有时间查看整个码字。这就是为什么我们必须局部地进行解码。在下一个视频中，我们将看到如何实现这个目标。

本节课中，我们一起学*了如何将一个学*布尔函数的问题转化为对哈达玛码进行局部列表解码的编码理论问题。我们首先定义了傅里叶变换，并假设目标函数在傅里叶域中是稀疏的。然后，我们逐步将学*问题转化为寻找与接收字有高一致性的码字列表的问题，并强调了在亚线性时间内（即局部地）完成此任务的需求。这为下一节讨论具体的局部列表解码算法奠定了基础。

051：Goldreich-Levin 算法

在本节课中，我们将学* Goldreich-Levin 算法。该算法能够在亚线性时间内对 Hadamard 码进行列表解码，从而解决我们在上一节课末尾提出的问题。

回顾与目标

上一节我们介绍了 Hadamard 码的定义，它由所有在 F₂^m 上的线性函数的求值向量组成。我们的目标是在亚线性时间内对其进行列表解码。

具体来说，给定对一个函数 G: F₂^m → F₂ 的查询访问权限，我们的目标是找到一个列表 ℒ，其计算时间关于 m 是多项式的。对于任意满足 dist(G, Enc(w)) ≤ 1/2 - ε 的 w，我们希望 w 以至少 2/3 的概率出现在列表 ℒ 中。

请注意，我们要求亚线性时间，因为 Hadamard 码的码字长度是 2^m，而我们必须在关于 m 的多项式时间内找到列表，这意味着我们甚至没有时间查看整个接收到的码字。

第一次尝试：基于局部解码算法

我们首先尝试使用之前学过的 Hadamard 码的局部解码算法来解决这个问题。

以下是算法步骤。我们被给予对函数 G 的查询访问权限，目标是找到某个 w，使得在 Hadamard 码下，Enc(w) 与 G 的汉明距离至多为 p（p 是某个参数）。在第一次尝试中，我们假设 p < 1/4。

随机均匀地选取向量 β₁, ..., β_T ∈ F₂^m，其中 T 是一个稍后确定的参数。
对于每个 i ∈ {1, ..., m}，执行以下操作：
- 对于每个 t ∈ {1, ..., T}，计算 w_i 的一个估计值 w̃_i^{(t)}。计算方法是：w̃_i^{(t)} = G(e_i + β_t) + G(β_t)。这是之前学过的两查询局部校正算法。
- 根据之前视频的分析，这个估计值等于 w_i 的概率至少为 1 - 2p。
- 由于 p < 1/4，这个成功概率严格大于 1/2。我们重复 T 次独立实验，通过多数表决来提升成功概率。
对于每个 i，取所有 w̃_i^{(t)} 的多数表决结果作为最终的 w̃_i。
将所有 w̃_i 组装成向量 w̃。

使用切比雪夫不等式可以证明，当 p < 1/4 时，w̃ 不等于正确 w 的概率是 O(1/T)。通过对所有 m 个 i 取并集，失败概率至多为 O(m/T)。如果我们选择 T = O(m)，可以使这个概率小于 1/3。

因此，对于任何满足 dist(Enc(w), G) ≤ p 且 p < 1/4 的 w，这个算法将以至少 2/3 的概率返回那个 w。

这个算法的问题在于，我们的目标 p 值应接* 1/2（即 1/2 - ε），而这里我们受限于 p < 1/4。当 p 接* 1/2 时，可能不再有唯一的码字在距离 p 内，因此我们需要列表解码。

第二次尝试：借助“魔法精灵”

作为热身，我们假设可以访问一个“魔法精灵”，它心中有一个满足条件的 w。

算法步骤如下：

如前所述，随机选取 β₁, ..., β_T。
向精灵询问比特 b₁, ..., b_T，其中 b_t = <w, β_t>（w 是精灵心中的向量）。
对于每个 i 和 t，计算 w̃_i^{(t)} = b_t + G(e_i + β_t)。
同样进行多数表决并组装成 w̃。

分析表明，由于精灵总是给出关于 w 的正确信息，这一步的成功概率变为 1 - p（之前是 1 - 2p）。因此，只要 p < 1/2，多数表决失败的概率就是 O(1/T)。通过选择 T = O(m)，我们可以使整体失败概率小于 1/3。

这个算法允许 p 任意接* 1/2。但显然，我们无法访问这样的魔法精灵。

第三次尝试：穷举所有可能的精灵

一个自然的想法是：穷举所有可能的精灵（即所有可能的答案序列），并生成一个列表。

算法步骤如下：

随机选取 β₁, ..., β_T。
初始化列表 ℒ 为空集。
穷举所有可能的答案序列 (b₁, ..., b_T) ∈ F₂^T。
- 对于每个序列，假设精灵会给出这些答案，并运行第二次尝试的算法，得到一个候选向量 w̃。
- 将 w̃ 加入列表 ℒ。
返回列表 ℒ。

对于任何满足条件的 w，存在一个与之对应的精灵答案序列。当算法迭代到那个序列时，根据第二次尝试的分析，w̃ 等于 w 的概率很高。因此，w 将以高概率出现在最终列表 ℒ 中。

然而，这个算法的运行时间不再关于 m 是多项式的。为了达到高成功概率，我们需要 T = O(m)，但穷举所有 2^T 个序列需要 2^Ω(m) 的时间，这过于缓慢。

最终算法：使用成对独立性

问题的关键在于，在第二次尝试的分析中，切比雪夫不等式只需要 β_t 之间是成对独立的，而不需要完全独立。我们可以用更少的随机向量，通过线性组合来生成大量成对独立的向量，从而减少需要穷举的精灵答案数量。

设 L = log₂ T。我们只随机选取 L 个向量 β₁, ..., β_L ∈ F₂^m。对于任意子集 A ⊆ {1, ..., L}，定义 β_A = Σ_{t∈A} β_t。可以证明，这样生成的 {β_A} 是成对独立的，并且共有 2^L = T 个这样的向量。

类似地，对于任意比特序列 (b₁, ..., b_L) ∈ F₂^L 和子集 A，定义 b_A = Σ_{t∈A} b_t。

最终的 Goldreich-Levin 算法如下：

随机选取 β₁, ..., β_L ∈ F₂^m，其中 L = O(log m)（因为 T = O(m)）。
初始化列表 ℒ 为空集。
穷举所有可能的“精简精灵”答案序列 (b₁, ..., b_L) ∈ F₂^L。
- 对于每个序列，构造一个“精灵”，对于每个子集 A，其输出为 b_A。
- 使用这个精灵和成对独立的向量集 {β_A}，运行第二次尝试的算法，得到一个候选向量 w̃。
- 将 w̃ 加入列表 ℒ。
返回列表 ℒ。

算法分析：

正确性：对于任何满足 dist(Enc(w), G) ≤ 1/2 - ε 的 w，存在对应的 (b₁, ..., b_L) 序列（由 b_t = <w, β_t> 定义）。当成对独立的向量 β_A 和由此构造的精灵答案 b_A 被使用时，第二次尝试的分析依然成立。因此，w 将以高概率出现在列表 ℒ 中。
运行时间：内部算法（第二次尝试）运行时间是 poly(m)。外层循环需要穷举 2^L = 2^{O(log m)} = poly(m) 个序列。因此，总运行时间是 poly(m)。

总结

本节课我们一起学*了 Goldreich-Levin 算法。我们首先回顾了在亚线性时间内列表解码 Hadamard 码的目标。接着，我们从基础的局部解码算法出发，通过引入“魔法精灵”的概念和利用成对独立性的技巧，逐步构建出了最终的算法。该算法对于任何满足 dist(Enc(w), G) ≤ 1/2 - ε 的 w，都能以至少 2/3 的概率在 poly(m) 时间内将其包含在输出列表中，从而实现了 Hadamard 码的局部列表解码。这一定理在布尔函数学*等领域有重要应用，我们将在下节课继续探讨。

052：局部列表解码 🧩

在本节课中，我们将正式定义局部列表解码，并探讨其若干应用。我们将结合图示来解析这个定义，并回顾之前视频中已经见过的一个局部列表解码算法实例。

概述

局部列表解码结合了局部解码和列表解码的思想。它允许解码算法在仅查询接收到的码字的一小部分的情况下，输出一个可能包含多个候选码字的列表，并且对于列表中每个接*接收字的码字，都存在一个对应的“局部解码器”能以高概率恢复该码字的任意指定符号。

局部列表解码的正式定义

我们称一个码 C ⊆ Σᴺ 是 (Q, P, L) 局部列表可解码的，如果存在一个随机化算法 A，它能输出最多 L 个其他算法 B₁, B₂, ..., B_L，并满足以下条件：

首先，明确每个算法 Bᵢ 的输入输出类型。对于每个 i 在 1 到 L 之间：

算法 Bᵢ 的输入是一个介于 1 和 N 之间的整数 j。
Bᵢ 拥有对接收字 z ∈ Σᴺ 的预言访问权限。
给定对 z 的预言访问和输入 j，Bᵢ 最多向 z 进行 Q 次查询。
它的输出是对某个码字第 j 个符号的猜测。

其次，对于所有 z ∈ Σᴺ 和所有与 z 的相对汉明距离在 P 以内的码字 c ∈ C（即 Δ(c, z) ≤ P），都存在一个 Bᵢ 能很好地局部解码该码字。更精确地说：

存在一个 i（介于 1 和 L 之间），使得对于所有索引 j（介于 1 和 N 之间），算法 Bᵢ 在拥有对 z 的预言访问权限下，输入 j，输出 cⱼ 的概率至少为 2/3。

这个定义包含了许多量词，接下来我们将用图示来分解它。

通过图示理解定义

我们的图示结合了列表解码和局部解码的示意图。

在列表解码中，对于任何向量 z，在以 z 为中心、半径为 P 的汉明球内，最多有 L 个码字。假设图中 L = 3，那么接* z 的码字只有三个：c₁, c₂, c₃。

在局部解码中，Bob 只对底层码字的某一个符号感兴趣，并通过向 Alice 发送的（可能损坏的）码字进行少量查询来找出它。

现在的区别在于，在这个场景中，没有单一的“正确”码字，而是有三个。因此，我们不能只有一个 Bob，而是需要 L 个 Bob（图中是三个）。每个 Bob 对应一个可能的正确码字：

Bob₁ 对应 c₁，他的职责是在输入 j 时，通过查询 z，以高概率返回 c₁ 的第 j 个符号。
Bob₂ 对应 c₂，负责恢复 c₂ 的第 j 个符号。
Bob₃ 对应 c₃，负责恢复 c₃ 的第 j 个符号。

这些 Bobᵢ 就对应定义中的算法 Bᵢ。对于每个接* z 的码字 c，都存在一个对应的 Bob，其任务就是充当该码字的一个良好的局部解码算法。

一个我们已经见过的例子：Goldreich-Levin 算法

在回顾定义时，你可能已经注意到，我们实际上已经见过一个局部列表可解码码的例子。具体来说，我们在上一个视频中看到的 Goldreich-Levin 算法，其核心部分就是一个针对哈达玛码的局部列表解码器。

我们可以用更接*上述定义的方式重写该算法：

算法描述：
我们被给予对某个函数 g 的查询访问权限，我们希望恢复所有满足“w 的哈达玛编码与接收字 g 的相对距离在 P 以内”的 w。也就是说，我们希望每个这样的 w 能以至少 2/3 的概率出现在输出列表中。

算法步骤如下：

抽取一些随机变量。
初始化一个空列表。
循环遍历一组比特向量 b₁, ..., b_L。
对于每个 w，如果建议 b₁, ..., b_L 与 w 一致，那么存在一个“精灵”算法 B_{b₁,...,b_L}（现在我们称它为 Bob），使得 B_{b₁,...,b_L} 在输入 j 时，能以高概率输出 w 与 eⱼ 的内积（即哈达玛码编码 w 的第 j 位）。
我们调用这个 Bob 来恢复 w 的所有 M 个比特，从而组装出 w，并将其加入列表。

其中，蓝色标注的步骤正是一个符合之前定义的局部列表解码器。

因此，我们在上一个视频中实际证明的是：哈达玛码是 (Q, P, L) 局部列表可解码的，其中半径 P 可以是任何严格小于 1/2 的数，查询复杂度 Q 和列表大小 L 都是 M 的多项式。

局部列表解码的应用

局部列表解码看似一个特殊的定义，但实际上它有广泛的应用。我们已经见过一个应用，它也是我们几个视频前开始整个讨论的起点。

应用一：学*傅里叶域稀疏的布尔函数

让我们回顾一下几个视频前的设定。我们有一个函数 G: 𝔽₂ᴹ → {+1, -1}，并将其写成傅里叶展开形式。如果 G 的傅里叶谱足够“尖峰”（即大多数系数很小，少数几个很大），那么从查询中*似 G 本质上等同于找到所有满足“ω 的哈达玛编码与 g（G 的 {0,1} 版本）的相对汉明距离 ≤ (1/2 - τ/2)”的 ω。而这正是我们的局部列表解码器让我们做的事情。

对于这个应用，我们确实同时需要“局部”和“列表”两部分：

我们需要“局部”性，因为期望的运行时间是 M 的多项式，而这是亚线性于码长 2ᴹ 的。
我们需要“列表”性，因为我们想要达到的译码半径需要接* 1/2。如果只做唯一解码，我们只能达到 1/4。

在布尔函数学*的语境中，我们之前看到的针对哈达玛码的局部列表解码算法被称为 Kushilevitz-Mansour 算法。

应用二：密码学（Goldreich-Levin 定理）

当我们介绍哈达玛码的局部列表解码算法时，我称它为 Goldreich-Levin 定理。实际上，Goldreich 和 Levin 最初感兴趣的应用来自密码学。

Goldreich-Levin 定理指出：单向函数蕴含伪随机生成器。事实证明，这个陈述可以从哈达玛码的局部列表可解码性推导出来。更多细节请查阅课程讲义。

应用三：复杂性理论（硬度放大）

基于之前对局部可校正码的讨论，你可能会想到另一个候选码：里德-穆勒码。事实上，里德-穆勒码也可以被局部列表解码，这应用于复杂性理论。

特别是，Sudan、Trevisan 和 Vadhan 展示了如何局部列表解码里德-穆勒码，并将其用于硬度放大。即，他们可以利用这一点，将一个平均情况下难以计算的函数，转化为一个最坏情况下难以计算的函数。这对复杂性理论和伪随机性有重要意义。同样，更多细节请参考相关论文。

总结

本节课我们一起学*了局部列表解码的正式定义。我们通过图示将其分解，并认识到 Goldreich-Levin 算法实质上是哈达玛码的一个局部列表解码器。最后，我们探讨了局部列表解码在多个领域的应用，包括学*布尔函数、密码学（Goldreich-Levin 定理）以及复杂性理论中的硬度放大。尽管局部列表解码的定义初看可能有些刻意，但它实际上自然出现在众多应用中，并催生了一些非常精妙的算法。

053：再生码

在本节课程中，我们将定义再生码，这是一种在分布式存储中非常有用的编码。

我们将聚焦于一个典型的分布式存储系统示例。假设我们有一个文件 F，我们希望将其存储在一系列存储节点上，图中用黑色方块表示。

一种方法是首先使用我们喜欢的纠错码对文件 F 进行编码。这样我们得到一个码字。然后，我们将这个码字的每个符号分别发送到不同的存储节点。例如，这个符号存储在这里，那个符号存储在那里，依此类推，直到最后一个符号存储在某个服务器上。

这样做的好处是，当其中一个存储节点出现故障时，信息依然具有鲁棒性。

例如，假设这个存储节点失效了。它可能是暂时不可用，或者完全损坏了。这对应于我们码字中相应符号的擦除。

在这里使用纠错码的意义在于，只要我们的纠错码能够处理（在本例中）一个擦除，我们就不会丢失数据。然而，我们可以要求比“不丢失数据”更多一点，即能够高效地恢复数据。这似乎是局部性的用武之地。

更具体地说，这是上一张幻灯片中的编码理论问题。我们有一个带有擦除的码字，我们想要恢复这个信息。例如，我们可能想为丢失的存储节点建立一个替代节点。我们该如何做呢？

第一种方法是像通常那样纠正错误。假设我们的替代存储节点（或某个节点）在这里，我们称它为 Bob。Bob 可以做的第一件事是从所有其他未失效的存储节点对应的符号下载信息，解码整个码，并恢复丢失的信息。

这种方法的问题在于，在分布式存储的背景下，这需要大量的通信。请记住，每个符号都存储在不同的存储节点上。因此，Bob 基本上需要从所有不同的存储节点下载整个文件。在现实世界的分布式存储系统中，通信常常是瓶颈，所以我们希望减少通信量。

第二种解决方案是尝试利用码中的一些局部性。也就是说，Bob 可以只下载少数几个符号，向这个码字发出少量查询，并希望能恢复 C_i。例如，Bob 可能只查询这个符号、那个符号和另一个符号，下载这些信息。如果我们设计得当，Bob 应该能从这些信息中恢复 C_i。如果他能做到这一点，我们非正式地说这个码展现了局部性。

此时，你可能会想，嘿，我们之前见过一些具有局部性的码，比如局部可纠正码。我们能在这里使用它们吗？可以，但事实证明，对于像这样的情况，局部可纠正码实际上是大材小用。原因是局部可纠正码被设计用来容忍恒定比例的错误。然而，在这个模型中，首先，我们处理的是擦除而不是错误；其次，我们通常只有恒定数量的擦除，而不是恒定比例的擦除。也就是说，在真实的数据中心中，通常一次只有一个节点宕机，你不会期望 10% 的节点同时失效。😡

因此，从某种意义上说，这个问题比局部可纠正码试图回答的问题要容易得多——只有恒定数量的擦除，而不是恒定比例的错误。正因为如此，我们可能希望做得更好。我们可以使用局部可纠正码，但我们之前看到的局部可纠正码例子并没有很高的码率。因此，我们可能希望获得高得多的码率，同时仍然能够执行此任务。

更详细地说，以下是我们可能希望的一些特性：

我们可能希望在码率和距离之间取得最佳权衡。也就是说，假设我们想要一个 MDS 码。像里德-所罗门码这样的 MDS 码通常用于分布式存储系统。所以，除非不得已，我们不想放弃这一点。
我们可能希望有好的局部性，即能够从最多 r 个其他符号中恢复任何单个符号（一个擦除）。在图中，我们能够从这三个其他符号中恢复这个符号。

如果我们能同时实现这两个目标，那将非常棒。但问题是，实际上我们无法同时实现两者。这是不可能的。😊

之所以不可能，原因如下：对于任何维度为 k 的 MDS 码，事实证明，任何 k-1 个符号的值都无法告诉我们第 k 个符号的值。也就是说，如果我们为一个码字的任意 k-1 个符号选择值（比如这 k-1 个），那么任何其他符号（比如这个）的值可以是任何值。这个陈述源于 MDS 码的定义。如果不清楚为什么，现在可以暂停视频思考一下。提示：你应该利用这样一个事实：对于 MDS 码，生成矩阵的任何 k × k 子矩阵都是可逆的。

那么，基于这个事实，为什么这两个目标不可能同时实现呢？我们想要一个 MDS 码，所以这个事实适用。但我们也想要好的局部性。然而，这个事实表明，例如，如果我们想要恢复这个符号，我们需要查询至少 k 个其他符号。少于 k 个是不行的。而当我们查询一个 MDS 码的 k 个其他符号时，我们就可以恢复整个码字（MDS 码的任何 k 个符号决定了整个码字）。所以现在我们又回到了这种浪费的场景：我们恢复了所有信息，却只为了丢弃其中的大部分。这根本不是局部性。因此，我们无法同时拥有这两者：我们无法拥有一个 MDS 码，同时又具有良好的局部性（即任何符号可以从远少于 k 个的其他符号中恢复）。

此时，有两个选择：我们可以放宽第一个要求（MDS 条件），或者放宽第二个要求（良好的局部性）。这两个选择都很有趣。但在本视频中，我们将专注于放宽第二个条件，即放宽对局部性的严格限制。😊

关键的观察是：我们实际上并不想限制 Bob 必须下载的符号数量。那只是减少通信量的一种便捷方式。但是，有没有其他方法可以减少通信量呢？

我们将要做的是允许 Bob 查看许多不同的符号，但关键在于 Bob 不会从每个符号下载很多信息。也就是说，如果我们在一个大字母表上工作，每个符号由多个比特组成（也许每个符号是 8 比特或 128 比特）。如果 Bob 只下载这些比特中的一两个，那么即使他联系了很多符号，这仍然是一种胜利。

这个基本思想被称为再生码。再生码是一种 MDS 码（所以我们仍然保留第一个目标）。但是，我们不要求良好的局部性，而是要求良好的修复带宽。这意味着，我们再次希望任何符号都能以低信息量恢复，但现在允许以稍微不同的方式发生。

Bob 被允许联系除失效节点之外的任意多个其他符号，但他可以从每个符号下载较少的信息。我们说码的修复带宽是 Bob 需要下载的总比特数。在图中，Bob 联系了所有这些其他节点，但他显然只从这个节点下载 1 比特，从那个节点下载 2 比特，等等。

为了更正式一点，我们假设每个符号（每个存储节点）都可以进行一些本地计算。也就是说，这个符号可以计算其持有数据的某个函数，并将该函数的输出发送给 Bob。即，对于每个 i 和 j，存在某个函数 g_{i, j}，它将字母表 Σ 映射到某个长度的比特串。符号 j 将要发送的是 g_{i, j}(c_j)，其中 i 是失效节点的标识。所以，这些函数可以依赖于我们试图修复的节点，这是可以的。

在分布式存储示例中，我们假设这些信息可以廉价地广播。现在，Bob 应该从他收到的这些信息中学*到丢失的符号 c_i。

因此，非正式地说，这就是再生码的定义：再生码是一种 MDS 码，使得任何单个符号都能以低带宽修复。

那么，我们如何获得再生码呢？在接下来的几个视频中，我们将看到我们的老朋友——里德-所罗门码——可以胜任这个任务。😊

本节课总结：我们一起学*了再生码的基本概念。我们了解到，在分布式存储中，为了高效修复单个节点故障，传统的 MDS 码（如里德-所罗门码）虽然能保证数据不丢失，但在修复时需要下载大量数据（高带宽）。再生码通过放宽对“局部查询符号数量”的限制，转而要求从多个节点各下载少量数据（低修复带宽），从而在保持 MDS 码高码率优势的同时，实现了高效的节点修复。这是一种在通信效率和存储效率之间取得平衡的重要编码方案。

代数编码理论导论：2：域迹（Field Trace）

在本节课程中，我们将快速介绍一个称为“域迹”的数学工具。这个工具在后续证明里德-所罗门码是良好的再生码时，将发挥重要作用。

为了引出域迹的定义，并理解我们将如何使用它，我们需要一个预备知识：F_{2^t} 是一个在 F_2 上的 t 维向量空间。

这意味着，我们可以将大域 F_{2^t} 中的一个元素 α，看作是一个长度为 t、元素在 F_2 中的向量，我们记作 α⃗。

这里用波浪线（~）表示，F_{2^t} 的加法结构与 F_2^t 的加法结构是相同的。也就是说，存在一种对应关系，使得 F_{2^t} 中的加法 α + β，对应于 F_2^t 中向量版本的加法 α⃗ + β⃗。

然而，这个波浪线对应关系并不保持乘法结构。也就是说，如果我们想将 F_{2^t} 中的两个元素 α 和 β 相乘，目前尚不清楚这对应于 F_2^t 中向量版本的何种运算。

不过，在向量空间 F_2^t 中，有一种运算“闻起来”很像乘法，那就是内积。目前，我们还不清楚这个内积运算对应回 F_{2^t} 中的什么操作。

有了这些铺垫，我们现在可以定义并初步解释域迹了。

域迹的定义如下：它是一个从 F_{2^t} 映射到 F_2 的函数，记作 TR。其定义为：
TR(x) = x + x^2 + x^4 + x^8 + ... + x^{2{t-1}}

这看起来只是一个多项式，但它具有一些非常好的性质。

以下是关于域迹的一些重要事实。

首先，域迹是 F_2 线性的。这意味着对于 F_{2^t} 中的任意 α 和 β，都有：
TR(α + β) = TR(α) + TR(β)

要理解这一点，可以利用我们在特征为2的域中已知的性质：(α + β)^2 = α^2 + β^2。由于定义中所有指数都是2的幂，反复应用这个性质即可证明。

域迹的第二个有用性质是，它的像（值域）就在 F_2 中。也就是说，对于大域 F_{2^t} 中的任意元素 α，TR(α) 的值只能是0或1。

这里有一个简短的证明：考虑 TR(α)^2。利用平方可以分配到每一项的性质，我们得到：
TR(α)^2 = α^2 + α^4 + ... + α^{2{t-1}} + α^{2t}
在域 F_{2^t} 中，任何元素的 2^t 次方都等于其自身，即 α^{2t} = α。因此，上式最右边一项变回 α，整个式子恰好等于 TR(α)。这意味着 TR(α)^2 = TR(α)。在 F_2 中，只有0和1满足“等于自身平方”这个条件，因此 TR(α) 必须是0或1。

第三个重要性质是，域迹在某种意义上“捕获”了所有具有上述性质的函数。具体来说，所有从 F_{2^t} 到 F_2 的 F_2 线性函数 φ，都具有以下形式：
φ(x) = TR(α * x)
其中 α 是 F_{2^t} 中的某个元素。

这可能会让你联想到向量空间 F_2^t 上的线性函数。在 F_2^t 上，所有从 F_2^t 到 F_2 的 F_2 线性函数，都具有内积的形式：
φ( x⃗ ) = < α⃗, x⃗ >
其中 α⃗ 是 F_2^t 中的某个向量。

这表明，我们可以将域迹看作是一种内积的类比。

回到我们最初的动机，现在我们确实有了一个对应关系。我们应该将向量 α⃗ 和 β⃗ 的内积，本质上理解为 TR(α * β)。事实上，我们总是可以选择 F_{2^t} 的一个基，从而在 F_{2^t} 和 F_2^t 之间建立一个对应关系，使得这里的波浪线（~）实际上成为一个等式。

好了，以上就是对域迹的快速介绍。在下一节视频中，我们将使用域迹来将里德-所罗门码视为再生码。特别是，将域迹视为向量内积的一种代理（proxy）的观点，将非常有助于我们的理解。

在本节课中，我们一起学*了域迹的定义和三个核心性质：F_2 线性性、值域在 F_2 中，以及它如何表征所有到 F_2 的线性函数。我们还建立了域迹与向量内积之间的类比关系，为后续课程内容奠定了基础。

055：RS码作为再生码

在本节课中，我们将学*如何将里德-所罗门码用作再生码。我们将展示，当使用特定参数的RS码存储数据时，如果一个存储节点失效，替换服务器仅需从每个存活节点下载一个比特，就能恢复失效节点上的数据。

目标与方案对比

假设我们的数据使用一个里德-所罗门码存储，其参数如下：

块长度 n = Q = 2^t
维度 k = n/2 = 2^(t-1)

我们的目标是：当一个节点失效时，替换服务器Bob能够从剩余的n-1个存活节点恢复失效数据，并且希望通信开销尽可能小。

我们将展示的方案是：Bob仅需从每个存活节点下载1个比特。

方案优劣对比：

本方案：修复带宽为 n-1 比特。
朴素方案：Bob需要联系k个节点，从每个节点下载一个域元素（需要t比特表示）。因此总带宽为 k * t = (n/2) * log n 比特。

本方案相比朴素方案，带宽节省了约 log n / 2 倍。随着n增大，这个优势非常显著。虽然我们聚焦于k=n/2、下载1比特的简单场景，但此基本思想非常灵活，可以推广到其他参数。

预备知识与有用事实

在展示具体方案前，我们先回顾两个有用的事实。

事实一： 对于有限域 F_q 上的任意两个多项式 F(x) 和 G(x)，如果它们的次数都严格小于 q/2，那么有：
∑_{α ∈ F_q} F(α) * G(α) = 0

证明思路： 因为F(x)G(x)的次数严格小于q-1，而我们已经知道对于所有 i < q-1，有 ∑_{α ∈ F_q} α^i = 0。将FG的每一项线性分解后应用此性质即可得证。

事实二： 迹函数 Tr: F_{2^t} → F_2 是 F_2-线性的。即对于任意x, y ∈ F_{2^t} 和 a, b ∈ F_2，有 Tr(a*x + b*y) = a*Tr(x) + b*Tr(y)。

上一节我们介绍了两个关键的数学事实，本节中我们将利用它们进行一些核心计算。

核心推导与方案构建

首先，我们定义一个多项式 g_ζ(x)。对于域 F_q 中的任意元素 ζ，定义：
g_ζ(x) = Tr(ζ * x) / x

根据迹的定义 Tr(y) = y + y^2 + y^4 + ... + y^{2^{t-1}}，我们可以将g_ζ(x)展开为：
g_ζ(x) = ζ + ζ^2*x + ζ^4*x^3 + ... + ζ^{2^{t-1}} * x^{2^{t-1} - 1}

现在，假设我们的消息多项式 F(x) 的次数严格小于 q/2（在本例中，q/2 = k，这符合RS码的编码要求）。

根据事实一，对于G(x) = g_ζ(x)，我们有：
F(0) * g_ζ(0) + ∑_{α ∈ F_q, α≠0} F(α) * g_ζ(α) = 0

由于我们工作在特征为2的域上，减法等于加法，因此可以将F(0)*g_ζ(0)移到等式右边：
F(0) * g_ζ(0) = ∑_{α ∈ F_q, α≠0} F(α) * g_ζ(α)

代入g_ζ(x)的定义 g_ζ(α) = Tr(ζ * α) / α，我们得到：
F(0) * ζ = ∑_{α ≠ 0} F(α) * (Tr(ζ * α) / α)

接下来，我们对等式两边同时取迹函数 Tr(·)。利用迹的F_2线性性质（事实二），我们可以将迹操作移入求和符号内，并且因为Tr(ζ * α)是F_2中的元素（0或1），可以提到Tr外面：
Tr(F(0) * ζ) = ∑_{α ≠ 0} Tr(ζ * α) * Tr(F(α) / α)

至此，我们已经得到了修复方案的核心公式。

修复方案详解

基于上一节推导出的公式，我们现在可以描述完整的修复方案。假设失效的节点存储的是 F(0)。

修复步骤：

对于每一个存活的节点α（存储着值F(α)），它计算一个比特：s_α = Tr(F(α) / α)，并将这个比特发送给修复节点Bob。
Bob收到所有n-1个存活节点发来的比特 {s_α}。
对于Bob想要恢复的F(0)，他可以选择任意的ζ ∈ F_q。为了完全恢复F(0)，他需要对一组基向量（例如标准基e1, e2, ..., et）分别进行计算。
对于选定的ζ，Bob计算：Tr(F(0) * ζ) = ∑_{α ≠ 0} Tr(ζ * α) * s_α。
注意，Tr(ζ * α)是Bob本地已知的系数（因为ζ和α已知），s_α是从节点收到的比特。这是一个在F_2上的线性组合。
通过让ζ遍历F_{2^t}在F_2上的一组基（共t个线性无关的ζ），Bob可以得到t个线性方程：Tr(F(0) * ζ_i) = b_i，其中b_i是计算出的比特。
这t个方程定义了F(0)的迹函数在不同方向上的投影。由于迹函数在F_2上是非退化的双线性型，这等价于获取了F(0)（视为一个t维F_2向量）与每个基向量的内积。因此，Bob可以解出F(0)的每一个比特，从而完全恢复这个域元素。

方案优势： 每个存活节点仅发送1比特信息。Bob通过执行一些本地线性计算，就能恢复出失效节点上完整的t比特数据（即F(0)）。

这个方案可以很容易地进行修改，以恢复存储在其他评估点（如F(1), F(γ)等）的数据。通过选择不同的多项式g_ζ，也可以调整方案以适应不同的码率参数k。

总结与扩展视角

本节课中我们一起学*了如何将里德-所罗门码构造为高效的再生码。

我们展示了一个具体的方案：在参数为 [n=2^t, k=2^{t-1}] 的RS码中，当单个节点失效时，修复节点仅需从每个存活节点下载1比特信息，即可恢复失效数据。这相比需要下载 (n/2)*log n 比特的朴素修复方案，带宽效率有显著提升。

这个推导过程巧妙地结合了有限域上多项式求和的特性与迹函数的线性性质。更重要的是，在许多参数设置下，RS码可以被证明是线性MDS码中最优的再生码。

最后，我们也可以跳出编码理论的框架来看待这个结果：它本质上是一种低带宽多项式插值算法。即使不考虑分布式存储的应用背景，这个能够用极少量信息恢复多项式特定点值的算法本身也是一个非常巧妙的结果。

代数编码导论：课程总结：课程回顾与核心思想 🎓

在本节课中，我们将对《代数编码导论》系列课程进行全面的回顾与总结。我们将梳理从纠错码基础到高级应用的核心概念，并提炼贯穿整个课程的核心思想。

概述

本课程系统性地介绍了代数编码理论。我们从纠错码的基本概念出发，探讨了线性码、各种码的界，并深入研究了里德-所罗门码及其衍生码。此外，我们还学*了多种解码范式及其在通信、存储、密码学等领域的广泛应用。

纠错码基础

首先，我们学*了纠错码的基础知识。

我们了解到，一个码本质上是字母表 Σ 上的一个点集，即 C ⊆ Σ^n。

如果码具有良好的距离（即任意两个码字之间的最小汉明距离）和良好的码率（即码字数量足够多），那么即使在有噪声的信道中，通信双方也能进行高效通信。

线性码与基本工具

接着，我们讨论了线性码，并引入了两个核心工具：生成矩阵 G 和校验矩阵 H。这两个矩阵在理解和操作线性码及其算法时非常有用。

码率与距离的权衡

我们还探讨了码率与距离之间的基本权衡关系。

我们学*了许多界，例如汉明界、普洛特金界和辛格尔顿界，这些都是关于码性能的不可能性结果。

同时，我们也看到了一些可能性结果，如吉尔伯特-瓦尔沙莫夫界和扎布洛夫界。这些结果共同揭示了不同码在码率与距离之间所能达到的最佳权衡。

然而，对于二进制码而言，其最佳权衡曲线仍然是开放问题。

里德-所罗门码

对于随着分组长度 n 增大的大字母表，我们确实知道存在能达到码率与距离最优权衡的码，那就是里德-所罗门码。

里德-所罗门码定义为低次多项式在多个点上的求值向量。

它们之所以能在码率与距离之间取得如此好的权衡，原因在于本课程中反复使用的一个核心事实：低次多项式没有太多根。

此外，里德-所罗门码拥有高效的解码算法，例如伯利坎普-韦尔奇算法。该算法能够成功，同样是因为低次多项式没有太多根。

基于里德-所罗门码的衍生码

通过基于或操作里德-所罗门码，我们还得到了其他几种码及其高效算法。

以下是几种重要的衍生码：

BCH码：将里德-所罗门码限制在所有二进制码字上得到的码。
里德-穆勒码：可以看作是里德-所罗门码的多元扩展。
级联码：允许我们将一个大字母表上的码（如里德-所罗门码）与一个内码级联，从而得到一个更小字母表上的码。其过程是：从一个里德-所罗门码字开始，将其视为多个比特块，然后用某个内部的二进制码对每个块进行编码，最终得到一个大的二进制码字。我们看到了几种解码级联码的算法，可用于纠正随机错误和最坏情况错误。
折叠里德-所罗门码：将里德-所罗门码转换为一个在更大字母表上的码，但具有更好的列表解码能力。

其他解码范式

除了传统解码，本课程还介绍了一系列其他解码概念。

列表解码：目标是找到所有接*接收字的码字，即使可能存在多个这样的码字。我们看到了几种算法，如戈帕拉-苏丹算法和折叠里德-所罗门码的列表解码算法，它们都依赖于低次多项式没有太多根这一事实。
局部解码：在这种模式下，即使存在最坏情况错误，解码者鲍勃也希望在亚线性时间内了解爱丽丝消息的某些信息（例如单个比特）。哈达玛码和里德-穆勒码支持局部解码。
局部列表解码：结合了局部解码和列表解码的概念。我们看到了哈达玛码的局部列表解码算法。
再生码：这是一种不同形式的局部性。在再生码中，仅缺失一个符号，鲍勃的任务是尽可能少地从码字的其余部分下载信息来恢复缺失的符号。里德-所罗门码本身就是非常出色的再生码。

纠错码的应用

在整个课程中，我们还看到了纠错码的多种应用。

原始动机：通信。
自然应用：数据存储。再生码就是专为分布式存储设计的。
超越通信与存储的应用：
- 密码学：例如梅尔-赫尔曼密码系统。
- 压缩感知。
- 流算法：如频繁项发现问题。我们看到了两种使用里德-所罗门码来获得更快速算法的方法。
- 群组测试：使用里德-所罗门码获得良好的群组测试方案。
- 学*理论：我们对哈达玛码进行局部列表解码的算法，为我们提供了从查询中学*傅里叶稀疏布尔函数的算法。

此外，还有许多其他应用在本课程中未能涵盖。

核心启示

那么，本课程的核心启示是什么？

纠错码无处不在。它们在通信和存储中极其有用，但作为通用的组合与算法对象，它们在众多应用中都发挥着重要作用。
低次多项式没有太多根，这一事实在各种应用中都非常有用。

总结

本节课中，我们一起回顾了《代数编码导论》的核心内容。我们从纠错码的基本定义出发，遍历了线性码、各种性能界、强大的里德-所罗门码家族、多种解码范式，以及纠错码在多个领域的广泛应用。希望本课程能激发你继续深入学*纠错码，或在你的工作中应用这些强大的工具。

posted @ 2026-03-29 09:46 布客飞龙III 阅读(7) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

斯坦福代数编程理论笔记-全-

斯坦福代数编程理论笔记（全）

001：动机与基本问题 🎯

基本问题

典型应用场景

1. 通信 📡

2. 存储 💾

编码方案的核心考量

核心问题与权衡

002：定义与示例 📚

概述

码的正式定义

码与编码图的关系

码的纠错与检错能力

一个能纠正错误的码

汉明距离与最小距离

最小距离与纠错能力的关系

回顾示例

码率与开销

总结

003：汉明界

核心思想

定义与公式

推导汉明界

实例分析：汉明码

总结与思考

概述 📋

生成矩阵视角 🧮

校验矩阵视角 🔍

线性代数视角的应用 💡

总结 🎯

什么是域？什么是有限域？

例子与非例子

有限域的存在性与结构

为什么有限域对本课程很重要？

总结

007：线性编码 📚

线性码的定义

生成矩阵

对偶码与校验矩阵

重要性质

总结

008：GV界

📖 定理陈述

🔍 与汉明界的比较

🧮 GV界的证明

第一步：参数设定

第二步：构造随机码

第三步：一个有用的事实

第四步：计算距离概率

第五步：应用并集界限

第六步：完成证明

📝 总结

010：McEliece密码系统 🔐

公钥密码学基础

McEliece密码系统的构建

加密与解密过程

加密过程

解密过程

系统安全性分析

现实意义与总结

011：渐*分析

概述

动机与回顾

渐*参数体系

码族的定义

一个熟悉的例子：汉明码族

核心问题：码率与距离的权衡

渐*好码的定义

总结

012：q元熵

013：Singleton界

概述 📋

Singleton界的直观理解 📈

Singleton界的证明 🔍

总结 ✨

普洛特金界定理

一个重要推论

权衡关系全景图