六、量子纠错码的构成法

介绍了量子纠错编码的基本原理，并且通过经典纠错编码的重复码为基础，介绍了解决 bit 反转错误和位相反转错误的方法。这里我们将进一步利用经典纠错码中其他思想和方法，介绍 CSS 量子纠错编码，并对量子纠错编码的性能界限等有关问题作一些简单的说明。
本文先介绍经典纠错编码的基本概率，然后介绍 CSS 编码和解码，以及量子编码的界限。

1.经典纠错编码的基础

纠错编码的目的是引入 冗余度 。直观的看，所谓的纠错编码就是在待传输的信源码的信息码元之后增加一些多余的校验码元，构成在信道中传输的信道码（纠错码），使得该编码在有噪信道中即使发生信息损失或错误，仍能在接收端加以恢复。
根据信息码元和校验码元之间的不同的关系，经典纠错码按结构大致可以分类如下：

经典编码中，如果我们要传送 k 个 bit 表示的信息，用长度为 n 的二元（{0，1}）代码表示这个要传送的信息。

长度为 n 的所有代码组成代码集合 CCC ，对于一个长度为 n 的二元码，我们定义代码中包含的 1 的个数为 Hamming 权重 ，用 wH(v)w_H(v)wH(v) 表示。如：
v=(111001)wH(v)=4v=(111001) \ \ \ \ \ \ w_H(v)=4v=(111001) wH(v)=4

同时定义两个代码之间的 Hamming 距离 为：两个代码中有多少个相同位置的元素不相等。我们可以表示为 dH(v,w)d_H(v,w)dH(v,w) 。

在二元码中，我么定义两两元素的加法和乘法运算使用 模2运算 ，即用普通的运算规则得到的结果 除以 2 取余 。如下：
0+0=01+0=10+1=11+1=00+0=0\ \ \ \ \ 1+0=1 \ \ \ \ \ 0+1=1\ \ \ \ \ 1+1=00+0=0 1+0=1 0+1=1 1+1=0

0∗0=01∗0=00∗1=01∗1=10*0=0\ \ \ \ \ \ 1*0=0 \ \ \ \ \ \ 0*1=0\ \ \ \ \ \ \ 1*1=1 \ 0∗0=0 1∗0=0 0∗1=0 1∗1=1

那么我们可以定义两个代码的加法也满足 模2运算 ，即若 v=(1010)，w=(1100)v=(1010)，w=(1100)v=(1010)，w=(1100)，则 v+w=(1+1,0+1,1+0,0+0)=(0,1,1,0)v+w=(1+1,0+1,1+0,0+0)=(0,1,1,0)v+w=(1+1,0+1,1+0,0+0)=(0,1,1,0) 。

再来看代码集合 C，对其任意两个代码 vvv 和 www ，如果总有 v+w∈Cv+w\in Cv+w∈C ，则我们称 CCC 为 线性代码集合 。

代码集合 CCC 的最小距离 d(C)d(C)d(C) 被定义为集合上不同代码间的 Hamming 距离的最小值。而对于线性代码集合，其最小距离 d(C)d(C)d(C) 就是非零代码的 Hamming 权重的最小值。

上面我们讲了，我们可以将要传送的 k bit 的信息编码为 n 个 bit (k<n) 来增加冗余，那么我们怎么用 n 个 bit 来表示这 k 个 bit 的信息呢？本来我们要传送的信息是 (x1,x2,⋯,xk)(x_1,x_2,\cdots,x_k)(x1,x2,⋯,xk) ，现在我们要将它变为 n 位，也就是在后面加上 n−kn-kn−k 位的校验元，从而将信息变为 (x1,x2,⋯,xk,xk+1‾,⋯,xn‾)(x_1,x_2,\cdots,x_k,\underline{x_{k+1}},\cdots,\underline{x_{n}})(x1,x2,⋯,xk,xk+1,⋯,xn) ，我们可以用原信息 (x1,x2,⋯,xk)(x_1,x_2,\cdots,x_k)(x1,x2,⋯,xk) 中的若干位进行某种运算，将运算的结果作为 n−kn-kn−k 位的校验元。如计算机网络中的循环冗余码，它通过生成多项式求出冗余码，然后将冗余码加在原信息后进行传输。如果我们通过原信息的线性组合获得该冗余码，如下所示，我们要传送的信息为
m=(m3,m2,m1)m=(m_3,m_2,m_1)m=(m3,m2,m1)

编码的输出为
c=(c6,c5,c4,c3,c2,c1)c=(c_ 6,c_5,c_4,c_3,c_2,c_1)c=(c6,c5,c4,c3,c2,c1)

令输入输出码元之间的关系为
c6=m3c_6=m_3c6=m3

c5=m2c_5=m_2c5=m2

c4=m1c_4=m_1c4=m1

c3=m3+m2c_3=m_3+m_2c3=m3+m2

c2=m3+m2+m1c_2=m_3+m_2+m_1c2=m3+m2+m1

c1=m3+m1c_1=m_3+m_1c1=m3+m1

则编码输出可以表示为原信息和矩阵 GGG 的乘积，即
(c6,c5,c4,c3,c2,c1)=(m3,m2,m1)[100111010110001011]⇒c=mG(c_ 6,c_5,c_4,c_3,c_2,c_1)=(m_3,m_2,m_1) \left[ \begin{matrix} 1 & 0 & 0 & 1 & 1 & 1 \\ 0 & 1 & 0 & 1 & 1 & 0 \\ 0 & 0 & 1 & 0 & 1 & 1 \end{matrix} \right] \Rightarrow c=mG(c6,c5,c4,c3,c2,c1)=(m3,m2,m1)⎣⎡100010001110111101⎦⎤⇒c=mG

我们称 G 为编码的 生成矩阵 ，从上面的分析我们可以知道，对于原信息不同的线性组合，生成矩阵是不同的。推广到一般形式，对于 k bit 组成的每个信息
(x1,x2,⋯,xk),xi∈(0,1),i=1,2,⋯,k(x_1,x_2,\cdots,x_k),\ x_i\in{(0,1),\ i=1,2,\cdots,k}(x1,x2,⋯,xk), xi∈(0,1), i=1,2,⋯,k

其通过生成矩阵 G 编码获得的所有代码的集合 C(∣C∣=2k)C\ (|C|=2^k)C (∣C∣=2k) 构成线性代码集合，该代码集合的每个代码可以表示为
v=(x1,x2,⋯,xn)Gk×nv=(x_1,x_2,\cdots,x_n)G_{k\times n}v=(x1,x2,⋯,xn)Gk×n

如果我们用 kkk 个行矢量 g1,g2,⋯,gkg_1,g_2,\cdots,g_kg1,g2,⋯,gk 表示线性代码集合 CCC 的生成矩阵
Gk×n=[g1g2⋮gk]G_{k\times n}= \left[ \begin{matrix} g_1 \\ g_2 \\ \vdots \\ g_k \end{matrix} \right]Gk×n=⎣⎡g1g2⋮gk⎦⎤

则对应信息 (x1,x2,⋯,xn)(x_1,x_2,\cdots,x_n)(x1,x2,⋯,xn) 的代码 vvv 将表示为
v=(x1,x2,⋯,xn)Gk×n=x1g1+x2g2+⋯+xkgkv=(x_1,x_2,\cdots,x_n)G_{k\times n}=x_1g_1+x_2g_2+\cdots+x_kg_kv=(x1,x2,⋯,xn)Gk×n=x1g1+x2g2+⋯+xkgk

由此可知，代码 vvv 是 g1,g2,⋯,gkg_1,g_2,\cdots,g_kg1,g2,⋯,gk 的线性组合。行矢量 g1,g2,⋯,gkg_1,g_2,\cdots,g_kg1,g2,⋯,gk 的一次性线性独立的最大个数用 dim(C)dim(C)dim(C) 表示，dim(C)dim(C)dim(C) 也是线性代码集合 CCC 的维数。

我们定义 nnn 维二元代码 v=(v1,v2,⋯,vn)v=(v_1,v_2,\cdots,v_n)v=(v1,v2,⋯,vn) 和 w=(w1,w2,⋯,wn)w=(w_1,w_2,\cdots,w_n)w=(w1,w2,⋯,wn) 的内积 v⋅wv \pmb{\cdot} wv⋅⋅w 为
v⋅w=v1∗w1+v2∗w2+⋯+vn∗wnv \pmb{\cdot} w=v_1*w_1+v_2*w_2+\cdots+v_n*w_nv⋅⋅w=v1∗w1+v2∗w2+⋯+vn∗wn

等式右边的运算满足模2运算。当 v⋅w=0v \pmb{\cdot} w=0v⋅⋅w=0 时，称两个矢量 vvv 和 www 直交。

与线性代码集合 CCC 中所有代码直交的矢量全体组成的集合称为 CCC 的 对偶代码集合 ，用记号 C⊥C^{\bot}C⊥ 表示，此时 C⊥C^{\bot}C⊥ 也是线性代码集。因为，如果有 w1w_1w1 和 w2w_2w2 是 C⊥C^{\bot}C⊥ 中的代码，则对于任意的 v∈Cv\in Cv∈C ，以下等式成立：
v⋅(w1+w2)=v⋅w1+v⋅w2=0+0=0v \pmb{\cdot} (w_1+w_2)=v \pmb{\cdot} w_1+v \pmb{\cdot} w_2=0+0=0v⋅⋅(w1+w2)=v⋅⋅w1+v⋅⋅w2=0+0=0

所以 w1+w2∈C⊥w_1+w_2\in C^{\bot}w1+w2∈C⊥。

由线性代数基础知识我们知道长度为 n 的线性代码集合 CCC 与其对偶代码集合 C⊥C^{\bot}C⊥ 的维数之间的关系满足下式
dim(C)+dim(C⊥)=ndim(C)+dim(C^{\bot})=ndim(C)+dim(C⊥)=n

我们将长度为 n 、维数为 k 的线性代码集合记为 [n,k][n,k][n,k] ，由此我们可以得出，其对偶代码集合应该记为 [n,n−k][n,n-k][n,n−k]。

线性代码集合 CCC 的对偶代码集合 C⊥C^{\bot}C⊥ 被称为是 CCC 的 奇偶校验矩阵 或简称为 校验矩阵 ，[n,k][n,k][n,k] 线性代码集合的奇偶校验矩阵是 (n−k)×n(n-k)\times n(n−k)×n 矩阵。假设代码集合 CCC 的奇偶校验矩阵为 HHH ，则从定义我们可以直接得到代码集合 CCC 的所有代码 vvv ，因为 vvv 一定满足以下等式：
vHT=0vH^T=0vHT=0

此处 HTH^THT 表示矩阵 HHH 的转置。

一般情况下，根据矩阵的基本变换规则，线性代码集合 CCC 的生成矩阵一定可以写成下列形式：
G=[IkP]G=\left[ \begin{matrix} I_k & P \end{matrix} \right]G=[IkP]

此处 IkI_kIk 表示 k×kk\times kk×k 的单位矩阵，PPP 表示 k×(n−k)k\times(n-k)k×(n−k) 矩阵。此时，代码集合 CCC 的奇偶校验矩阵可以由下列等式给出：
H=[PTIn−k]H=\left[ \begin{matrix} P^T & I_{n-k} \end{matrix} \right]H=[PTIn−k]

此处 PTP_TPT 表示 PPP 的转置，In−kI_{n-k}In−k 表示 (n−k)×(n−k)(n-k)\times(n-k)(n−k)×(n−k) 的单位矩阵。

上面说了，我们可以通过奇偶校验矩阵可以得到代码集合 CCC 的所有代码，那么同理，如果一个代码不属于该代码集合，那么我们通过奇偶校验矩阵也可以发现。通过该性质我们可以利用奇偶校验矩阵来纠正线性代码的错误。现在使用生成矩阵 GGG 的 [n,k][n,k][n,k] 线性代码集合，假设信息 x=(x1,x2,⋯,xn)x=(x_1,x_2,\cdots,x_n)x=(x1,x2,⋯,xn) 借助生成矩阵 GGG 转换称代码 v=xGv=xGv=xG 。将 vvv 通过信道传送，如果在信道传输中发生错误，我们可以用长度为 nnn 的二元矢量 eee 表示，则接收方收到的信息可表示成为
y=v+ey=v+ey=v+e

这里 “+” 表示各元素进行上面的模2加法运算。假设用 HHH 表示该线性代码集合的奇偶校验矩阵，因为关于代码 vvv 的等式 vHT=0vH^T=0vHT=0 一定成立，能够得到下列等式：
yHT=(v+e)HT=vHT+eHT=eHTyH^T=(v+e)H^T=vH^T+eH^T=eH^TyHT=(v+e)HT=vHT+eHT=eHT

显然，决定 yHTyH^TyHT 的仅仅是错误矢量的 eee ，而与发送信息的代码 vvv 无关。我们称 yHTyH^TyHT 为 伴随式 。伴随式中仅仅包含错误矢量 eee 的信息，如果能够很好地利用伴随式，就有可能推断出通过信道传送过来的 vvv 。

下面用一个粒子描述用伴随式订正错误的方法。考虑下面 [7,4][7,4][7,4] Hamming 编码集合的奇偶校验矩阵
H=[000111101100111010101]H=\left[ \begin{matrix} 0 & 0 & 0 & 1 & 1 & 1 & 1 \\ 0 & 1 & 1 & 0 & 0 & 1 & 1 \\ 1 & 0 & 1 & 0 & 1 & 0 & 1 \end{matrix} \right]H=⎣⎡001010011100101110111⎦⎤

如果没有发生错误，则从 e=0e=0e=0 直接得到的伴随式是
yHT=eHT=0yH^T=eH^T=0yHT=eHT=0

如果发生了错误，假设第 jjj 位 bitbitbit 上发生错误，则用 eje_jej 表示第 jjj 位 bitbitbit 为 1 、其他 bitbitbit 位上全为 0 的矢量，就能够得到
yHT=ejHT=[0⋯1j⋯0]HTyH^T=e_jH^T=\left[ \begin{matrix} 0 \cdots1_j\cdots0 \end{matrix} \right]H^TyHT=ejHT=[0⋯1j⋯0]HT

由于奇偶校验矩阵 HHH 的所有列矢量都各部相同，因此错误矢量 e1∼e7e_1\sim e_7e1∼e7 上对应着不同的伴随式，从具体的结果可以得到如下的对应关系：

错误发生的位置	伴随式
没有错误(e0)(e_0)(e0)	(000)(0\ \ \ 0\ \ \ 0)(0 0 0)
没有错误(e1)(e_1)(e1)	(001)(0\ \ \ 0\ \ \ 1)(0 0 1)
没有错误(e2)(e_2)(e2)	(010)(0\ \ \ 1\ \ \ 0)(0 1 0)
没有错误(e3)(e_3)(e3)	(011)(0\ \ \ 1\ \ \ 1)(0 1 1)
没有错误(e4)(e_4)(e4)	(100)(1\ \ \ 0\ \ \ 0)(1 0 0)
没有错误(e5)(e_5)(e5)	(101)(1\ \ \ 0\ \ \ 1)(1 0 1)
没有错误(e6)(e_6)(e6)	(110)(1\ \ \ 1\ \ \ 0)(1 1 0)
没有错误(e7)(e_7)(e7)	(111)(1\ \ \ 1\ \ \ 1)(1 1 1)

由以上的结果可知，编码的 7 位 bit 中无论哪一位 bit 上发生错误，都可以通过伴随式准确地知道错误发生的位置，然后对错误位置上的 bit 状态值的 1 和 0 进行反转操作，就能够获得通过信道传送过来的正确代码。

[7,4][7,4][7,4] Hamming 编码对于 7 位 bit 中有两位以上的 bit 发生错误时是无法获得正确的发送的信息代码的，这个可以通过发生两个错误的 eee 进行验证。

2.CSS 编码的构成方法

CSS编码有时也称 CRSS编码，它在 1996 年由 Calderbank、Shor 两人与 Stoane 独立发现，之后， Calderbank、Rains、Shor 、Stoane 4 人又在 1998 年共同提出了 Stabilizer 编码，即 CRSS 编码。Stabilizer 是 CSS 编码的一般化。

CSS 编码是基于经典纠错编码方法体系的量子纠错编码的构成方法。CSS 编码是由 2 个经典纠错编码构成的能够纠正 t 位为止的量子纠错编码，它能够同时订正 t 位为止的 bit 反转错误以及 t 位为止的位相反转错误。类比于经典编码，一般用 [[n,k]][[n,k]][[n,k]] 表示由 k 个 qubit 组成的信源编码序列转换成由 n 个 qubit 组成的信道编码序列的 量子编码集合 。

前面我们曾经提到，对于多个量子的系统，它们整体的状态可以用张量积表示。对于双态的量子系统，每个量子的状态可以表示为
∣φ⟩=α∣0⟩+β∣1⟩|\varphi\rangle=\alpha|0\rangle+\beta|1\rangle∣φ⟩=α∣0⟩+β∣1⟩

由于 ∣0⟩|0\rangle∣0⟩ 和 ∣1⟩|1\rangle∣1⟩ 表示两个基态，我们可以将量子态写成矩阵的形式
∣φ⟩=[αβ]|\varphi\rangle= \left[ \begin{matrix} \alpha \\ \beta \end{matrix} \right]∣φ⟩=[αβ]

而多量子系统的整体状态可以表示为
∣a1⟩⊗∣a2⟩⊗⋯⊗∣an⟩|a_1\rangle\otimes|a_2\rangle\otimes\cdots\otimes|a_n\rangle∣a1⟩⊗∣a2⟩⊗⋯⊗∣an⟩

aia_iai 表示第 iii 个量子的状态。同理，我们也可以用矩阵的形式表示该状态，对于每个量子状态是一个二维矩矢量，要想表示 n 个 qubit 的状态，我们需要一个 2n2^n2n 维的矢量，一个 2n2^n2n 维的矢量可以用一组 2n2^n2n 个互相正交的基矢来表示，这些基矢的 复线性组合 就可以表示整体的状态了，它们构成了一个 2n2^n2n 维的复向量空间，2n2^n2n 维的复向量空间有一组基
∣a1⟩⊗∣a2⟩⊗⋯⊗∣an⟩,(ai∈{0,1},(1≤i≤n))|a_1\rangle\otimes|a_2\rangle\otimes\cdots\otimes|a_n\rangle,\ \ \ (a_i\in\{0,1\},(1\leq i\leq n)\ )∣a1⟩⊗∣a2⟩⊗⋯⊗∣an⟩, (ai∈{0,1},(1≤i≤n) )

这个表示一组基的向量也可以简单记为 ∣a1a2⋯an⟩=∣a⟩|a_1a_2\cdots a_n\rangle=|a\rangle∣a1a2⋯an⟩=∣a⟩ 。所以每个整体的状态 ∣φ⟩|\varphi\rangle∣φ⟩ 可以表示为这组基的线性组合：
∣φ⟩=∑(a1,a2,⋯,an)∈{0,1}c(a1,a2,⋯,an)∣a1a2⋯an⟩=∑(a1,a2,⋯,an)∈{0,1}c(a)∣a⟩\begin{aligned} |\varphi\rangle &=\sum_{(a_1,a_2,\cdots,a_n)\in \{0,1\}} c(a_1,a_2,\cdots,a_n)|a_1a_2\cdots a_n\rangle \\ &=\sum_{(a_1,a_2,\cdots,a_n)\in \{0,1\}}c(a)|a\rangle \end{aligned}∣φ⟩=(a1,a2,⋯,an)∈{0,1}∑c(a1,a2,⋯,an)∣a1a2⋯an⟩=(a1,a2,⋯,an)∈{0,1}∑c(a)∣a⟩

其中 c(a1,a2,⋯,an)=c(a)c(a_1,a_2,\cdots,a_n)=c(a)c(a1,a2,⋯,an)=c(a)

现在假设有 2 个经典纠错编码集合：[n,k1][n,k_1][n,k1] 线性编码集合 C1C_1C1 和 [n,k2][n,k_2][n,k2] 线性编码集合 C2C_2C2 ，它们满足以下两个条件：

C2⊂C1C_2 \subset C_1C2⊂C1
d(C1)≥2t+1,d(C⊥)≥2t+1d(C_1)\geq2t+1,\ d(C^{\bot})\geq2t+1d(C1)≥2t+1, d(C⊥)≥2t+1

条件 (1) 表示 C2C_2C2 的全体代码包含在 C1C_1C1 代码集合中，条件 (2) 分表表示 C1C_1C1 和 C2C_2C2 的对偶代码集合同时都能订正 t 个为止的错误（这是一个定理，通过 Hamming 距离的最小值可以确定可以纠正多少位的错误，在后面会给出详细的介绍）。

CSS编码就是由这些代码集合构成的，它是能够订正 t 个以下 qubit 上发生错误的 量子编码集合 [[n,k1−k2]][[n,k_1-k_2]][[n,k1−k2]] 。

对于代码集合 C1C_1C1 中的任意代码 x∈C1x\in C_1x∈C1，代码集合 C2C_2C2 中的任意代码 y∈C2y\in C_2y∈C2，我们用经典代码表示一个量子状态为 ∣x⟩|x\rangle∣x⟩ 或 ∣y⟩|y\rangle∣y⟩ ，如
x=11101x=11101x=11101

可以表示量子状态 ∣11101⟩|11101\rangle∣11101⟩ ，同时我们定义量子状态 ∣x+y⟩|x+y\rangle∣x+y⟩ 为经典代码 xxx 和 yyy 进行模2加法运算得到的结果的状态。如
x=11101，y=10000x=11101，y=10000x=11101，y=10000

则 ∣x+y⟩=∣11101+10000⟩=∣01101⟩|x+y\rangle=|11101+10000\rangle=|01101\rangle∣x+y⟩=∣11101+10000⟩=∣01101⟩。

对于 C1C_1C1 中的一个代码 x∈C1x\in C_1x∈C1，我们将量子状态：
12k22∑y∈C2∣x+y⟩\frac{1}{2^{\frac{k_2}{2}}}\sum_{y\in C_2}|x+y\rangle22k21y∈C2∑∣x+y⟩

记为 ∣x+C2⟩|x+C_2\rangle∣x+C2⟩ ，它表示将代码 xxx 和线性代码集合 C2C_2C2 中的每个代码相加组成的量子状态进行叠加得到整体状态。此时量子状态 ∣x+C2⟩|x+C_2\rangle∣x+C2⟩ 具有如下性质：

如果 C1C_1C1 中代码 x′x'x′ 满足条件 (x+x′)∈C2(x+x')\in C_2(x+x′)∈C2，则下列等式成立：
∣x′+C2⟩=∣x+C2⟩|x'+C_2\rangle=|x+C_2\rangle∣x′+C2⟩=∣x+C2⟩
如果 (x+x′)∉C2(x+x') \notin C_2(x+x′)∈/C2 ，则状态 ∣x+C2⟩|x+C_2\rangle∣x+C2⟩ 与 ∣x′+C2⟩|x'+C_2\rangle∣x′+C2⟩ 直交。也就是下列等式成立：
⟨x′+C2∣x+C2⟩=0\langle x'+C_2|x+C_2 \rangle=0⟨x′+C2∣x+C2⟩=0

由以上的性质，我们取遍 C1C_1C1 中所有的 x∈C1x\in C_1x∈C1 ，可以得到的直交状态 ∣x+C2⟩|x+C_2\rangle∣x+C2⟩ 的个数为
2k12k2=2k1−k2\frac{2^{k_1}}{2^{k_2}}=2^{k_1-k_2}2k22k1=2k1−k2

这里 k1k_1k1 代表 C1C_1C1 原信息代码长， k2k_2k2 代表 C2C_2C2 原信息代码长。这些相异的状态由以下的集合表示：
{∣x0+C2⟩,∣x1+C2⟩,⋯,∣x2k1−k2−1⟩}\{|x_0+C_2\rangle,|x_1+C_2\rangle,\cdots,|x_{2^{k_1-k_2}-1}\rangle\}{∣x0+C2⟩,∣x1+C2⟩,⋯,∣x2k1−k2−1⟩}

CSS代码就是将 k1−k2k_1-k_2k1−k2 个 qubit 的重叠状态
α0∣0⋯00⟩+α1∣0⋯01⟩+α2∣0⋯10⟩+⋯+α2k1−k2−1∣0⋯11⟩\alpha_0|0\cdots 00\rangle+ \alpha_1|0\cdots 01\rangle+ \alpha_2|0\cdots 10\rangle+ \cdots+ \alpha_{2^{k_1-k_2}-1}|0\cdots 11\rangleα0∣0⋯00⟩+α1∣0⋯01⟩+α2∣0⋯10⟩+⋯+α2k1−k2−1∣0⋯11⟩

转换成 nnn 个 qubit 的重叠状态
α0∣x0+C2⟩+α1∣x1+C2⟩+α2∣x2+C2⟩+⋯+α2k1−k2−1∣x2k1−k2−1+C2⟩\alpha_0|x_0+C_2\rangle+ \alpha_1|x_1+C_2\rangle+ \alpha_2|x_2+C_2\rangle+ \cdots+ \alpha_{2^{k_1-k_2}-1}|x_{2^{k_1-k_2}-1}+C_2\rangleα0∣x0+C2⟩+α1∣x1+C2⟩+α2∣x2+C2⟩+⋯+α2k1−k2−1∣x2k1−k2−1+C2⟩

的编码体系。因此，CSS 代码是在 [n,k1][n,k_1][n,k1] 线性编码集合 C1C_1C1 和 [n,k2][n,k_2][n,k2] 线性编码集合 C2C_2C2 满足 C2⊂C1C_2\subset C_1C2⊂C1 时，由 C1C_1C1 和 C2C_2C2 构成的 [[n,k1−k2]][[n,k_1-k_2]][[n,k1−k2]] 量子线性编码集合。

下面我们用一个例子来说明 CSS 编码的编码方式。

作为线性编码集合 C1C_1C1 ，选择 [7,4][7,4][7,4] Hamming 编码集合，它的奇偶校验矩阵为下面的 H1H_1H1 。我们假设线性编码集合 C2C_2C2 为 [7,3][7,3][7,3] 的 Hamming 代码集合，它的奇偶校验矩阵为下面的 H2H_2H2。
H1=[000111101100111010101]H2=[1000011010010100101100001111]H_1= \left[ \begin{matrix} 0 & 0 & 0 & 1 & 1 & 1 & 1 \\ 0 & 1 & 1 & 0 & 0 & 1 & 1 \\ 1 & 0 & 1 & 0 & 1 & 0 & 1 \end{matrix} \right] \ \ \ \ H_2=\left[ \begin{matrix} 1 & 0 & 0 & 0 & 0 & 1 & 1 \\ 0 & 1 & 0 & 0 & 1 & 0 & 1 \\ 0 & 0 & 1 & 0 & 1 & 1 & 0 \\ 0 & 0 & 0 & 1 & 1 & 1 & 1 \\ \end{matrix} \right] H1=⎣⎡001010011100101110111⎦⎤ H2=⎣⎡1000010000100001011110111101⎦⎤

显然，C2C_2C2 表示的线性编码的集合如下：
C2={(0000000),(1010101),(0110011),(1100110),(0001111),(1011010),(0111100),(1101001)}\begin{aligned} C_2= \{ & (0000000),(1010101),(0110011),(1100110), \\ & (0001111),(1011010),(0111100),(1101001)\} \end{aligned}C2={(0000000),(1010101),(0110011),(1100110),(0001111),(1011010),(0111100),(1101001)}

C1C_1C1 的线性编码集合为：
C1={(0000000),(1110000),(1001100),(0101010),(1101001),(0111100),(1011010),(0011001),(1100110),(0100101),(0010110),(1010101),(0110011),(0001111),(100011),(1111111)}\begin{aligned} C_1= \{ & (0000000),(1110000),(1001100),(0101010), \\ & (1101001),(0111100),(1011010),(0011001), \\ & (1100110),(0100101),(0010110),(1010101), \\ & (0110011),(0001111),(100011),(1111111)\} \end{aligned}C1={(0000000),(1110000),(1001100),(0101010),(1101001),(0111100),(1011010),(0011001),(1100110),(0100101),(0010110),(1010101),(0110011),(0001111),(100011),(1111111)}

显然满足 C2⊂C1C_2\subset C_1C2⊂C1 。现在对应于代码 (0000000)∈C1(0000000) \in C_1(0000000)∈C1 构成的状态 ∣0000000+C2⟩|0000000+C_2\rangle∣0000000+C2⟩，我们可以得到 ∣s0⟩|s_0\rangle∣s0⟩ ：
s0=∣(0000000)+C2⟩=18∑y∈C2∣0000000+y⟩=18{(0000000),(1010101),(0110011),(1100110),(0001111),(1011010),(0111100),(1101001)}\begin{aligned} s_0 &= |(0000000) + C_2\rangle\\ \\ &= \frac{1}{\sqrt{8}}\sum_{y\in C_2}|0000000+y\rangle \\ & = \frac{1}{\sqrt{8}}\{(0000000),(1010101),(0110011),(1100110), \\ & (0001111),(1011010),(0111100),(1101001)\} \end{aligned}s0=∣(0000000)+C2⟩=81y∈C2∑∣0000000+y⟩=81{(0000000),(1010101),(0110011),(1100110),(0001111),(1011010),(0111100),(1101001)}

若再任取 C1C_1C1 与 C2C_2C2 交集中的任意元素，例如 (1010101)(1010101)(1010101) ，它也构成下列状态:
∣(1010101)+C2⟩=18∑y∈C2∣1010101+y⟩=18{(1010101),(0000000),(1100110),(0110011),(1011010),(0001111),(1101001),(0111100)}\begin{aligned} &|(1010101) + C_2\rangle \\ &= \frac{1}{\sqrt{8}}\sum_{y\in C_2}|1010101+y\rangle \\ & = \frac{1}{\sqrt{8}}\{ (1010101),(0000000),(1100110),(0110011), \\ & (1011010),(0001111),(1101001),(0111100)\} \end{aligned}∣(1010101)+C2⟩=81y∈C2∑∣1010101+y⟩=81{(1010101),(0000000),(1100110),(0110011),(1011010),(0001111),(1101001),(0111100)}

该结果与 (0000000)(0000000)(0000000) 对应的状态 ∣s0⟩|s_0\rangle∣s0⟩ 是一致的。即
∣0000000+C2⟩=∣1010101+C2⟩|0000000+C_2\rangle=|1010101+C_2\rangle∣0000000+C2⟩=∣1010101+C2⟩

现在我们选择包含在 C1C_1C1 中但不包含在 C2C_2C2 中的 ∣1111111⟩|1111111\rangle∣1111111⟩ ，能够获得第 2 个状态 ∣s1⟩|s_1\rangle∣s1⟩：
s0=∣(1111111)+C2⟩=18∑y∈C2∣1111111+y⟩=18{(1111111),(0101010),(1001100),(0011001),(1110000),(0100101),(1000011),(0010110)}\begin{aligned} s_0 &= |(1111111) + C_2\rangle\\ &= \frac{1}{\sqrt{8}}\sum_{y\in C_2}|1111111+y\rangle \\ &= \frac{1}{\sqrt{8}}\{(1111111),(0101010),(1001100),(0011001), \\ &(1110000),(0100101),(1000011),(0010110)\} \end{aligned}s0=∣(1111111)+C2⟩=81y∈C2∑∣1111111+y⟩=81{(1111111),(0101010),(1001100),(0011001),(1110000),(0100101),(1000011),(0010110)}

因为
⟨s0∣s1⟩=⟨C2+1010101∣1111111+C2⟩=⟨C2∣1111111⟩+⟨1010101∣1111111⟩+⟨C2∣C2⟩+⟨1010101∣C2⟩=0\begin{aligned} \langle s_0|s_1\rangle & = \langle C_2 + 1010101 | 1111111+C_2\rangle \\ &= \langle C_2| 1111111\rangle + \langle1010101 | 1111111\rangle+ \langle C_2|C_2\rangle + \langle 1010101 | C_2\rangle \\ &=0 \end{aligned} ⟨s0∣s1⟩=⟨C2+1010101∣1111111+C2⟩=⟨C2∣1111111⟩+⟨1010101∣1111111⟩+⟨C2∣C2⟩+⟨1010101∣C2⟩=0

所以，∣s0⟩|s_0\rangle∣s0⟩ 与 s1s_1s1 直交。因为此时
2k12k2=2k1−k2=24−3=2\frac{2^{k_1}}{2^{k_2}}=2^{k_1-k_2}=2^{4-3}=22k22k1=2k1−k2=24−3=2

所以不可能再找到一个 ∣s′⟩|s'\rangle∣s′⟩ 与 ∣s0⟩|s_0\rangle∣s0⟩ 、∣s1⟩|s_1\rangle∣s1⟩ 都直交。即对应于 C1C_1C1 的代码集合，除了 2 个状态 {∣s0⟩,∣s1⟩}\{|s_0\rangle,|s_1\rangle\}{∣s0⟩,∣s1⟩} 以外，其他状态是不存在的。因此，对应的量子纠缠码的集合是 [[7,4−3]]=[[7,1]][[7,4-3]]=[[7,1]][[7,4−3]]=[[7,1]] 的量子代码集合，则一个 qubit 的状态 α∣0⟩+β∣1⟩\alpha|0\rangle+\beta|1\rangleα∣0⟩+β∣1⟩ 可以转换成以下代码：
α∣s0⟩+β∣s1⟩\alpha|s_0\rangle+\beta|s_1\rangleα∣s0⟩+β∣s1⟩

3.CSS 编码的解码

下面我们学习经过 CSS 编码后的信息，在信道中传输后发生了 bit 错误，或者位相反转错误后，怎么进行订正。为了简单，我们只讨论 bit 反转和位相反转各自至多发生一个错误时的解码方法，当一个以上的错误发生时，使用同样的方法可以实现解码。

对于发生 bit 反转错误的订正方法

考虑下面状态的编码：
∣x+C2⟩=12k22∑y∈C2∣x+y⟩|x+C_2\rangle=\frac{1}{2^{\frac{k_2}{2}}}\sum_{y\in C_2}|x+y\rangle∣x+C2⟩=22k21y∈C2∑∣x+y⟩

假设线性编码集合 C1C_1C1 的奇偶校验矩阵为 H1H_1H1 ，因为 x∈C1x\in C_1x∈C1 ，则
xH1T=0xH_1^T=0xH1T=0

又因为 C2⊂C1C_2\subset C_1C2⊂C1 ，所以对于任意的 y∈C2y\in C_2y∈C2 ，同样有
yH1T=0yH_1^T=0yH1T=0

成立。因此，对应于状态 ∣x+C2⟩|x+C_2\rangle∣x+C2⟩ 等式的右边状态 ∣x+y⟩|x+y\rangle∣x+y⟩ 矢量 x+yx+yx+y 的伴随式，即使 y∉C2y\notin C_2y∈/C2 下面的等式也成立：
(x+y)H1T=xH1T+yH1T=0(x+y)H_1^T=xH_1^T+yH_1^T=0(x+y)H1T=xH1T+yH1T=0

假设用 eie_iei 表示长度为 n 的、仅在第 iii 位为 1、其他各位均为 0 的矢量，则 ∣x⟩|x\rangle∣x⟩ 的第 iii 位上 qubit 发生 bit 反转后的状态可用 ∣x+ei⟩|x+e_i\rangle∣x+ei⟩ 表示。所以状态 ∣x+C2⟩|x+C_2\rangle∣x+C2⟩ 的第 iii 位上 qubit 发生 bit 反转错误时，我们收到的状态可用下式表示：
∣φ⟩=12k22∑y∈C2∣x+y+ei⟩|\varphi\rangle=\frac{1}{2^\frac{k_2}{2}}\sum_{y\in C_2}|x+y+e_i\rangle∣φ⟩=22k21y∈C2∑∣x+y+ei⟩

计算该状态 ∣x+y+ei⟩|x+y+e_i\rangle∣x+y+ei⟩ 对应于矢量 x+u+eix+u+e_ix+u+ei 的伴随式，即使 y∉C2y\notin C_2y∈/C2 ，也能够得到下面的等式：
(x+y+ei)H1T=xH1T+yH1T+eiH1T+=eiH1T(x+y+e_i)H_1^T=xH_1^T+yH_1^T+e_iH_1^T+=e_iH_1^T(x+y+ei)H1T=xH1T+yH1T+eiH1T+=eiH1T

也就是说集合中的代码全体拥有同一个伴随式 eiH1Te_iH_1^TeiH1T 。这里因为线性编码集合 C1C_1C1 能够订正 ttt 个错误，所以对应于唯一一个错误的伴随式 e1H1T,e2H1T,⋯enH1Te_1H_1^T,e_2H_1^T,\cdots e_nH_1^Te1H1T,e2H1T,⋯enH1T 当然是相互不同的。显然，如果能够从接受到的信息状态 ∣φ⟩|\varphi\rangle∣φ⟩ 中求出伴随式 eiH1Te_iH_1^TeiH1T ，使用经典纠错码的解码方法就能够知道在哪一位 qubit 上发生了错误，在错误发生的 qubit 位上通过 X−GateX - GateX−Gate 执行 bit 反转演算，就可以订正相应的错误。

实际执行伴随式计算的量子门电路如下所示：

所以，对应于伴随式的 3 个 qubit 如果能够基于基底状态 {∣0⟩,∣1⟩}\{|0\rangle,|1\rangle\}{∣0⟩,∣1⟩} 进行测定，判定它们是 0 或 1 ，就能够以概率 1 得知伴随式 eiHite_iH_i^teiHit 。

对于发生位相翻转错误的订正方法

首先我们对每个 qubit 位执行 Hadamard 变换演算。此时对 ∣x⟩|x\rangle∣x⟩ 实施 Hadamard 变换演算的结果如下所示：
∣x⟩⟶Hadamard12n∑y∈{0,1}n(−1)(x⋅y)∣y⟩|x\rangle \stackrel{Hadamard}{\longrightarrow} \frac{1}{\sqrt{2^n}}\sum_{y\in \{0,1\}^n}(-1)^{(x·y)}|y\rangle∣x⟩⟶Hadamard2n1y∈{0,1}n∑(−1)(x⋅y)∣y⟩

该式的成立于两个序列 y=(y1,y2,⋯,yn),x=(x1,x2,⋯,xn)y=(y_1,y_2,\cdots,y_n) ,x=(x_1,x_2, \cdots ,x_n)y=(y1,y2,⋯,yn),x=(x1,x2,⋯,xn) 有关， ∣y⟩|y\rangle∣y⟩ 的正负由 yi=1y_i=1yi=1 且 xi=1x_i=1xi=1 的 bit 位置有几个来决定，如果是偶数个，则位正，奇数个则为负。

那么，利用编码对状态
∣x+C2⟩=12k22∑y∈C2∣x+y⟩|x+C_2\rangle=\frac{1}{2^{\frac{k_2}{2}}}\sum_{y\in C_2}|x+y\rangle∣x+C2⟩=22k21y∈C2∑∣x+y⟩

的各个 qubit 实施 Hadamard 变换演算，可以得到下式：
12k222n2∑z∈{0,1}n∑y∈C2(−1)(x+y)⋅z∣z⟩\frac{1}{ 2^{\frac{k_2}{2}} 2^{\frac{n}{2}} } \sum_{ z\in\{0,1\}^n } \sum_{y\in C_2} (-1)^{(x+y)·z}|z\rangle22k222n1z∈{0,1}n∑y∈C2∑(−1)(x+y)⋅z∣z⟩

这里利用线性编码集合 C2C_2C2 的线性性质导出的关系式：
∑y∈C2(−1)y⋅z={2k2ifz∈C2⊥0ifz∉C2⊥\sum_{y\in C_2}(-1)^{y·z}=\left\{ \begin{aligned} 2^{k_2} & & if \ z\in C_2^\bot \\ 0 & & if \ z\notin C_2^\bot \\ \end{aligned} \right. y∈C2∑(−1)y⋅z={2k20if z∈C2⊥if z∈/C2⊥

则上面的状态可以写成下面的形式：
12k222n2∑z∈{0,1}n(−1)x⋅z∑y∈C2(−1)y⋅z∣z⟩=2k222n2∑z∈C2⊥(−1)x⋅z∣z⟩\frac{1}{ 2^{\frac{k_2}{2}} 2^{\frac{n}{2}} } \sum_{ z\in\{0,1\}^n } (-1)^{x·z} \sum_{y\in C_2} (-1)^{y·z}|z\rangle= \frac{ 2^{\frac{k_2}{2}} }{ 2^{\frac{n}{2}} } \sum_{ z\in C_2^\bot } (-1)^{x·z}|z\rangle 22k222n1z∈{0,1}n∑(−1)x⋅zy∈C2∑(−1)y⋅z∣z⟩=22n22k2z∈C2⊥∑(−1)x⋅z∣z⟩

上式右边出现的状态 zzz 所对应的矢量 zzz 已都是 C2⊥C_2^\botC2⊥ 或者说是线性编码集合 C2C_2C2 的对偶编码集合的元素了。

我们再次用 eje_jej 表示长度为 n 的、仅在第 jjj 位为 1、其他各位均为 0 的矢量，那么对于矢量 xejxe_jxej ，当 xxx 的第 jjj 位为 1 时 xejxe_jxej 为1，当 xxx 的第 jjj 位为 0 时则 xejxe_jxej 就为 0 ；当第 jjj 位发生位相翻转错误时，∣x⟩|x\rangle∣x⟩ 就变成了 (−1)x⋅ej∣x⟩(-1)^{x·e_j}|x\rangle(−1)x⋅ej∣x⟩ 。因此，如果状态 ∣x+C2⟩|x+C_2\rangle∣x+C2⟩ 的第 jjj 位 qubit 上发生位相翻转错误时，将得到下列状态：
12k22∑y∈C2(−1)(x+y)⋅ej∣x+y⟩\frac{1}{2^{\frac{k_2}{2}}} \sum_{y\in C_2} (-1)^{(x+y)·e_j} |x+y\rangle 22k21y∈C2∑(−1)(x+y)⋅ej∣x+y⟩

对该状态的各个 qubit 实施 Hadamard 变换演算，可以得到：
12k222n2∑z∈{0,1}n∑y∈C2(−1)(x+y)⋅(ej+z)∣z⟩=12k222n2∑z′∈{0,1}n∑y∈C2(−1)(x+y)⋅z′∣z+ej⟩\frac{1}{ 2^{\frac{k_2}{2}} 2^{\frac{n}{2}} } \sum_{ z\in\{0,1\}^n } \sum_{y\in C_2} (-1)^{(x+y)·(e_j+z)}|z\rangle= \frac{1}{ 2^{\frac{k_2}{2}} 2^{\frac{n}{2}} } \sum_{ z'\in\{0,1\}^n } \sum_{y\in C_2} (-1)^{(x+y)·z'}|z+e_j\rangle 22k222n1z∈{0,1}n∑y∈C2∑(−1)(x+y)⋅(ej+z)∣z⟩=22k222n1z′∈{0,1}n∑y∈C2∑(−1)(x+y)⋅z′∣z+ej⟩

这里设 z′=z+ejz'=z+e_jz′=z+ej 。再一次利用 CSS 进行编码可以得到下面的结果：

2k222n2∑z′∈C2⊥(−1)x⋅z′∣z′+ej⟩\frac{ 2^{\frac{k_2}{2}} }{ 2^{\frac{n}{2}} } \sum_{ z'\in C_2^\bot } (-1)^{x·z'}|z'+e_j\rangle 22n22k2z′∈C2⊥∑(−1)x⋅z′∣z′+ej⟩

由此可以得出，经过 Hadamard 变换演算，位相翻转错误可以变成 bit 反转错误。因此对于上面的状态，只要订正 bit 反转错误就可以实现订正位相反转错误。实际上利用代码集合 C2⊥C_2^\botC2⊥ 的奇偶校验矩阵为 H2H_2H2 ，求解状态 ∣z′+ej⟩|z'+e_j\rangle∣z′+ej⟩ 对应矢量 z′+ejz'+e_jz′+ej 的伴随式为 ejH2Te_jH_2^TejH2T ，因为 C2⊥C_2^\botC2⊥ 能够订正 t 个以下错误，因此，从伴随式可以确定错误 eje_jej 并能够订正它。作为结果，得到下列状态：
2k222n2∑z′∈C2⊥(−1)(x+y)⋅z′∣z′⟩\frac{ 2^{\frac{k_2}{2}} }{ 2^{\frac{n}{2}} } \sum_{ z'\in C_2^\bot } (-1)^{(x+y)·z'}|z'\rangle 22n22k2z′∈C2⊥∑(−1)(x+y)⋅z′∣z′⟩

然后再一次对该状态的各个 qubit 实施 Hadamard 变换演算，就能够获得纠正后的正确的送信的原始状态信息。

对于 bit 反转和位相翻转错误同时发生的订正方法

如果状态 ∣x+C2⟩|x+C_2\rangle∣x+C2⟩ 第 iii 位 qubit 上发生 bit 反转错误、第 jjj 位 qubit 上发生位相反转错误时，将得到下列状态：

12k22∑y∈C2(−1)(x+y)⋅ej∣x+y+ei⟩\frac{ 1 }{ 2^{\frac{k_2}{2}} } \sum_{y\in C_2} (-1)^{(x+y)·e_j} |x+y+e_i\rangle 22k21y∈C2∑(−1)(x+y)⋅ej∣x+y+ei⟩

如果计算该状态 ∣x+y+ei⟩|x+y+e_i\rangle∣x+y+ei⟩ 所对应的矢量 x+y+eix+y+e_ix+y+ei 的伴随式，将得到 eiH1Te_iH_1^TeiH1T ，由线性编码集合 C1C_1C1 的解码方法能够确认在第 iii 位 qubit 上发生 bit 反转错误，因此对第 iii 位上的 qubit 实施 bit 反转演算 X−GateX - GateX−Gate ，订正 bit 反转错误后的状态就变为如下：
12k22∑y∈C2(−1)(x+y)⋅ej∣x+y⟩\frac{ 1 }{ 2^{\frac{k_2}{2}} } \sum_{y\in C_2} (-1)^{(x+y)·e_j} |x+y\rangle 22k21y∈C2∑(−1)(x+y)⋅ej∣x+y⟩

此时的状态仅包含位相翻转错误，同样的道理，使用前面所讨论的订正位相翻转错误的方法，自然能够恢复发送信息的原始状态

4.量子纠错码的性能界限

这里我们再来讨论以下当给定代码长度为 n ，码字 qubit 数为 k 时，这些量子纠错码的性能界限。显然能够订正的错误个数越多，其量子吗的性能就越高。下面先介绍量子编码可以达到的性能的下界 。

定理（量子 Gilbert - Varshamov 界限）：

当代码长度 n 足够大时，能够订正 t 个 qubit 位上发生错误的量子编码在 CSS 编码中存在，该编码>是编码参数 (n,k,t)(n,k,t)(n,k,t) 满足下列不等式的 [[n,k]][[n,k]][[n,k]] 量子编码体系。
kn≥1−2H(2tn)\frac{k}{n}\geq1-2H(\frac{2t}{n})nk≥1−2H(n2t)

其中函数 H(x)H(x)H(x) 由下列等式定义：
H(x)=−xlog⁡x−(1−x)log⁡(1−x)H(x)=-x\log x-(1-x)\log(1-x)H(x)=−xlogx−(1−x)log(1−x)

这个定理说明量子编码的错误订正能力保持在 tn\frac{t}{n}nt 的一定水准时，其编码的效率能够保持在一定值 kn\frac{k}{n}nk 以上。

下面介绍量子编码可达到的性能上界：

定理（量子 Hamming 界限）：

任意的 [[n,k]][[n,k]][[n,k]] 量子编码体系，能够订正错误的 qubit 数 t 满足下列不等式：

∑j=0t(nj)3j2k≤2n\sum_{j=0}^t \left( \begin{matrix} n \\ j \end{matrix} \right) 3^j2^k\leq 2^n j=0∑t(nj)3j2k≤2n

这个定理不依赖于量子纠错码的构成方法，无论什么样的量子编码体系，这个不等式都成立。