随笔- 28 文章- 0 评论- 3 阅读- 12537

里德（Reed）-所罗门（Solomon）纠删码

纠删码是一种差错控制方式，常用在通信和存储中。

应用在存储中时，它和多副本相比，能用更少的空间实现与多副本相当水平的可靠性。

经典的纠删码两个参数， $k$ 和 $m$ ， $k$ 表示把数据分成多少部分， $m$ 表示这 $k$ 部分数据有 $m$ 个校验信息。令 $n=k+m$ ，则 $k$ 份数据占据 $n$ 份空间，需要的额外空间比为 $n/k−1=m/k$ ，而多副本——例如 $r$ 副本——需要的额外空间比为 $r−1$ 。

纠删码的用途和优劣势

优势：省空间

在实际生产中，多副本的 $r$ 一般取 3，需要额外 2 倍空间，纠删码 $(k,m)$ 一般取 $(6,3)$ 之类的值，需要额外 0.5 倍空间。

劣势：性能差，计算负担重

所以纠删码适用的场景是，读很少，写极少。典型的例子是陈年卷宗。

环上的代数与纠删码原理

原理

设 $d_1,d_2,d_3$ 是需要保存的数据，考虑如下矩阵

A = (\begin{matrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 1 \\ 1 & 2 & 4 \end{matrix})

$A=\begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 1 \\ 1 & 2 & 4 \end{pmatrix}$

则

A (\begin{matrix} d_{1} \\ d_{2} \\ d_{3} \end{matrix}) = (\begin{matrix} d_{1} \\ d_{2} \\ d_{3} \\ c_{1} \\ c_{2} \end{matrix})

$A \begin{pmatrix} d_1 \\ d_2 \\ d_3 \end{pmatrix}=\begin{pmatrix} d_1 \\ d_2 \\ d_3 \\ c_1 \\ c_2 \end{pmatrix}$

显然， $c_1=d_1+d_2+d_3$ ，而 $c_2=d_1+2d_2+4d_3$ ，可以证明 $A$ 去掉任何两行后，都会得到一个满秩矩阵 $B$ ，在上式右边去掉行号相同的对应两行，得到

(\begin{matrix} t_{1} \\ t_{2} \\ t_{3} \end{matrix})

$\begin{pmatrix} t_1 \\ t_2 \\ t_3 \end{pmatrix}$

那么

B^{- 1} (\begin{matrix} t_{1} \\ t_{2} \\ t_{3} \end{matrix}) = (\begin{matrix} d_{1} \\ d_{2} \\ d_{3} \end{matrix})

$B^{-1} \begin{pmatrix} t_1 \\ t_2 \\ t_3 \end{pmatrix}=\begin{pmatrix} d_1 \\ d_2 \\ d_3 \end{pmatrix}$

于是，我们在丢失了两个数据后，通过代数运算，还原了原始数据。这就是 $(k,m)=(3,2)$ 的里德所罗门编码的基本原理。它可以容忍任意 $m$ 个数据丢失。

但是，上述计算直接应用在计算机上，则完全行不通，因为计算机只能处理有限数，不能处理实数。所以，必须通过某种转换，使得计算机也能处理这样的计算。

有限域

不难发现，上面的计算只用到了加减乘除（除数不能是零），矩阵的求逆也是有限次加减乘除的复合，没有用到实数的连续性等其他性质。所以我们可以（也必须）用一个对计算机友好的、支持加减乘除的代数结构替换上面的实数集 $\mathbb{R}$ 。

域，Field，指的是一个非空集合 $F$ ，上面有加法和乘法两个运算，且：

加法使 $F$ 成为交换群 $F^+$ ，其单位元记为 $0$
乘法满足交换律，且使 $F−\{0\}$ 成为交换群 $F^\times$ ，其单位元记为 $1$
满足乘法对加法的分配律， $a(b+c)=ab+ac$

如果 $F$ 是有限集，那么就称这个域是有限域，也叫伽罗瓦域。

可以证明，有限域的元素个数必须是 $p^k$ ，其中 $p$ 是素数， $k$ 是正整数。

一个字节有 256 个不同的值，即 0 到 255，而幸运的是， 256 可以作为有限域的元素个数，因为它是 $2^8$ 。所以我们的目标是，构造一个元素个数为 256 的域 $F$ ，它和

B = {0, 1, \dots, 255}

$B = \{0,1,\cdots,255\}$

之间建立起一一对应

h : B \to F

$h:B \rightarrow F$

于是 $B$ 中的四则运算可以定义为

a + b = h^{- 1} (h (a) + h (b))

$a+b = h^{-1}(h(a) + h(b))$

a - b = h^{- 1} (h (a) - h (b))

$a-b = h^{-1}(h(a) - h(b))$

a b = h^{- 1} (h (a) h (b))

$ab = h^{-1}(h(a)h(b))$

a / b = h^{- 1} (h (a) / h (b))

$a/b = h^{-1}(h(a) / h(b))$

有限域的构造

构造元素个数为 256 的域需要一些小波折。但好在，构造元素个数为素数的域很简单。

设 $p$ 为素数。考虑整数的模 $p$ 同余类 $\mathbb{Z}/p\mathbb{Z}$ ，加法就是相加后取模 $p$ 同余，乘法就是相乘后取模 $p$ 同余，相反数定义为如果 $p$ 整除 $a+b$ 则称 $a$ 和 $b$ 互为相反数， $a$ 的倒数定义为使 $ab\equiv1(\text{mod}\,p)$ 的那个 $b$ ，有了相反数和倒数就可以定义减法和除法。根据初等数论知识，这些定义都是良定义的，并且满足域的条件，它是有限域 $\mathbf{F}_p$ 。

特别地， $p=2$ ，那么 $F=\{0,1\}$ ，加减法都是亦或，乘法是只有 $1×1=1$ 其他乘积都等于零。这是有 2 个元素的有限域 $\mathbf{F}_2$ 。

正如我们用整数环和素数 $p$ 构造有限域 $\mathbf{F}_p$ 那样，可以考虑系数在 $\mathbf{F}_2$ 中的多项式组成的多项式环 $\mathbf{F}_2[x]$ 以及该环上的本原多项式构造有限域。

考察多项式

p (x) = x^{8} + x^{4} + x^{3} + x^{2} + 1

$p(x)=x^8+x^4+x^3+x^2+1$

它在 $\mathbf{F}_2$ 中是本原多项式。在 $\mathbf{F}_2$ 中取模 $p(x)$ 同余，得到由次数小于 8 的多项式环

G F = G F (256) = {f (x) | f (x) = \sum_{i = 0}^{7} a_{i} x^{i}, a_{i} \in F_{2}}

$\mathbf{GF}=\mathbf{GF}(256)=\{ f(x) | f(x)=\sum_{i=0}^7 a_ix^i, a_i \in \mathbf{F}_2 \}$

它是 $\mathbf{F}_2$ 上的 8 维线性空间，里面正好有 $2^8=256$ 个向量。

$\mathbf{GF}$ 中的加减法按照多项式自然的加减法进行，加法单位元为零多项式 0，乘法按照多项式相乘模 $p(x)$ ，除零多项式外，乘法都有逆元，乘法的单位元是零次多项式 1，于是，它满足域的所有条件。

终于，我们得到了一个有 256 个元素的域！

代码实现

在开始代码之前，我们还是要继续啰嗦几句代数。

一个有限域 $F$ ，它的乘法群 $F^\times$ 必定是循环群，也就是群 $F^\times$ 的所有元素都可以由某个不是单位元的元素不断乘以自己得到。具体到 $\mathbf{GF}(256)$ ，它里面的 1 次多项式 $x$ 可以生成它里面除零多项式之外的所有多项式

G F (256) = {0, 1, x, x^{2}, . . ., x^{254}}

$\mathbf{GF}(256)=\{ 0,1,x,x^2,...,x^{254} \}$

而 $x$ 的阶 ${\rm ord}(x)=255$ ，这就为我们编码实现提供了便利。

给定多项式 $f(x)=x^n$ 和 $g(x)=x^m$ ，计算它们的乘积可以直接把指数加起来 $f(x)g(x)=x^nx^m=x^{n+m}$ 。而在代码中，我们可以直接构造两个表：

指数表：给定 $n$ ，得到 $x^n$ 展开后的样子，byte 表示
对数表：给定 byte，它对应的多项式是 $x$ 的多少次幂

有了这两个表，我们计算乘除法才好算。

constexpr int FIELD_SIZE = 256;

constexpr uint16 PRIMITIVE_POLYNOMIAL = 0b100011101; // x^8 + x^4 + x^3 + x^2 + 1

uint8 gf_power[FIELD_SIZE - 1];
uint8 gf_log[FIELD_SIZE];

// 计算指数表和对数表
// 在实际生产中，提前在别的地方算好放入 constexpr 数组，这里为了演示无所谓了
void init()
{
    constexpr uint16 MASK = 0xFF00;

    gf_power[0] = uint8(1);
    gf_power[1] = uint8(1) << 1;
    for (int i = 2; i < FIELD_SIZE - 1; ++i)
    {
        uint16 temp = gf_power[i - 1] << 1;
        if ((temp & MASK) != 0)
        {
            // 越界了，取模
            temp ^= PRIMITIVE_POLYNOMIAL;
        }
        gf_power[i] = static_cast<uint8>(temp);
    }

    gf_log[0] = 0; // 注意，0 没有对数
    for (int i = 0; i < FIELD_SIZE - 1; ++i)
    {
        gf_log[gf_power[i]] = i;
    }
}