两个多项式，
十二个逻辑比特 Two polynomials,
twelve logical qubits

先看经典码。三比特重复码把 0 编成 000、1 编成 111。要发现出错，不必读出每一位，只要问「第 1 位加第 2 位（mod 2）是不是 0」：000 和 111 都答 0，010 答 1，说明出错了。这个问题就是一条检查。它可以写成一行 0/1：(1, 1, 0)，1 标出「哪几位参与相加」；「检查通过」= 参与位之和为偶数。

Start with a classical code. The three-bit repetition code encodes 0 as 000 and 1 as 111. To catch an error you need not read every bit: just ask “is bit 1 plus bit 2 (mod 2) equal to 0?” — 000 and 111 answer 0, 010 answers 1, so something went wrong. That question is one check. It can be written as a row of 0/1, (1, 1, 0), the 1s marking “which bits take part in the sum”; “the check passes” means the participating bits sum to an even number.

量子码不能直接读比特——读了叠加态就塌了。替代品是测一个算符，让测量结果只透露奇偶。Pauli Z 满足 Z|0⟩ = +|0⟩、Z|1⟩ = −|1⟩，所以在两个比特上各放一个 Z 再乘起来，算符 Z⊗Z 作用在 |b₁b₂⟩ 上给出符号 (−1)^b₁+b₂：测得 +1 说明两位相同，−1 说明不同；而 |00⟩ + |11⟩ 这种叠加态测完仍是它自己——只问了奇偶，没问各位是几。这就是「一条 Z 检查」：在某几个比特上放 Z（其余放恒等 I），把它们乘成一个算符，测它，+1 是通过、−1 是警报。写成 0/1 行向量 v，1 标出放了 Z 的比特，和经典的 (1, 1, 0) 完全对应。

A quantum code cannot read its bits directly — reading collapses a superposition. The substitute is to measure an operator whose outcome reveals only a parity. Pauli Z satisfies Z|0⟩ = +|0⟩ and Z|1⟩ = −|1⟩, so placing a Z on each of two qubits and multiplying, the operator Z⊗Z acting on |b₁b₂⟩ gives the sign (−1)^b₁+b₂: outcome +1 means the two bits agree, −1 that they differ; and a superposition such as |00⟩ + |11⟩ is left exactly as it was — only the parity was asked, never the individual bits. That is “one Z check”: put a Z on some qubits (identity I on the rest), multiply them into one operator, measure it, +1 is a pass, −1 an alarm. Written as a 0/1 row vector v, the 1s mark the qubits carrying a Z, exactly like the classical (1, 1, 0).

X 检查同理，只是换了一种「位」。X 的本征态是 |+⟩ = |0⟩ + |1⟩（本征值 +1）和 |−⟩ = |0⟩ − |1⟩（−1），在几个比特上放 X 再乘起来，测 X⊗X⊗…，得到的是这些比特「在 ± 基下」的奇偶。它有用，是因为一个 Z 错误会把 |+⟩ 变成 |−⟩——Z 错误在 ± 基下就是一次翻转。所以 X 检查抓 Z 错误，Z 检查抓 X 错误，量子码需要两类检查各管一半。「一条 X 检查是在某些比特上放 X」，说的就是算符 ∏_q∈S X_q：S 是它碰到的比特集合，对应 0/1 行向量 u。把所有 X 检查的行叠起来就是 H_X，所有 Z 检查叠起来就是 H_Z。

X checks work the same way with a different kind of “bit”. The eigenstates of X are |+⟩ = |0⟩ + |1⟩ (eigenvalue +1) and |−⟩ = |0⟩ − |1⟩ (−1); placing X on a few qubits and measuring X⊗X⊗… reads the parity of those qubits “in the ± basis”. It is useful because a Z error turns |+⟩ into |−⟩ — in the ± basis a Z error is a flip. So X checks catch Z errors and Z checks catch X errors, and a quantum code needs both kinds, each minding half of the job. “An X check is X placed on some qubits” means the operator ∏_q∈S X_q: S is the set of qubits it touches, encoded as the 0/1 row vector u. Stacking the rows of all X checks gives H_X, stacking all Z checks gives H_Z.

第 i 行第 j 列的 1 是什么意思What a 1 in row i, column j means

行是检查，列是比特。H_X 第 i 行第 j 列为 1，意思是第 i 条 X 检查在第 j 个比特上放了一个 X；为 0 就是什么都不放。同一个 1 从两个方向读，各有一层含义。按行读，一行就是一条检查的「腿」：有 1 的那些列是它碰到的比特，1 的个数是检查重量（3.1）；症状电路里每个 1 对应一个 CNOT——辅助比特 i 和数据比特 j 之间要连一根线——这就是6.1 Tanner 图里的一条边。按列读，一列就是一个比特的「归属」：有 1 的那些行是碰到它的检查，决定它出错时谁会报警。一个 X 错误翻转所有含它的 Z 检查的结果，所以 H_Z 的第 j 列就是「比特 j 发生 X 错误时的症状」；一般地，错误向量 e（第 j 位为 1 表示比特 j 出了 X 错误）的症状是 s = H_Z·e (mod 2)，其第 i 个分量是「检查 i 里有多少个出错比特」的奇偶。列里 1 的个数叫比特度，gross 码每列 3 个，一个错误点亮三个警报——6.3 里匹配译码失效的原因。

Rows are checks, columns are qubits. A 1 in row i, column j of H_X means check i places an X on qubit j; a 0 means it places nothing. The same 1 reads two ways. Along the row, a row is one check’s “legs”: the columns holding a 1 are the qubits it touches, and the number of 1s is the check weight (§3.1); in the syndrome circuit every 1 is one CNOT — a wire between ancilla i and data qubit j — which is one edge of the Tanner graph of §6.1. Down the column, a column is one qubit’s “membership”: the rows holding a 1 are the checks touching it, which decides who raises the alarm when it fails. An X error flips the outcome of every Z check containing it, so column j of H_Z is “the syndrome of an X error on qubit j”; in general an error vector e (bit j set when qubit j suffers an X error) has syndrome s = H_Z·e (mod 2), whose i-th entry is the parity of “how many faulty qubits check i contains”. The number of 1s in a column is the qubit degree; the gross code has 3 per column, so one error lights three alarms — the reason matching decoders fail in §6.3.

H_X 与 H_Z 的行数可以不同H_X and H_Z may have different numbers of rows

两个矩阵只有列数必须相同——列是物理比特，都是 n 列；行数分别是 X 检查和 Z 检查的条数，没有理由相等。乘积 H_XH_Zᵀ 是 (X 检查数) × (Z 检查数) 的矩阵，照样能乘、照样要求全为 0。经典例子是 Shor 的九比特码，H_Z 六行、H_X 两行：

Only the number of columns must agree — columns are physical qubits, n of them in both; the numbers of rows count X checks and Z checks separately and need not be equal. The product H_XH_Zᵀ is then an (X checks) × (Z checks) matrix, still well defined and still required to vanish. The classic example is Shor’s nine-qubit code, six rows in H_Z and two in H_X:

任取一条 X 检查和一条 Z 检查，共享的比特要么 0 个、要么 2 个（如 X₁…X₆ 与 Z₁Z₂ 共享 {1, 2}），2 × 6 的 H_XH_Zᵀ 全是偶数，码合法，k = 9 − 6 − 2 = 1。这种不对称有实际含义：六条 Z 检查让它能纠每个三比特块里各一个 X 错误，两条 X 检查却只够纠总共一个 Z 错误。BB 码、环面码里两个矩阵行数恰好都等于 lm，是因为每个格子配了一条 X 检查和一条 Z 检查——这是这一族的对称性，不是 CSS 码的要求；4.1 特意论证 rank H_X = rank H_Z，正说明它需要证明。行数本身也不重要，重要的是秩（补课 0.D）。

Any X check shares either 0 or 2 qubits with any Z check (X₁…X₆ and Z₁Z₂ share {1, 2}), so the 2 × 6 product H_XH_Zᵀ is all even, the code is legitimate, and k = 9 − 6 − 2 = 1. The asymmetry has a practical meaning: six Z checks let the code correct one X error in each three-qubit block, while two X checks only suffice for a single Z error overall. In BB and toric codes both matrices happen to have lm rows because every site carries one X check and one Z check — a symmetry of this family, not a requirement of CSS codes; §4.1 takes the trouble to prove rank H_X = rank H_Z precisely because it needs proof. Nor is the row count itself what matters — the rank is (Catch-up 0.D).

|ψ⟩ 是一个列向量，ψ 是这个向量的名字，尖括号是物理学家的记法。一个量子比特的状态是二维向量，两个基向量记作 |0⟩ = (1, 0)ᵀ、|1⟩ = (0, 1)ᵀ，一般状态是它们的线性组合，例如 |0⟩ + |1⟩ = (1, 1)ᵀ（归一化系数先不管，不影响下面任何结论）。两个比特的状态是四维向量，基是 |00⟩、|01⟩、|10⟩、|11⟩，比如 |00⟩ + |11⟩ = (1, 0, 0, 1)ᵀ。

|ψ⟩ is a column vector; ψ is its name and the angle bracket is the physicists’ notation. The state of one qubit is a two-dimensional vector with basis vectors |0⟩ = (1, 0)ᵀ and |1⟩ = (0, 1)ᵀ; a general state is a linear combination such as |0⟩ + |1⟩ = (1, 1)ᵀ (normalisation is ignored here; it changes nothing below). Two qubits give a four-dimensional vector with basis |00⟩, |01⟩, |10⟩, |11⟩, e.g. |00⟩ + |11⟩ = (1, 0, 0, 1)ᵀ.

S 是一个矩阵，「S 作用在 |ψ⟩ 上」就是矩阵乘向量。单比特的 Z 和 X 是

S is a matrix, and “S acts on |ψ⟩” is matrix-times-vector. For one qubit,

S|ψ⟩ = |ψ⟩ 的字面意思：矩阵 S 乘上向量 |ψ⟩，结果还是原来的向量，一点没变。更一般的形式 S|ψ⟩ = λ|ψ⟩ 说矩阵只把向量拉伸了 λ 倍、没改方向——这样的向量叫 S 的本征向量，λ 叫本征值。Pauli 算符的平方都是 I，所以本征值只能是 +1 或 −1：|0⟩ 是 Z 的 +1 本征向量、|1⟩ 是 −1 本征向量；|+⟩、|−⟩ 对 X 同理。

What S|ψ⟩ = |ψ⟩ says literally: multiply the vector |ψ⟩ by the matrix S and you get the very same vector back. The general form S|ψ⟩ = λ|ψ⟩ says S merely stretches the vector by λ without turning it — such a vector is an eigenvector of S and λ its eigenvalue. Every Pauli operator squares to I, so the eigenvalues can only be +1 or −1: |0⟩ is a +1 eigenvector of Z and |1⟩ a −1 eigenvector; likewise |+⟩ and |−⟩ for X.

为什么这和「检查通过」是一回事。量子力学里「测量一个算符 S」的规则是：结果一定是 S 的某个本征值，测完后状态落到对应的本征向量上。所以若 S|ψ⟩ = |ψ⟩，测 S 必然得 +1，而且状态原地不动——这就是「通过检查、且检查没有破坏状态」，检查之所以可以每一轮反复测而不损伤编码信息，靠的就是这一点。若 S|ψ⟩ = −|ψ⟩，必然得 −1，即警报。码空间的定义就是：所有检查 S_i 都满足 S_i|ψ⟩ = |ψ⟩ 的那些 |ψ⟩——每一条检查都稳稳答 +1、又不会被测量搅乱的状态，逻辑信息就存在它们的线性组合里。

Why this is the same as “passing the check”. The rule for “measuring an operator S” in quantum mechanics: the outcome is always one of S’s eigenvalues, and afterwards the state lies in the corresponding eigenvector. So if S|ψ⟩ = |ψ⟩, measuring S must give +1 and leaves the state untouched — “the check passes and does not disturb the state”, which is exactly why checks can be measured round after round without harming the encoded information. If S|ψ⟩ = −|ψ⟩ the outcome must be −1: an alarm. The code space is by definition the set of all |ψ⟩ with S_i|ψ⟩ = |ψ⟩ for every check S_i — states that answer +1 to every check with certainty and are not scrambled by the measurements; the logical information lives in their linear combinations.

diag(1, −1, −1, 1)：Z⊗Z 长什么样diag(1, −1, −1, 1): what Z⊗Z looks like

diag 是「对角矩阵」的简写，括号里的数依次放在主对角线上，其余全是 0。对角矩阵乘向量就是把每个分量各乘对角线上对应的数。两比特的四个基向量按 |00⟩、|01⟩、|10⟩、|11⟩ 排序，Z⊗Z 表示「两个比特上都作用 Z」，对 |b₁b₂⟩ 给出符号 (−1)^b₁·(−1)^b₂，四个基向量各自只被乘了一个数，所以矩阵是对角的。用 2.2 节的克罗内克积算也一样：Z⊗Z = [1·Z, 0·Z; 0·Z, −1·Z]。

diag is short for “diagonal matrix”: the listed numbers sit on the main diagonal and everything else is 0, and such a matrix multiplies each component of a vector by the corresponding diagonal entry. Ordering the two-qubit basis as |00⟩, |01⟩, |10⟩, |11⟩, Z⊗Z means “Z on both qubits” and gives |b₁b₂⟩ the sign (−1)^b₁·(−1)^b₂; each basis vector is merely scaled, so the matrix is diagonal. The Kronecker product of §2.2 gives the same thing: Z⊗Z = [1·Z, 0·Z; 0·Z, −1·Z].

例：|ψ⟩ = |00⟩ + |11⟩ = (1, 0, 0, 1)ᵀ，Z⊗Z|ψ⟩ = (1·1, −1·0, −1·0, 1·1)ᵀ = |ψ⟩，+1 本征向量，测必得 +1，「两位奇偶相同」通过，叠加态完好且我们仍不知道它是 00 还是 11。|01⟩ + |10⟩ = (0, 1, 1, 0)ᵀ 被送到 (0, −1, −1, 0)ᵀ = −(原向量)，本征值 −1，警报。而 |00⟩ + |01⟩ = (1, 1, 0, 0)ᵀ 被送到 (1, −1, 0, 0)ᵀ，不是原向量的倍数——它没有确定的检查结果。

Example: |ψ⟩ = |00⟩ + |11⟩ = (1, 0, 0, 1)ᵀ gives Z⊗Z|ψ⟩ = (1·1, −1·0, −1·0, 1·1)ᵀ = |ψ⟩, a +1 eigenvector: the outcome is certainly +1, “equal parity” passes, the superposition survives and we still do not know whether it is 00 or 11. |01⟩ + |10⟩ = (0, 1, 1, 0)ᵀ is sent to (0, −1, −1, 0)ᵀ = −(itself), eigenvalue −1, alarm. But |00⟩ + |01⟩ = (1, 1, 0, 0)ᵀ is sent to (1, −1, 0, 0)ᵀ, not a multiple of itself — it has no definite check outcome.

两头不靠的态怎么办：测量一定落在 ±1 上States that are neither: measurement still lands on ±1

对任何满足 S² = I 的算符，定义 P₊ = (I + S)/2、P₋ = (I − S)/2。两者相加是 I，所以任何 |ψ⟩ = P₊|ψ⟩ + P₋|ψ⟩；又 S·P₊ = (S + S²)/2 = P₊，所以 P₊|ψ⟩ 是 +1 本征向量，同理 P₋|ψ⟩ 是 −1 本征向量。任何态都能唯一拆成「一份 +1 加一份 −1」，「S|ψ⟩ 既不等于 |ψ⟩ 也不等于 −|ψ⟩」只是说两份都不为零。测 S 得 +1 的概率是 ‖P₊|ψ⟩‖²，得 −1 的概率是 ‖P₋|ψ⟩‖²，测到哪个，状态就塌到那一份。对 Z⊗Z，P₊ 保留 |00⟩、|11⟩ 分量，P₋ 保留 |01⟩、|10⟩ 分量：|00⟩ + |01⟩ 各以 1/2 的概率给 +1（塌到 |00⟩）或 −1（塌到 |01⟩），测完之后 S|ψ′⟩ = ±|ψ′⟩ 就成立了。

For any operator with S² = I define P₊ = (I + S)/2 and P₋ = (I − S)/2. They add up to I, so every |ψ⟩ = P₊|ψ⟩ + P₋|ψ⟩; and S·P₊ = (S + S²)/2 = P₊, so P₊|ψ⟩ is a +1 eigenvector, and likewise P₋|ψ⟩ a −1 eigenvector. Every state splits uniquely into “a +1 part plus a −1 part”; “S|ψ⟩ is neither |ψ⟩ nor −|ψ⟩” just says both parts are nonzero. Measuring S gives +1 with probability ‖P₊|ψ⟩‖² and −1 with probability ‖P₋|ψ⟩‖², and the state collapses onto the part that was found. For Z⊗Z, P₊ keeps the |00⟩, |11⟩ components and P₋ the |01⟩, |10⟩ ones: |00⟩ + |01⟩ gives +1 (collapsing to |00⟩) or −1 (collapsing to |01⟩) with probability 1/2 each, and afterwards S|ψ′⟩ = ±|ψ′⟩ holds.

这件事在纠错里恰恰是关键。真实的错误往往不是干脆的「翻了/没翻」，而是一个小角度的转动 cos θ·|ψ⟩ + sin θ·X₁|ψ⟩。测检查时第一项落在 +1 份、第二项落在 −1 份，于是以 cos²θ 的概率回到 |ψ⟩（错误被测量抹掉），以 sin²θ 的概率变成 X₁|ψ⟩（再补一个 X₁ 纠回来）。连续的模拟错误被检查测量强行数字化成有限几种，量子纠错才能像经典纠错那样工作。物理上「测 Z⊗Z」由一个辅助比特加几个 CNOT 实现（6.2），读出 0 对应 +1、读出 1 对应 −1；它的数学效果就是上面的 P₊、P₋。

This is exactly what error correction relies on. Real errors are rarely a clean “flipped / not flipped” but a small rotation cos θ·|ψ⟩ + sin θ·X₁|ψ⟩. Measuring a check puts the first term in the +1 part and the second in the −1 part, so with probability cos²θ the state returns to |ψ⟩ (the error is erased by the measurement) and with probability sin²θ it becomes X₁|ψ⟩ (undone by applying X₁). Continuous, analogue errors are forcibly digitised into finitely many cases by the check measurements — which is why quantum error correction can work like classical error correction at all. Physically “measuring Z⊗Z” is done with one ancilla and a few CNOTs (§6.2), a readout of 0 meaning +1 and 1 meaning −1; its mathematical effect is precisely P₊ and P₋ above.

第一环：同一个比特上，XZ = −ZX。用 2 × 2 矩阵直接乘：

Link one: on a single qubit, XZ = −ZX. Multiply the 2 × 2 matrices directly:

不同比特上的算符可以随意交换：X₁ 是 X⊗I⊗I⊗I，Z₂ 是 I⊗Z⊗I⊗I，(X⊗I)(I⊗Z) = X⊗Z = (I⊗Z)(X⊗I)，交换不出符号。于是把 X 串 X(u) 从 Z 串 Z(v) 的左边挪到右边，每个共同踩到的比特付一个 −1，其余免费：

Operators on different qubits swap freely: X₁ is X⊗I⊗I⊗I, Z₂ is I⊗Z⊗I⊗I, and (X⊗I)(I⊗Z) = X⊗Z = (I⊗Z)(X⊗I) with no sign. So moving an X string X(u) from the left of a Z string Z(v) to its right costs one −1 per qubit they both touch and nothing elsewhere:

共享比特数怎么用 u、v 算？第 q 位同时为 1 的位置才算共享，所以共享数 = Σ_q u_qv_q，正是 u 与 v 的点积（按普通整数加）。于是：对易 ⇔ 点积是偶数 ⇔ u·v ≡ 0 (mod 2)。

How is the shared count computed from u and v? Position q counts only when both u_q and v_q are 1, so the count is Σ_q u_qv_q — the dot product of u and v as ordinary integers. Hence: commute ⇔ the dot product is even ⇔ u·v ≡ 0 (mod 2).

第二环：矩阵乘积的元素就是这些点积。按定义，(H_XH_Zᵀ) 的第 (i, j) 元 = H_X 的第 i 行 · H_Zᵀ 的第 j 列，而 H_Zᵀ 的第 j 列就是 H_Z 的第 j 行竖过来——这正是要写 H_Zᵀ 而不是 H_Z 的原因：矩阵乘法是「左边的行点右边的列」，要让两组检查的行互相点积，就得把 H_Z 竖起来。所以 (H_XH_Zᵀ)[i][j] = (第 i 条 X 检查) · (第 j 条 Z 检查) = 它们共享的比特数。

Link two: the entries of the matrix product are exactly these dot products. By definition, entry (i, j) of H_XH_Zᵀ is row i of H_X dotted with column j of H_Zᵀ, and column j of H_Zᵀ is row j of H_Z stood upright — which is why one writes H_Zᵀ rather than H_Z: matrix multiplication dots “rows of the left factor with columns of the right”, so to dot rows against rows, H_Z must be turned on its side. Hence (H_XH_Zᵀ)[i][j] = (X check i) · (Z check j) = the number of qubits they share.

第三环：整张表为零 = 每一对都对易。H_XH_Zᵀ 是 (X 检查数) × (Z 检查数) 的一张表，第 (i, j) 格记着那一对共享几个比特。要求它在 mod 2 下等于零矩阵，就是要求每一格都是偶数，即每一对 X 检查、Z 检查都对易——一对都不能例外。为什么一对都不能例外？码空间是全部检查共同的 +1 本征空间；若 S₁S₂ = −S₂S₁ 而某个 |ψ⟩ 同时满足 S₁|ψ⟩ = |ψ⟩、S₂|ψ⟩ = |ψ⟩，则 |ψ⟩ = S₁S₂|ψ⟩ = −S₂S₁|ψ⟩ = −|ψ⟩，只能是零向量：码空间为空，一个态也编不进去。用测量的话说，每一轮要把全部检查都测一遍，不对易的观测量没有同时确定的值。gross 码 72 条 X 检查、72 条 Z 检查，5184 对全都得对易；BB 码的巧处是不必逐对核对，AB + BA = 2AB = 0 一行代数一次保证（3.2）。

Link three: the whole table vanishing = every pair commuting. H_XH_Zᵀ is an (X checks) × (Z checks) table whose cell (i, j) records how many qubits that pair shares. Demanding that it equal the zero matrix mod 2 demands that every cell be even, i.e. that every pair of an X check and a Z check commute — no exception allowed. Why none? The code space is the +1 eigenspace common to all checks; if S₁S₂ = −S₂S₁ and some |ψ⟩ satisfied both S₁|ψ⟩ = |ψ⟩ and S₂|ψ⟩ = |ψ⟩, then |ψ⟩ = S₁S₂|ψ⟩ = −S₂S₁|ψ⟩ = −|ψ⟩, forcing |ψ⟩ = 0: an empty code space, no state can be encoded. In measurement terms, every round measures all the checks, and non-commuting observables have no simultaneous definite values. The gross code has 72 X checks and 72 Z checks, 5184 pairs that must all commute; the BB trick is that they need not be checked one by one — the single line AB + BA = 2AB = 0 guarantees all of them at once (§3.2).

两点澄清。同类检查之间永远对易（同类型 Pauli 相乘不出符号），所以 CSS 码只需管跨类型的这一张表。「对易」也不要求两条检查有交集：多数对根本不碰同一个比特（共享 0 个，0 是偶数），所以对易；条件真正约束的是那些有重叠的对——重叠必须是偶数个。gross 码里每条检查六条腿，绝大多数对是 0 重叠、少数是 2 重叠，没有一对是 1 或 3。

Two clarifications. Checks of the same type always commute (Paulis of one type multiply without signs), so a CSS code only needs this one cross-type table. Nor does “commute” require the two checks to meet: most pairs touch no common qubit (0 shared, and 0 is even) and so commute; the condition really constrains the overlapping pairs, whose overlap must be even. In the gross code every check has six legs, most pairs overlap in 0 qubits, a few in 2, and none in 1 or 3.

数字例子与反例A numerical example and a counterexample

[[4,2,2]]：H_X = H_Z = (1 1 1 1)，H_XH_Zᵀ = 1·1 + 1·1 + 1·1 + 1·1 = 4，偶数，X₁X₂X₃X₄ 与 Z₁Z₂Z₃Z₄ 对易（(−1)⁴ = +1）。改成 H_X = (1 1 1 0)：点积 = 3，奇数，X₁X₂X₃ 与 Z₁Z₂Z₃Z₄ 反对易（(−1)³ = −1），码不合法——那个 3 就是共享比特 {1, 2, 3} 的个数。2.4.2 的 bicycle 码那张 3 × 3 的表 (4 2 2; 2 4 2; 2 2 4)，每一格也都是「这两条检查共享几个比特」，全是偶数。

[[4,2,2]]: H_X = H_Z = (1 1 1 1), so H_XH_Zᵀ = 1·1 + 1·1 + 1·1 + 1·1 = 4, even, and X₁X₂X₃X₄ commutes with Z₁Z₂Z₃Z₄ ((−1)⁴ = +1). Change to H_X = (1 1 1 0): the dot product is 3, odd, X₁X₂X₃ anticommutes with Z₁Z₂Z₃Z₄ ((−1)³ = −1) and the code is illegitimate — that 3 is the size of the shared set {1, 2, 3}. The 3 × 3 table (4 2 2; 2 4 2; 2 2 4) of the bicycle code in §2.4.2 likewise records “how many qubits do these two checks share” in every cell, all even.

反对易的正面用途：错误被发现The useful side of anticommutation: errors get caught

检查之间要对易，但错误与检查之间恰恰要反对易，这才是发现错误的机制。仍用 [[4,2,2]]，码态 |ψ⟩ = |0000⟩ + |1111⟩ 满足 S|ψ⟩ = |ψ⟩（S = Z₁Z₂Z₃Z₄，两个串都有偶数个 1）。比特 1 发生 X 错误后状态变为 X₁|ψ⟩ = |1000⟩ + |0111⟩，对它测 S：S·X₁|ψ⟩ = −X₁·S|ψ⟩ = −X₁|ψ⟩，新状态是 −1 本征态，测量必得 −1——警报。直接看也一样：1000 和 0111 各有奇数个 1，Z₁Z₂Z₃Z₄ 给每一项乘 (−1)^奇 = −1。能被发现的错误恰恰是与至少一条检查反对易的错误；与所有检查都对易、却不是检查乘积的算符，则是骗过全部检查的逻辑算符（4.4、补课 4.C）。三种角色，三种关系：检查之间对易；错误与某些检查反对易；逻辑算符与全部检查对易但不是检查乘积。

Checks must commute with each other, but errors and checks are supposed to anticommute — that is the detection mechanism. In [[4,2,2]] again, the code state |ψ⟩ = |0000⟩ + |1111⟩ satisfies S|ψ⟩ = |ψ⟩ (S = Z₁Z₂Z₃Z₄; both strings have an even number of 1s). After an X error on qubit 1 the state is X₁|ψ⟩ = |1000⟩ + |0111⟩, and measuring S on it: S·X₁|ψ⟩ = −X₁·S|ψ⟩ = −X₁|ψ⟩, a −1 eigenstate, so the outcome is certainly −1 — an alarm. Seen directly: 1000 and 0111 each have an odd number of 1s, and Z₁Z₂Z₃Z₄ multiplies each term by (−1)^odd = −1. The detectable errors are exactly those anticommuting with at least one check; an operator commuting with all checks yet not a product of checks is a logical operator that fools them all (§4.4, Catch-up 4.C). Three roles, three relations: checks commute with checks; errors anticommute with some checks; logical operators commute with all checks without being products of them.

什么叫独立、什么叫不独立Independent versus dependent checks

三个比特上的三条奇偶检查：A「第 1 位 + 第 2 位是偶数」(1, 1, 0)，B「第 2 位 + 第 3 位是偶数」(0, 1, 1)，C「第 1 位 + 第 3 位是偶数」(1, 0, 1)。八个串里通过 A 的是 000、001、110、111（砍了一半），再通过 B 的只剩 000、111（又砍一半）。加上 C：000 和 111 都通过，一个也没砍掉——因为 b₁ + b₂ 与 b₂ + b₃ 都是偶数时，两式相加得 b₁ + 2b₂ + b₃ 是偶数，即 b₁ + b₃ 必然是偶数。C 的结论已经包含在 A、B 里，这就叫 C 不独立于 A、B。更强的说法是：对任何串，C 的答案永远等于 A 的答案 XOR B 的答案，测 C 不会带来任何新信息。矩阵上 (1, 0, 1) = (1, 1, 0) + (0, 1, 1) (mod 2)，第三行是前两行之和，三行的秩只有 2。对比一条独立的第三条 C′「第 3 位是 0」(0, 0, 1)：它把 {000, 111} 砍成 {000}，无法由前两行相加得到，秩是 3。定义：一组检查里若某一条能写成其他几条的乘积（行向量是其他行 mod 2 之和），它就不独立；独立检查的条数 = 秩 = 真正砍了几次半。

Three parity checks on three bits: A “bit 1 + bit 2 is even” (1, 1, 0), B “bit 2 + bit 3 is even” (0, 1, 1), C “bit 1 + bit 3 is even” (1, 0, 1). Of the eight strings, A passes 000, 001, 110, 111 (halving the set) and B then leaves 000, 111 (halving again). Add C: 000 and 111 both pass, nothing is cut — because when b₁ + b₂ and b₂ + b₃ are both even, their sum b₁ + 2b₂ + b₃ is even, so b₁ + b₃ must be even. C’s verdict is already contained in A and B: C is dependent on them. Stronger still: for every string, C’s answer equals A’s answer XOR B’s answer, so measuring C never yields new information. In matrix terms (1, 0, 1) = (1, 1, 0) + (0, 1, 1) (mod 2), the third row is the sum of the first two, and the three rows have rank only 2. Compare an independent third check C′ “bit 3 is 0” (0, 0, 1): it cuts {000, 111} down to {000}, cannot be obtained by adding the first two rows, and the rank is 3. Definition: in a set of checks, one that can be written as a product of the others (its row is a mod-2 sum of other rows) is dependent; the number of independent checks = the rank = the number of genuine halvings.

量子版一模一样。三条 Z 检查 Z₁Z₂、Z₂Z₃、Z₁Z₃：因为 Z₂² = I，(Z₁Z₂)(Z₂Z₃) = Z₁Z₃，第三条是前两条的乘积，凡满足前两条的态自动满足第三条。8 维空间被 Z₁Z₂ 砍成 4 维（|000⟩、|001⟩、|110⟩、|111⟩ 张成），再被 Z₂Z₃ 砍成 2 维（|000⟩、|111⟩ 张成），Z₁Z₃ 对这两个态都给 (−1)⁰ = (−1)² = +1，什么都没砍。剩下 2 维 = 1 个逻辑比特：这就是三比特重复码，n = 3，rank H_Z = 2，rank H_X = 0，k = 3 − 2 − 0 = 1——若按行数算 3 − 3 = 0 就错了。多余的检查在码里天然会出现：把 4 个比特放在一个环的 4 条边上，4 个顶点各配一条检查 Z₁Z₂、Z₂Z₃、Z₃Z₄、Z₄Z₁，四条乘起来每个 Z 出现两次、乘积是 I，秩只有 3；环面码的 ∏A = I 是同一件事的二维版——每条边恰好属于两个顶点，所以 L² 条星形检查中必有一条多余。多余的检查并非「错」：它们仍是真命题，测出来的值可以用来核对测量本身有没有出错，只是在数码空间有多大时不能重复计数。

The quantum version is identical. Three Z checks Z₁Z₂, Z₂Z₃, Z₁Z₃: since Z₂² = I, (Z₁Z₂)(Z₂Z₃) = Z₁Z₃, the third is the product of the first two, and any state passing the first two passes the third for free. The 8-dimensional space is cut by Z₁Z₂ to 4 dimensions (spanned by |000⟩, |001⟩, |110⟩, |111⟩), then by Z₂Z₃ to 2 (|000⟩, |111⟩), and Z₁Z₃ gives both of these (−1)⁰ = (−1)² = +1, cutting nothing. The remaining 2 dimensions are one logical qubit: this is the three-qubit repetition code, n = 3, rank H_Z = 2, rank H_X = 0, k = 3 − 2 − 0 = 1 — counting rows instead, 3 − 3 = 0, would be wrong. Redundant checks arise naturally: put 4 qubits on the edges of a ring with a check Z₁Z₂, Z₂Z₃, Z₃Z₄, Z₄Z₁ at each of the 4 vertices; multiplying all four, every Z appears twice and the product is I, so the rank is only 3. The toric identity ∏A = I is the two-dimensional version — every edge belongs to exactly two vertices, so one of the L² star checks must be redundant. Redundant checks are not “wrong”: they are still true statements, and their outcomes can be used to cross-check the measurements themselves; they simply must not be double-counted when sizing the code space.

为什么 k = n − rank H_X − rank H_ZWhy k = n − rank H_X − rank H_Z

n 个比特的状态空间是 2ⁿ 维。一条检查 S 的本征值 ±1 把空间分成 +1、−1 两半，各 2ⁿ⁻¹ 维（Pauli 算符的迹是 0，两半一样大）；要求「通过检查」就是只保留 +1 那一半。r 条独立且两两对易的检查砍 r 次，剩 2ⁿ/2ʳ = 2ⁿ⁻ʳ 维，而 2ᵏ 维的空间恰好能存 k 个逻辑比特，所以 k = n − r。为什么 r = rank H_X + rank H_Z？两条 X 检查相乘，X(u)·X(v) = X(u + v)（同一比特上 X·X = I，对应 1 + 1 = 0），所以「若干检查的乘积」对应「若干行 mod 2 相加」，X 型独立检查的条数就是 rank H_X，Z 型同理；而 X 型算符的乘积还是 X 型，不可能等于一个 Z 型乘积（除非两边都是 I），两类之间不会产生新的依赖，秩可以直接相加。

The state space of n qubits has 2ⁿ dimensions. One check S with eigenvalues ±1 splits it into a +1 half and a −1 half of 2ⁿ⁻¹ dimensions each (a Pauli operator has trace 0, so the halves are equal); demanding “pass” keeps only the +1 half. r independent, mutually commuting checks cut r times, leaving 2ⁿ/2ʳ = 2ⁿ⁻ʳ dimensions, and a 2ᵏ-dimensional space stores exactly k logical qubits, so k = n − r. Why is r = rank H_X + rank H_Z? Two X checks multiply as X(u)·X(v) = X(u + v) (X·X = I on a shared qubit, matching 1 + 1 = 0), so “a product of several checks” corresponds to “a mod-2 sum of several rows”, and the number of independent X checks is rank H_X; likewise for Z. A product of X-type operators is again X-type and can never equal a product of Z-type operators (unless both are I), so the two kinds create no new dependencies and the ranks simply add.

更具体的数法（CSS 码专属）。在 |c⟩（c 是 n 位 0/1 串）这组基下，Z 检查是经典的奇偶校验：Z(v)|c⟩ = (−1)^v·c|c⟩，|c⟩ 通过全部 Z 检查 ⇔ H_Z·c = 0，这些 c 组成一个经典线性码 C₁，元素个数 2^{n − rank H_Z}。X 检查是平移：X(u)|c⟩ = |c + u⟩，要在全部 X 检查下不变，态必须对整个陪集 c + C₂ 均匀叠加，其中 C₂ = H_X 的行空间（所有行的 mod 2 组合），元素个数 2^{rank H_X}。于是码态是 |c + C₂⟩ = Σ_w∈C₂|c + w⟩（c ∈ C₁），彼此独立的码态数 = C₁ 被切成多少个陪集 = 2^{n − rank H_Z} / 2^{rank H_X}，指数就是 k。这个构造成立需要 C₂ ⊂ C₁（平移不能把通过 Z 检查的串搬到不通过的串上），而这恰恰就是 H_ZH_Xᵀ = 0——对易条件在这里再次出现。

A more concrete count, special to CSS codes. In the basis |c⟩ (c an n-bit 0/1 string) the Z checks are classical parity checks: Z(v)|c⟩ = (−1)^v·c|c⟩, so |c⟩ passes every Z check ⇔ H_Z·c = 0, and these c form a classical linear code C₁ with 2^{n − rank H_Z} elements. The X checks are translations: X(u)|c⟩ = |c + u⟩, and to be invariant under all of them a state must be a uniform superposition over a whole coset c + C₂, where C₂ = the row space of H_X (all mod-2 combinations of its rows), with 2^{rank H_X} elements. The code states are therefore |c + C₂⟩ = Σ_w∈C₂|c + w⟩ (c ∈ C₁), and the number of independent ones = the number of cosets C₁ splits into = 2^{n − rank H_Z} / 2^{rank H_X}, whose exponent is k. The construction needs C₂ ⊂ C₁ (a translation must not carry a string passing the Z checks onto one that fails), and that is exactly H_ZH_Xᵀ = 0 — the commutation condition again.

三个例子。[[4,2,2]]，H_X = H_Z = (1 1 1 1)：通过 Z₁Z₂Z₃Z₄ 的串是偶重量的 8 个（2⁴⁻¹），C₂ = {0000, 1111} 把它们两两配对成 4 个陪集，4 个码态 |0000⟩+|1111⟩、|0011⟩+|1100⟩、|0101⟩+|1010⟩、|0110⟩+|1001⟩，4 = 2²，k = 4 − 1 − 1 = 2。Shor 九比特码：通过 6 条 Z 检查的是每个三比特块都为 000 或 111 的 8 个串；C₂ = {000000000, 111111000, 000111111, 111000111}，4 个元素；8 个串切成 2 个陪集，k = 9 − 6 − 2 = 1，而且能直接看出码态：含偶数个 111 块的四个串叠加是 |0̄⟩ = (|000⟩+|111⟩)^⊗3，含奇数个的是 |1̄⟩。环面码 toric_L3：n = 18，H_X、H_Z 各 9 行但各只有 8 行独立（∏ = I），k = 18 − 8 − 8 = 2；错用行数会得到 18 − 18 = 0。

Three examples. [[4,2,2]], H_X = H_Z = (1 1 1 1): the strings passing Z₁Z₂Z₃Z₄ are the 8 even-weight ones (2⁴⁻¹); C₂ = {0000, 1111} pairs them into 4 cosets, giving the 4 code states |0000⟩+|1111⟩, |0011⟩+|1100⟩, |0101⟩+|1010⟩, |0110⟩+|1001⟩, 4 = 2², k = 4 − 1 − 1 = 2. Shor’s nine-qubit code: the strings passing the 6 Z checks are the 8 in which each three-qubit block is 000 or 111; C₂ = {000000000, 111111000, 000111111, 111000111} has 4 elements; the 8 strings split into 2 cosets, k = 9 − 6 − 2 = 1, and the code states can be read off: the superposition of the four strings with an even number of 111 blocks is |0̄⟩ = (|000⟩+|111⟩)^⊗3, the odd ones give |1̄⟩. The toric code toric_L3: n = 18, H_X and H_Z have 9 rows each but only 8 independent (∏ = I), so k = 18 − 8 − 8 = 2; using row counts would give 18 − 18 = 0.

怎么算秩：GF(2) 上的高斯消元Computing the rank: Gaussian elimination over GF(2)

允许的操作只有两种——交换两行、把一行加到另一行上（加法是 XOR）——它们都不改变「这些行能组合出哪些向量」，所以不改变秩。目标是消成阶梯形：每个非零行有一个「打头的 1」，而这一列里其他行全是 0，这样的非零行互相独立：每一行在自己打头的那一列上是 1，别的行在这一列都是 0，所以不管挑哪几行相加，这些打头的 1 都消不掉，得不到零向量；它们的个数就是秩；被消成零行的，记录了一条依赖关系。步骤：从左往右逐列处理，在还没用过的行里找一个这一列为 1 的行当主元行（找不到就跳到下一列），把主元行加到其他所有这一列为 1 的行上，秩加一。

Only two operations are allowed — swapping two rows, and adding one row to another (addition is XOR) — and neither changes “which vectors these rows can combine into”, hence neither changes the rank. The goal is echelon form: every nonzero row has a “leading 1” whose column is 0 in all other rows; such nonzero rows are independent: each has a 1 in its own leading column, where every other row has 0, so no sum of some of them can cancel those leading 1s and reach the zero vector; their number is the rank, while any row reduced to zero records a dependency. Procedure: go through the columns left to right, pick among the unused rows one with a 1 in this column as pivot (skip the column if none), add the pivot row to every other row with a 1 in this column, and count one more for the rank.

再看环上的四条检查 (1100), (0110), (0011), (1001)：第 1 列 r₁ 打头，r₄ ← r₄ + r₁ = 0101；第 2 列 r₂ 打头，r₄ ← r₄ + r₂ = 0011；第 3 列 r₃ 打头，r₄ ← r₄ + r₃ = 0000。秩 = 3，清零对应 r₁ + r₂ + r₃ + r₄ = 0，即「所有检查乘起来是 I」。2.4.2 的 bicycle 码 H：第 1 列 r₁ 打头，r₃ ← r₃ + r₁ 后与 r₂ 相同，第 2 列再消掉，秩 = 2，于是 k = 6 − 2 − 2 = 2。反过来，Shor 码的 H_Z 六行打头的 1 分别在第 1、2、4、5、7、8 列，已是阶梯形，直接读出秩 6。行秩等于列秩，所以 rank Mᵀ = rank M——4.1 证两个秩相等时用到它。计算机做的是同一套动作，本页「现场重算 n、k」跑的正是这个循环，写成代码十来行：

Next the four ring checks (1100), (0110), (0011), (1001): column 1, pivot r₁, r₄ ← r₄ + r₁ = 0101; column 2, pivot r₂, r₄ ← r₄ + r₂ = 0011; column 3, pivot r₃, r₄ ← r₄ + r₃ = 0000. Rank = 3, and the cleared row is r₁ + r₂ + r₃ + r₄ = 0, “all checks multiply to I”. For the bicycle H of §2.4.2: column 1, pivot r₁, and r₃ ← r₃ + r₁ becomes identical to r₂, which column 2 then clears; rank = 2, hence k = 6 − 2 − 2 = 2. Conversely Shor’s H_Z has its six leading 1s in columns 1, 2, 4, 5, 7, 8, already echelon, rank 6 by inspection. Row rank equals column rank, so rank Mᵀ = rank M — used in §4.1 to show the two ranks agree. A computer performs the same moves; this page’s live recomputation of n and k runs exactly this loop, a dozen lines of code:

def rank_gf2(rows):                       # rows: 0/1 列表的列表 / lists of 0/1
    rows, rank = [r[:] for r in rows], 0
    for c in range(len(rows[0])):
        piv = next((i for i in range(rank, len(rows)) if rows[i][c]), None)
        if piv is None: continue
        rows[rank], rows[piv] = rows[piv], rows[rank]
        for i in range(len(rows)):
            if i != rank and rows[i][c]:
                rows[i] = [a ^ b for a, b in zip(rows[i], rows[rank])]
        rank += 1
    return rank

gross 码的 H_X 是 72 × 144 的矩阵，手算不现实，但交给这个函数就是 66，秩亏损 72 − 66 = 6，k = 12。

The gross code’s H_X is 72 × 144, hopeless by hand, but this function returns 66: a rank deficit of 72 − 66 = 6, so k = 12.

矩阵乘法的规则只有一句话：结果的第 i 行第 j 列 = 左矩阵的第 i 行与右矩阵的第 j 列逐项相乘再相加（点积）。左矩阵 a × b、右矩阵 b × c，结果 a × c。把 S 的行和列分别写出来（c₀ 是第一列从上往下读）：

Matrix multiplication is one sentence: entry (i, j) of the product = row i of the left factor dotted with column j of the right factor (multiply termwise, add up). An a × b matrix times a b × c matrix gives a × c. Write out the rows and columns of S (c₀ is the first column read top to bottom):

省力读法。看第 0 行的三个点积：r₀ = (0 1 0) 只有中间是 1，所以 r₀·c_j 等于每个 c_j 的第 1 个分量，即右矩阵第 1 行的各元素——「结果的第 0 行 = 右矩阵的第 1 行」。一般地，若左矩阵第 i 行只有第 k 列是 1，结果的第 i 行就是右矩阵的第 k 行，整行照抄。置换矩阵每行恰好一个 1，乘法退化成「抄行」。于是 S³ = S²·S 的各行是 S 的第 2、0、1 行，正好是 I。对一般的 l 同理：Sᵏ 的第 i 行的 1 在第 i+k (mod l) 列，取 k = l 便回到第 i 列，S^l = I——绕一整圈回原地。用向量看：S(v₀, v₁, v₂)ᵀ = (v₁, v₂, v₀)ᵀ，三个分量循环转一位，转三次复原。把 S 的行列互换得 Sᵀ，它恰好是 S²，所以 Sᵀ·S = S³ = I，Sᵀ = S⁻¹：转置就是反向挪一格。

The shortcut. Look at the three dot products of row 0: r₀ = (0 1 0) has its only 1 in the middle, so r₀·c_j equals the second component of each c_j, i.e. the entries of row 1 of the right factor — “row 0 of the product = row 1 of the right factor”. In general, if row i of the left factor has its only 1 in column k, row i of the product is row k of the right factor, copied whole. A permutation matrix has exactly one 1 per row, so multiplication degenerates into copying rows. Hence the rows of S³ = S²·S are rows 2, 0, 1 of S — exactly I. For general l likewise: row i of Sᵏ has its 1 in column i+k (mod l), and k = l brings it back to column i, S^l = I — one full turn round the ring. As vectors: S(v₀, v₁, v₂)ᵀ = (v₁, v₂, v₀)ᵀ, a cyclic rotation of the three components, and three rotations restore them. Swapping rows and columns of S gives Sᵀ, which is precisely S², so Sᵀ·S = S³ = I and Sᵀ = S⁻¹: the transpose is one step backwards.

关于 mod 2。上面每个和最多只有一项非零，取不取奇偶无所谓。但一般的 0/1 矩阵相乘会出现 2、3、4，这时在 GF(2) 上要再取奇偶：例如 (C·Cᵀ) 的第 0 行第 0 列 = (1 1 0)·(1 1 0)ᵀ = 2 ≡ 0（2.4.3）；2.4.2 里 H·Hᵀ 算出的 (4 2 2; 2 4 2; 2 2 4) 每个元素都是这样的点积，取奇偶后全为 0，那就是「对易」的矩阵表达。

On mod 2. Each sum above has at most one nonzero term, so reducing mod 2 changes nothing. But products of general 0/1 matrices produce 2s, 3s and 4s, and over GF(2) these are then reduced to their parity: e.g. entry (0, 0) of C·Cᵀ is (1 1 0)·(1 1 0)ᵀ = 2 ≡ 0 (§2.4.3), and every entry of the H·Hᵀ = (4 2 2; 2 4 2; 2 2 4) of §2.4.2 is such a dot product, all 0 after reduction — the matrix form of “commute”.

用最小的例子：l = m = 2，环面只有 4 个格子。按 2.2 的约定，把第一个坐标 i 画成横轴、第二个坐标 j 画成纵轴（向上增大），格子 (i, j) 的编号是 i·m + j = 2i + j：

Take the smallest example, l = m = 2, a torus of only 4 sites. Following §2.2, draw the first coordinate i horizontally and the second coordinate j vertically (increasing upward); site (i, j) gets number i·m + j = 2i + j:

在这种画法里 x 是往右挪一格、y 是往上挪一格。要是你把 i 当作行号、j 当作列号画成一张矩阵式的表，x 就变成「往下走一行」——这只是画法问题：x 的定义只有「第一个坐标加一」这一句，矩阵的每个元素由它决定，与格子画在纸上的哪个方向无关。

In this picture x steps right and y steps up. If instead you tabulate i as a row index and j as a column index, matrix style, x becomes “one row down” — a matter of drawing only: x is defined by the single phrase “add one to the first coordinate”, every matrix entry follows from it, and the direction in which the sites are drawn on paper is irrelevant.

矩阵的读法和循环移位 S 一样：行 = 出发的格子，那一行的 1 落在到达的格子那一列。x：(i, j) → (i+1 mod 2, j)，逐格看它去哪——格子 0 = (0,0) → (1,0) = 格子 2，第 0 行的 1 在第 2 列；格子 1 = (0,1) → (1,1) = 3；格子 2 = (1,0) → (0,0) = 0（1 + 1 ≡ 0，绕回去）；格子 3 = (1,1) → (0,1) = 1。y：(i, j) → (i, j+1 mod 2)，格子 0 → 1，1 → 0，2 → 3，3 → 2。于是

The matrices are read like the cyclic shift S: row = the site you start from, and that row’s 1 sits in the column of the site you land on. x: (i, j) → (i+1 mod 2, j); site by site — site 0 = (0,0) → (1,0) = site 2, so row 0 has its 1 in column 2; site 1 = (0,1) → (1,1) = 3; site 2 = (1,0) → (0,0) = 0 (1 + 1 ≡ 0, wrapping round); site 3 = (1,1) → (0,1) = 1. y: (i, j) → (i, j+1 mod 2), sites 0 → 1, 1 → 0, 2 → 3, 3 → 2. Hence

在编号表上看，x 是把两列整体互换（i = 0 的一列去 i = 1），y 是把两行整体互换。用克罗内克积再算一遍，结果一样。l = 2 的循环移位是 S₂ = [0 1; 1 0]。教程写 x = S₂ ⊗ I₂、y = I₂ ⊗ S₂，⊗ 的规则是「把左边矩阵的每个元素 a 换成整块 a·(右边矩阵)」：

On the numbering table x swaps the two columns bodily (the i = 0 column goes to i = 1) and y swaps the two rows. Recomputing with the Kronecker product gives the same matrices. The cyclic shift for l = 2 is S₂ = [0 1; 1 0]. The tutorial writes x = S₂ ⊗ I₂ and y = I₂ ⊗ S₂, where ⊗ means “replace every entry a of the left matrix by the whole block a·(right matrix)”:

S₂ 在外层管第一个坐标（整块搬动），I₂ 在内层保持第二个坐标不变；y 反过来——这就是 2.2 说「不必记公式、只记意思」的原因。然后 A、B 就是矩阵相加（mod 2）：

S₂ on the outside moves the first coordinate (whole blocks at a time) while I₂ inside leaves the second alone; y the other way round — which is why §2.2 says to remember the meaning rather than the formula. A and B are then matrix sums (mod 2):

读 A 的第 0 行 (1 0 1 0)：站在格子 (0,0) 的检查，「1」这一项碰自己 (0,0)，「x」这一项碰 (1,0) = 格子 2，所以第 0 列和第 2 列是 1。这里没有一格出现 1 + 1，mod 2 没用上；若某个多项式有两项把同一格搬到同一处（如 l = 2 上的 x + x³），它们会相消为 0。还有一处 l = 2 的特殊性：圈上只有两个格子，「往右一格」和「往左一格」是同一件事，x² = I，x⁻¹ = x，所以 A 是对称矩阵、Aᵀ = A，B 也一样，H_Z = [Bᵀ | Aᵀ] = [B | A]。l = 3 起就不再如此——2.4.1 里 C = 1 + x 与 Cᵀ = 1 + x² 不同，就是这个区别。

Read row 0 of A, (1 0 1 0): the check standing at site (0,0) touches itself, (0,0), through the term “1” and site (1,0) = site 2 through the term “x”, so columns 0 and 2 are 1. No cell here receives 1 + 1, so mod 2 never bites; a polynomial with two terms carrying the same site to the same place (x + x³ on l = 2, say) would cancel them to 0. One more peculiarity of l = 2: with only two sites on the ring, “one step right” and “one step left” coincide, x² = I and x⁻¹ = x, so A is symmetric, Aᵀ = A, likewise B, and H_Z = [Bᵀ | Aᵀ] = [B | A]. From l = 3 on this fails — in §2.4.1 C = 1 + x and Cᵀ = 1 + x² differ, and that is the difference.

xy = yx 的三种证法Three proofs of xy = yx

一、看每个格子去哪里。置换矩阵相乘就是「先做一个动作，再做另一个」：x·y 的第 s 行的 1 落在「s 先被 x 送到哪、再被 y 送到哪」那一列。x·y：(i, j) →x→ (i+1, j) →y→ (i+1, j+1)；y·x：(i, j) →y→ (i, j+1) →x→ (i+1, j+1)。每个起点的终点都相同，两个矩阵每一行的 1 都落在同一列，所以 x·y = y·x。原因只有一个：x 只改第一个坐标、y 只改第二个，两件事互不干扰，说到底还是加法可交换。这不是理所当然的——三个格子上，p =「交换 0 和 1」，q =「交换 1 和 2」，先 p 再 q 把 0 送到 2，先 q 再 p 把 0 送到 1，pq ≠ qp。x、y 能对易，靠的正是「各管一个坐标」。

One: follow every site. Multiplying permutation matrices is “do one move, then the other”: row s of x·y has its 1 in the column of “where s goes under x, then under y”. x·y: (i, j) →x→ (i+1, j) →y→ (i+1, j+1); y·x: (i, j) →y→ (i, j+1) →x→ (i+1, j+1). Every start reaches the same end, so every row of the two matrices has its 1 in the same column: x·y = y·x. The only reason is that x touches the first coordinate alone and y the second alone, so the two never interfere — at bottom, addition commutes. This is not automatic: on three sites, with p = “swap 0 and 1” and q = “swap 1 and 2”, p then q sends 0 to 2 while q then p sends 0 to 1, so pq ≠ qp. x and y commute precisely because each minds its own coordinate.

二、克罗内克积的混合乘积律 (A ⊗ B)(C ⊗ D) = (AC) ⊗ (BD)——左因子乘左因子、右因子乘右因子。于是 x·y = (S_l·I_l) ⊗ (I_m·S_m) = S_l ⊗ S_m，y·x = (I_l·S_l) ⊗ (S_m·I_m) = S_l ⊗ S_m，两边都是「两个坐标同时各加一」。混合乘积律本身就是分块乘法：A ⊗ B 的第 (i, k) 块是 a_ik·B，两个分块矩阵相乘时第 (i, k) 块 = Σ_j(a_ijB)(c_jkD) = (Σ_j a_ijc_jk)·BD = (AC)_ik·BD。这条证法不依赖画法，还顺带给出 x^ay^b = S_l^a ⊗ S_m^b。

Two: the mixed-product rule of the Kronecker product, (A ⊗ B)(C ⊗ D) = (AC) ⊗ (BD) — left factors multiply left factors, right factors right. So x·y = (S_l·I_l) ⊗ (I_m·S_m) = S_l ⊗ S_m and y·x = (I_l·S_l) ⊗ (S_m·I_m) = S_l ⊗ S_m, both “add one to both coordinates at once”. The rule itself is block multiplication: block (i, k) of A ⊗ B is a_ik·B, and multiplying two such block matrices gives block (i, k) = Σ_j(a_ijB)(c_jkD) = (Σ_j a_ijc_jk)·BD = (AC)_ik·BD. This proof is independent of any picture and yields x^ay^b = S_l^a ⊗ S_m^b for free.

三、把 2 × 2 的例子算出来。用「x 的第 s 行只有第 t 列是 1，则 x·M 的第 s 行 = M 的第 t 行」：x 第 0 行的 1 在第 2 列 → x·y 第 0 行抄 y 的第 2 行 (0 0 0 1)；第 1 行 → 抄 y 第 3 行 (0 0 1 0)；第 2 行 → 抄 y 第 0 行 (0 1 0 0)；第 3 行 → 抄 y 第 1 行 (1 0 0 0)。反过来 y·x：y 第 0 行的 1 在第 1 列 → 抄 x 第 1 行 (0 0 0 1)；第 1 行 → 抄 x 第 0 行 (0 0 1 0)；第 2 行 → 抄 x 第 3 行 (0 1 0 0)；第 3 行 → 抄 x 第 2 行 (1 0 0 0)。

Three: compute the 2 × 2 example. Using “if row s of x has its only 1 in column t, then row s of x·M is row t of M”: row 0 of x has its 1 in column 2 → row 0 of x·y copies row 2 of y, (0 0 0 1); row 1 → row 3 of y, (0 0 1 0); row 2 → row 0 of y, (0 1 0 0); row 3 → row 1 of y, (1 0 0 0). Conversely y·x: row 0 of y has its 1 in column 1 → row 1 of x, (0 0 0 1); row 1 → row 0 of x, (0 0 1 0); row 2 → row 3 of x, (0 1 0 0); row 3 → row 2 of x, (1 0 0 0).

它为什么足够推出 AB = BA。有了 xy = yx，再加上同一个矩阵的幂彼此可交换，任意两个单项式就可交换：x^ay^b·x^cy^d = x^a+cy^b+d = x^cy^d·x^ay^b（把 y 和 x 一步步换位，每次用一遍 xy = yx）。A、B 是单项式的和，用分配律展开后逐项换位，就是 2.4.3 里「三层论证」的第二层，只是变量从一个换成两个。这就是 3.2 那一行证明里 AB = BA 的全部依据。

Why this suffices for AB = BA. Given xy = yx, and that powers of one matrix commute among themselves, any two monomials commute: x^ay^b·x^cy^d = x^a+cy^b+d = x^cy^d·x^ay^b (swap y past x one step at a time, using xy = yx each time). A and B are sums of monomials; expand by the distributive law and swap term by term — the second layer of the “three-layer argument” of §2.4.3, with two variables instead of one. That is the entire basis of AB = BA in the one-line proof of §3.2.

稀疏矩阵就是「绝大多数元素是 0、只有零星几个非零元」的矩阵；非零元占相当比例的叫稠密矩阵。这个词本身没有精确门槛，但在编码里有一个很具体的用法。先看尺寸感：gross 码的 H_X 是 72 行 × 144 列，共 10368 个格子，每行只有 6 个 1，总共 432 个 1，约 4%——一张几乎全白、点着零星几个 1 的大表。这些 1 从哪来，2.3 已经说了：一个单项式是置换矩阵，每行每列恰好一个 1；A = x³ + y + y² 三项相加，每行每列恰好三个 1；[A | B] 并排，每行恰好 |A| + |B| = 6 个 1。「多项式项数少」直接等于「矩阵稀疏」。

A sparse matrix is one in which “almost every entry is 0 and only a scattering are nonzero”; one with a sizeable share of nonzero entries is dense. The word has no precise threshold, but in coding it has a very specific use. First a sense of scale: the gross code’s H_X has 72 rows × 144 columns, 10 368 cells, only 6 ones per row, 432 ones in all, about 4% — a large, almost blank table dotted with a few 1s. Where they come from was said in §2.3: a monomial is a permutation matrix with exactly one 1 per row and column; A = x³ + y + y² adds three of them, exactly three 1s per row and column; [A | B] side by side has exactly |A| + |B| = 6 ones per row. “Few terms in the polynomial” is the same as “sparse matrix”.

编码里真正在意的不是某个百分比，而是每行、每列的 1 有没有一个不随 n 增长的上界。这就是 LDPC（low-density parity check，低密度奇偶检查）的定义：行重（检查重量，一条检查碰几个比特）和列重（比特度，一个比特被几条检查碰到）都被一个固定的小数字限住。表面码不管做多大，每行至多 4 个 1（边界上的检查只有 2 或 3 条腿），每列也至多 4 个；BB 码是 6 和 3 + 3；把环面放大到 288 或 756 个比特，仍然是 6，1 的比例越来越低。相反，[[4,2,2]] 的检查 (1 1 1 1) 一行全是 1，Shor 码的 X 检查九个比特碰六个——这些小码无所谓，但如果一族码随 n 增长检查重量也跟着涨（比如永远碰一半比特），它就是稠密的、不是 LDPC。

What coding really cares about is not a percentage but whether the number of 1s per row and per column is bounded by a constant that does not grow with n. That is the definition of LDPC (low-density parity check): the row weight (check weight, how many qubits a check touches) and the column weight (qubit degree, how many checks touch a qubit) are both capped by a fixed small number. The surface code has at most 4 ones per row (boundary checks have only 2 or 3 legs) and at most 4 per column at any size; BB codes have 6 and 3 + 3; enlarge the torus to 288 or 756 qubits and it is still 6, the fraction of 1s falling ever lower. By contrast the [[4,2,2]] check (1 1 1 1) is all ones and Shor’s X checks touch six of nine qubits — harmless in tiny codes, but a family whose check weight grew with n (always touching half the qubits, say) would be dense, not LDPC.

为什么非要稀疏，有三层原因，都在第 6 章出现。第一，物理上一条检查要用一个辅助比特加「重量个」CNOT 来测：重量 6 就是 6 个 CNOT，芯片上每个比特只需连 6 根线，两层平面图能布下；重量 n/2 的检查代价极高：若仍用一个辅助比特依次做 n/2 个 CNOT，辅助比特上一个错误就会沿 CNOT 传到大量数据比特上（hook 错误的放大版）；要容错地测它，就得换用猫态、旗标比特之类的专门电路，开销随重量一起增长。第二，列稀疏意味着一个比特出错只点亮少数几个警报（gross 里一个 X 错误点亮 3 条 Z 检查，一个 Y 错误点亮 3 + 3 = 6 条），症状才有局部性可供译码器利用。第三，BP 译码在 Tanner 图上传消息，图的每个点度数有界（就是行重和列重有界），每一轮的计算量与 n 成正比，而且短圈少时 BP 才准。最后一点是存储和描述：稀疏矩阵不用把整张表存下来，只需列出 1 的位置；BB 码把这一点做到极致——两个三项多项式加上 l、m，四个数据就完全确定了一个 72 × 144 乃至 378 × 756 的检查矩阵。「多项式是稀疏矩阵」，就是这个意思。

Why sparsity is non-negotiable has three layers, all of which surface in Chapter 6. First, physically a check is measured with one ancilla and “weight-many” CNOTs: weight 6 means 6 CNOTs, every qubit on the chip needs only 6 wires, and two planar layers suffice; a check of weight n/2 is very expensive: measured the same way, with one ancilla and n/2 CNOTs in turn, a single fault on the ancilla would spread along the CNOTs to many data qubits (a hook error writ large), and measuring it fault-tolerantly needs special circuits such as cat states or flag qubits, whose cost grows with the weight. Second, sparse columns mean a faulty qubit lights only a few alarms (in gross an X error lights 3 Z checks and a Y error 3 + 3 = 6), giving the syndrome the locality a decoder can exploit. Third, BP decoding passes messages on the Tanner graph; bounded degree (i.e. bounded row and column weight) keeps each round’s work proportional to n, and BP is only accurate when short cycles are scarce. Finally, storage and description: a sparse matrix need not be stored as a full table, only as the positions of its 1s — and BB codes take this to the extreme: two three-term polynomials plus l and m, four pieces of data, completely determine a 72 × 144 or even 378 × 756 check matrix. That is what “a polynomial is a sparse matrix” means.

A 和 B 是两个同样大小的方阵，都是 lm × lm（第 2 章的翻译：多项式有 w 项，矩阵每行每列恰好 w 个 1）。把它们左右并排，H_X = [A | B] 就是 lm 行、2lm 列。关键是行和列各自代表什么。行 = 检查。环面有 lm 个格子，每个格子 (i, j) 配一条 X 检查，所以 H_X 有 lm 行，A 的第 (i, j) 行和 B 的第 (i, j) 行说的是同一条检查——A 那一半记它在左层伸出的腿，B 那一半记它在右层伸出的腿。列 = 比特。每个格子上放两个数据比特，共 n = 2lm 个；H_X 的前 lm 列对应第一份比特（每格一个，按格子编号），后 lm 列对应第二份。所谓「左层」「右层」，只是给这两份比特起的名字：落在 [A | B] 左半块的那一份叫左层 L，右半块的叫右层 R。可以想成两张一模一样的环面上下叠着、每张上每格一个比特——或者就是 2.4.2 bicycle 码里的两只轮子，那里的「环面」退化成一圈 l 个格子。

A and B are two square matrices of the same size, both lm × lm (the translation of Chapter 2: a polynomial with w terms is a matrix with exactly w ones per row and column). Placed side by side, H_X = [A | B] has lm rows and 2lm columns. The point is what rows and columns stand for. Rows = checks. The torus has lm sites and each site (i, j) carries one X check, so H_X has lm rows, and row (i, j) of A and row (i, j) of B describe the same check — the A half records its legs on the left layer, the B half its legs on the right layer. Columns = qubits. Every site holds two data qubits, n = 2lm in all; the first lm columns of H_X are the first copy (one per site, in site order), the last lm the second copy. “Left layer” and “right layer” are merely the names of these two copies: the copy addressed by the left block of [A | B] is the left layer L, the other the right layer R. Picture two identical tori stacked, one qubit per site on each — or simply the two wheels of the bicycle code in §2.4.2, where the “torus” degenerates to a ring of l sites.

于是 3.1 那句话的意思是：A 的第 (i, j) 行在第 (i+a, j+b) 列有 1（每项 x^ay^b 一个），这些列属于左半块，所以是左层比特 L(i+a, j+b)；B 的第 (i, j) 行的 1 落在右半块，是右层比特 R(i+a′, j+b′)。一条检查共 |A| + |B| 条腿。用 l = m = 2、A = 1 + x、B = 1 + y（补课 2.B 算出的 4 × 4 矩阵）把布局摆出来，H_X 是 4 行 8 列：

So the sentence in §3.1 means: row (i, j) of A has a 1 in column (i+a, j+b) for each term x^ay^b, and those columns belong to the left block, hence left-layer qubits L(i+a, j+b); the 1s in row (i, j) of B fall in the right block, right-layer qubits R(i+a′, j+b′). One check has |A| + |B| legs in all. Laying it out with l = m = 2, A = 1 + x, B = 1 + y (the 4 × 4 matrices of Catch-up 2.B), H_X is 4 rows by 8 columns:

对照原话：格子 (0,0) 的 X 检查作用于 A 的两项指向的左层比特 L(0,0)、L(1,0)，以及 B 的两项指向的右层比特 R(0,0)、R(0,1)。四条腿，正是环面码教程里的星形检查——那里把左层比特画在横边上、右层比特画在竖边上，「层」就有了几何形象；一般的 BB 码没有边的图像，「层」只剩「哪一半列」这个含义。Z 检查同理：H_Z = [Bᵀ | Aᵀ] 也是 lm 行 2lm 列，格子 (i, j) 的 Z 检查在左层碰 Bᵀ 指向的比特（B 的每项反向平移，(i−a′, j−b′)），在右层碰 Aᵀ 指向的比特。最后核对尺寸，也顺带看清 3.2 那行证明的形状：H_X 是 lm × 2lm，H_Zᵀ 是 2lm × lm（上半块 B、下半块 A，各 lm × lm），乘积 H_XH_Zᵀ = AB + BA 是 lm × lm 的方阵，第 (i, j) 元就是「格子 i 的 X 检查与格子 j 的 Z 检查共同踩到的比特数」。gross 码 lm = 72，A、B 都是 72 × 72，H_X 是 72 × 144。

Against the original sentence: the X check at site (0,0) acts on the left-layer qubits L(0,0), L(1,0) pointed to by the two terms of A and on the right-layer qubits R(0,0), R(0,1) pointed to by the two terms of B. Four legs — exactly the star check of the toric tutorial, which draws left-layer qubits on horizontal edges and right-layer qubits on vertical ones, giving “layer” a geometric face; a general BB code has no edge picture, and “layer” keeps only the meaning “which half of the columns”. Z checks likewise: H_Z = [Bᵀ | Aᵀ] also has lm rows and 2lm columns, and the Z check at (i, j) touches on the left layer the qubits pointed to by Bᵀ (each term of B translated backwards, (i−a′, j−b′)) and on the right layer those pointed to by Aᵀ. Finally the sizes, which also show the shape of the one-line proof in §3.2: H_X is lm × 2lm, H_Zᵀ is 2lm × lm (B on top, A below, each lm × lm), and the product H_XH_Zᵀ = AB + BA is an lm × lm square whose (i, j) entry is “the number of qubits shared by the X check at site i and the Z check at site j”. For gross, lm = 72, A and B are 72 × 72, and H_X is 72 × 144.

检查重量（check weight）就是一条检查碰到多少个比特——那条检查的算符里有多少个 X（或 Z），等价地，检查矩阵那一行里 1 的个数。「重量」（weight）在这套语言里永远是同一个意思：一个 Pauli 算符在多少个比特上不是恒等 I。用在检查上叫检查重量，用在错误上叫错误重量（翻了几个比特），用在逻辑算符上就是码距 d 的定义（最轻的逻辑算符的重量）。它只数位置，不管类型。

The check weight is how many qubits one check touches — how many X (or Z) factors its operator contains, equivalently how many 1s its row of the check matrix has. “Weight” always means the same thing in this language: the number of qubits on which a Pauli operator is not the identity I. Applied to a check it is the check weight, applied to an error the error weight (how many qubits flipped), applied to a logical operator it defines the distance d (the weight of the lightest logical operator). It counts positions only, not types.

对 BB 码，格子 (i, j) 的 X 检查在左层伸出 |A| 条腿（A 每一项一条），在右层伸出 |B| 条腿，所以重量 = |A| + |B|。这里 |A| 表示多项式 A 的项数——不是绝对值、不是行列式，词汇表里专门列了这个记号。环面码 A = 1 + x、B = 1 + y：2 + 2 = 4，星形检查的四条腿，补课 3.A 那张表每行恰好四个 1。bicycle 码 H = [C | Cᵀ]、C = 1 + x：2 + 2 = 4。gross 码 A = x³ + y + y²、B = y³ + x + x²：3 + 3 = 6，「六腿检查」，X 检查在 (i, j) 上的六条腿是 L(i+3, j)、L(i, j+1)、L(i, j+2)、R(i, j+3)、R(i+1, j)、R(i+2, j)；Z 检查用 H_Z = [Bᵀ | Aᵀ]，项数不变，重量同样是 6。BB 码里所有检查重量都一样；一般的码不必如此，Shor 码的 X 检查重量 6、Z 检查重量 2。

For a BB code the X check at site (i, j) puts |A| legs on the left layer (one per term of A) and |B| legs on the right, so the weight is |A| + |B|. Here |A| is the number of terms of the polynomial A — not an absolute value or a determinant; the glossary lists the symbol. Toric code, A = 1 + x, B = 1 + y: 2 + 2 = 4, the four legs of a star, and every row of the table in Catch-up 3.A has exactly four 1s. Bicycle code, H = [C | Cᵀ] with C = 1 + x: 2 + 2 = 4. Gross code, A = x³ + y + y², B = y³ + x + x²: 3 + 3 = 6, the “six-leg check”, whose legs at (i, j) are L(i+3, j), L(i, j+1), L(i, j+2), R(i, j+3), R(i+1, j), R(i+2, j); the Z checks use H_Z = [Bᵀ | Aᵀ], the term counts are unchanged, weight 6 as well. In BB codes every check has the same weight; in general codes it need not — Shor’s X checks have weight 6 and its Z checks weight 2.

为什么要单独给它起名字：重量直接等于测这条检查要用几个 CNOT——一个辅助比特依次和每条腿上的数据比特做一次门，重量 6 就是 6 个 CNOT，多一条腿就多一个门、多一个出错的机会，也多一条 hook 错误传播的路径；它同时决定了芯片上每个辅助比特要连几根线。LDPC 里的「低密度」就是「检查重量有上界、不随 n 增长」（补课 2.C）。要和它区分的是比特度（qubit degree）：一个比特被几条检查碰到，对应检查矩阵的列里 1 的个数。BB 码里一个左层比特被 |A| 条 X 检查和 |B| 条 Z 检查碰到，右层比特反之；gross 码是 3 + 3。行重是检查的账，列重是比特的账，6.1 的 Tanner 图里两者分别是检查节点和比特节点的度数。

Why it deserves a name of its own: the weight is exactly the number of CNOTs needed to measure the check — one ancilla interacts in turn with the data qubit on each leg, so weight 6 means 6 CNOTs; every extra leg is an extra gate, an extra chance of failure and an extra path for hook errors to spread, and it also fixes how many wires each ancilla needs on the chip. The “low density” of LDPC means “the check weight is bounded and does not grow with n” (Catch-up 2.C). Distinguish it from the qubit degree: how many checks touch a qubit, the number of 1s in a column of the check matrix. In a BB code a left-layer qubit meets |A| X checks and |B| Z checks and a right-layer qubit the reverse; for gross, 3 + 3. Row weight is the checks’ ledger, column weight the qubits’; in the Tanner graph of §6.1 they are the degrees of the check nodes and the qubit nodes respectively.

记号：[P | Q] 是把两个矩阵左右并排，[P ; Q] 是上下堆叠。分三步。

Notation: [P | Q] places two matrices side by side, [P ; Q] stacks them. Three steps.

第一步：H_Zᵀ = [B ; A]。H_Z = [Bᵀ | Aᵀ] 是 lm 行、2lm 列。转置就是行列互换。并排矩阵 [P | Q] 的列是「P 的各列，接着 Q 的各列」，转置后这些列变成行，就成了「Pᵀ 的各行，接着 Qᵀ 的各行」，也就是上下堆叠：[P | Q]ᵀ = [Pᵀ ; Qᵀ]。再用「转置两次回到自己」(Mᵀ)ᵀ = M：H_Zᵀ = [Bᵀ | Aᵀ]ᵀ = [(Bᵀ)ᵀ ; (Aᵀ)ᵀ] = [B ; A]，一个 2lm 行、lm 列的矩阵，上半块 B、下半块 A。尺寸对得上：H_X 是 lm × 2lm，H_Zᵀ 是 2lm × lm，乘积 lm × lm。

Step one: H_Zᵀ = [B ; A]. H_Z = [Bᵀ | Aᵀ] has lm rows and 2lm columns. Transposing swaps rows and columns. The columns of [P | Q] are “the columns of P, then the columns of Q”; after transposition these become rows, “the rows of Pᵀ, then the rows of Qᵀ”, which is a stack: [P | Q]ᵀ = [Pᵀ ; Qᵀ]. With “transposing twice gives the original”, (Mᵀ)ᵀ = M: H_Zᵀ = [Bᵀ | Aᵀ]ᵀ = [(Bᵀ)ᵀ ; (Aᵀ)ᵀ] = [B ; A], a matrix of 2lm rows and lm columns, B on top and A below. The sizes fit: H_X is lm × 2lm, H_Zᵀ is 2lm × lm, the product lm × lm.

第二步：[A | B]·[B ; A] = AB + BA。回到乘法的定义：乘积的第 (i, j) 元 = H_X 的第 i 行 · H_Zᵀ 的第 j 列 = 对全部 2lm 个位置 q 求和 H_X[i][q]·H_Zᵀ[q][j]。这个 2lm 项的和从中间切成两半：前 lm 个 q 是左层的列，那里 H_X 的元素是 A 的元素、H_Zᵀ 的元素是 B 的元素；后 lm 个 q 是右层，那里是 B 和 A。于是

Step two: [A | B]·[B ; A] = AB + BA. Back to the definition: entry (i, j) of the product = row i of H_X · column j of H_Zᵀ = the sum over all 2lm positions q of H_X[i][q]·H_Zᵀ[q][j]. Cut this 2lm-term sum in the middle: the first lm values of q are the left-layer columns, where the entries of H_X come from A and those of H_Zᵀ from B; the last lm are the right layer, with B and A. Hence

第一个和正是矩阵乘积 AB 的第 (i, j) 元的定义（A 的第 i 行点 B 的第 j 列），第二个和是 BA 的。每个 (i, j) 都如此，所以整个矩阵 H_XH_Zᵀ = AB + BA。用数字打个比方：(1 2 | 3 4) 点 (5 ; 6 ; 7 ; 8) = (1·5 + 2·6) + (3·7 + 4·8)，「前半段点前半段」加「后半段点后半段」。分块乘法的口诀：只要块的尺寸对得上，把每个块当成一个数来乘就行——(A, B) 这一「行」点 (B, A) 这一「列」得 A·B + B·A，只是块之间的乘法要保持左右顺序。这一步有个很好的物理读法：(AB)[i][j] 是 A 的第 i 行与 B 的第 j 列的点积，而 B 的第 j 列就是 Bᵀ 的第 j 行，即 Z 检查 j 在左层的腿，所以 (AB)[i][j] = X 检查 i 与 Z 检查 j 在左层共同踩到的比特数，(BA)[i][j] 是它们在右层共同踩到的比特数，AB + BA 是总重叠数——和 bicycle 码的「左轮重叠 + 右轮重叠」一模一样。

The first sum is by definition entry (i, j) of the matrix product AB (row i of A dotted with column j of B), the second that of BA. This holds for every (i, j), so the whole matrix is H_XH_Zᵀ = AB + BA. A numerical analogy: (1 2 | 3 4) dotted with (5 ; 6 ; 7 ; 8) = (1·5 + 2·6) + (3·7 + 4·8), “first half dotted with first half” plus “second half with second half”. The rule of block multiplication: as long as the block sizes fit, treat each block as a number — the “row” (A, B) dotted with the “column” (B, A) gives A·B + B·A — keeping the left-to-right order of the blocks. There is a good physical reading: (AB)[i][j] is row i of A dotted with column j of B, and column j of B is row j of Bᵀ, the legs of Z check j on the left layer, so (AB)[i][j] = the number of qubits X check i and Z check j share on the left layer, (BA)[i][j] the number they share on the right layer, and AB + BA the total overlap — exactly the bicycle code’s “left-wheel overlap + right-wheel overlap”.

第三步：2 × 2 的例子算一遍。用补课 2.B 的 A = 1 + x、B = 1 + y（4 × 4）。这个例子里 l = m = 2，恰好 Aᵀ = A、Bᵀ = B，所以 H_Z = [B | A]，H_Zᵀ = [B ; A]（8 行 4 列）：

Step three: the 2 × 2 example. Take A = 1 + x and B = 1 + y (4 × 4) from Catch-up 2.B. Here l = m = 2, so it happens that Aᵀ = A and Bᵀ = B, whence H_Z = [B | A] and H_Zᵀ = [B ; A] (8 rows, 4 columns):

先算 AB：A 的第 0 行 (1 0 1 0) 分别点 B 的四列 (1 1 0 0)ᵀ、(1 1 0 0)ᵀ、(0 0 1 1)ᵀ、(0 0 1 1)ᵀ，得 1、1、1、1；其余三行同样全是 1。再算 BA：B 的第 0 行 (1 1 0 0) 点 A 的四列 (1 0 1 0)ᵀ、(0 1 0 1)ᵀ、(1 0 1 0)ᵀ、(0 1 0 1)ᵀ，也是 1、1、1、1。于是

First AB: row 0 of A, (1 0 1 0), dotted with the four columns of B, (1 1 0 0)ᵀ, (1 1 0 0)ᵀ, (0 0 1 1)ᵀ, (0 0 1 1)ᵀ, gives 1, 1, 1, 1; the other three rows are all 1s as well. Then BA: row 0 of B, (1 1 0 0), dotted with the columns of A, (1 0 1 0)ᵀ, (0 1 0 1)ᵀ, (1 0 1 0)ᵀ, (0 1 0 1)ᵀ, again 1, 1, 1, 1. Hence

用多项式验证同一件事：AB = (1 + x)(1 + y) = 1 + x + y + xy，四个单项式把每个起点送到四个不同的格子，所以矩阵每行四个 1；BA = (1 + y)(1 + x) = 1 + y + x + yx，因 xy = yx 而完全相同。物理读法：这个小环面码里任何一条 X 检查和任何一条 Z 检查，在左层恰好共享 1 个比特、在右层也恰好共享 1 个，总共 2 个，偶数，对易。拿补课 3.A 的表核对：X 检查 (0,0) 碰 L00、L10、R00、R01，Z 检查 (1,1) 碰 L10、L11、R01、R11，共享 L10 和 R01。收尾：有了 H_XH_Zᵀ = AB + BA，3.2 剩下两步——AB = BA（补课 2.B），所以 AB + BA = AB + AB = 2AB；GF(2) 里 2 = 0，所以等于零矩阵。也可以不走代数、直接用物理读法：左层重叠数 (AB)[i][j] 与右层重叠数 (BA)[i][j] 永远相等，总数必然是偶数。

The polynomials say the same: AB = (1 + x)(1 + y) = 1 + x + y + xy, four monomials carrying every start to four different sites, so four 1s per row; BA = (1 + y)(1 + x) = 1 + y + x + yx, identical because xy = yx. Physically: in this little toric code any X check and any Z check share exactly 1 qubit on the left layer and exactly 1 on the right, 2 in all, even, commuting. Check against the table of Catch-up 3.A: X check (0,0) touches L00, L10, R00, R01; Z check (1,1) touches L10, L11, R01, R11; shared: L10 and R01. To finish: with H_XH_Zᵀ = AB + BA in hand, §3.2 has two steps left — AB = BA (Catch-up 2.B), so AB + BA = AB + AB = 2AB, and in GF(2) 2 = 0, the zero matrix. Or skip the algebra and use the physical reading: the left-layer overlap (AB)[i][j] always equals the right-layer overlap (BA)[i][j], so the total is necessarily even.

一、整数版的比方One: an analogy with integers

取两个整数 6 和 10，考虑所有能写成 6u + 10v 的数（u、v 任意整数）：6, 10, 12, 16, 4 = 10 − 6, 2 = 16 − 14, …，结果是全体偶数。这个集合就叫 6 和 10 生成的理想，记 (6, 10)。「把所有 6u + 10v 当作零之后还剩什么」——就是 mod 2 的世界：所有偶数都算 0，整数只剩「奇/偶」两类，Z/(6, 10) 只有 2 个元素。换成 (3, 5)：3u + 5v 能凑出 1 = 6 − 5，于是能凑出一切，理想占满整个 Z，商里只剩 1 个元素。「占得越少，剩的越多」——这就是那句「让 (A, B) 尽量不占满整个环」。

Take the integers 6 and 10 and consider every number of the form 6u + 10v (u, v any integers): 6, 10, 12, 16, 4 = 10 − 6, 2 = 16 − 14, … — all the even numbers. This set is the ideal generated by 6 and 10, written (6, 10). “What is left after every 6u + 10v is declared zero” is the world of mod 2: all even numbers count as 0, and the integers collapse to two classes, odd and even; Z/(6, 10) has 2 elements. Take (3, 5) instead: 3u + 5v reaches 1 = 6 − 5 and hence everything, the ideal fills all of Z, and the quotient has a single element. “The less it fills, the more is left” — that is the sentence “choose A, B so that (A, B) fills as little of the ring as possible”.

二、矩阵版：[A | B] 的像Two: the matrix version — the image of [A | B]

把 lm × 2lm 的矩阵 [A | B] 右乘一个长 2lm 的列向量，切成上下两半 (u ; v)（各长 lm），按分块乘法得 A·u + B·v。让 u、v 跑遍所有 0/1 向量，得到的全部结果叫这个矩阵的像，也就是它 2lm 根列向量的所有组合；像的维数就是秩（列秩 = 行秩）。用 2 × 2 的环面码算：H_X = [A | B] 的 8 根列竖着读是 A 的列 (1 0 1 0)、(0 1 0 1)、(1 0 1 0)、(0 1 0 1) 和 B 的列 (1 1 0 0)、(1 1 0 0)、(0 0 1 1)、(0 0 1 1)。不同的只有四根：1010、0101、1100、0011，而 1010 + 0101 = 1111 = 1100 + 0011，有一条依赖，所以秩 = 3。把它们组合出来的向量全部列出：0000, 1010, 0101, 1100, 0011, 1111, 1001, 0110——恰好是长度 4 的全部 8 个偶重量向量；任何奇重量向量（如 1000）永远到不了。4 维空间里像占了 3 维，差的那 1 维就是「商空间」：lm − r = 4 − 3 = 1，k = 2 × 1 = 2，正是 [[8,2,2]]。

Multiply the lm × 2lm matrix [A | B] on the right by a column vector of length 2lm, cut into halves (u ; v) (each of length lm); block multiplication gives A·u + B·v. Letting u and v range over all 0/1 vectors, the set of results is the matrix’s image, i.e. all combinations of its 2lm columns; the dimension of the image is the rank (column rank = row rank). For the 2 × 2 toric code: the 8 columns of H_X = [A | B], read downward, are the columns of A, (1 0 1 0), (0 1 0 1), (1 0 1 0), (0 1 0 1), and of B, (1 1 0 0), (1 1 0 0), (0 0 1 1), (0 0 1 1). Only four are distinct — 1010, 0101, 1100, 0011 — and 1010 + 0101 = 1111 = 1100 + 0011, one dependency, so the rank is 3. Listing every combination: 0000, 1010, 0101, 1100, 0011, 1111, 1001, 0110 — exactly the 8 even-weight vectors of length 4; no odd-weight vector (such as 1000) is ever reached. The image fills 3 of the 4 dimensions, and the missing one is the “quotient”: lm − r = 4 − 3 = 1, k = 2 × 1 = 2, which is [[8,2,2]].

三、翻译成多项式，就是 4.2 那段话Three: translated into polynomials, this is §4.2

长 lm 的向量和多项式一一对应：格子 (i, j) 上的分量就是 xⁱy^j 的系数，(1 0 1 0) ↔ 1 + x，(1 1 1 1) ↔ 1 + x + y + xy。2.3 说过这套翻译保持乘法，所以矩阵乘向量 A·u 就是多项式乘法 A·u，「像 = 所有 Au + Bv」翻译成「理想 (A, B) = 所有 uA + vB」。对 A = 1 + x、B = 1 + y 它是什么？u(1 + x) = u + xu，项数是偶数（相消也是成对消），所以理想里全是偶数项的多项式——和上面的偶重量向量完全对应。再看商 R/(A, B)：「把所有 uA + vB 当作零」，最起码 1 + x ≡ 0、1 + y ≡ 0，即 x ≡ 1、y ≡ 1。那么任何单项式 x^ay^b ≡ 1，任何多项式 ≡ 它的项数 mod 2，只可能是 0 或 1。整个 lm 维的环被压成了 {0, 1}：只剩常数，维数 1。它和 ∏A = I 的联系：像里全是偶重量 ⇔ 存在一个对所有列都成立的奇偶约束 ⇔ H_X 的所有行加起来是零行 ⇔ 全部星形检查乘起来是 I。lm 条检查里恰有 1 条多余，秩亏损 1，商空间 1 维——同一件事的三种口气。

Vectors of length lm correspond one-to-one to polynomials: the component at site (i, j) is the coefficient of xⁱy^j, so (1 0 1 0) ↔ 1 + x and (1 1 1 1) ↔ 1 + x + y + xy. Since §2.3 showed the translation respects multiplication, the matrix–vector product A·u is the polynomial product A·u, and “image = all Au + Bv” becomes “the ideal (A, B) = all uA + vB”. What is it for A = 1 + x, B = 1 + y? u(1 + x) = u + xu has an even number of terms (cancellations come in pairs), so the ideal consists of the even-term polynomials — matching the even-weight vectors above. Now the quotient R/(A, B): “declare every uA + vB zero”, so at the least 1 + x ≡ 0 and 1 + y ≡ 0, i.e. x ≡ 1 and y ≡ 1. Then every monomial x^ay^b ≡ 1 and every polynomial ≡ its number of terms mod 2, either 0 or 1. The whole lm-dimensional ring is squeezed to {0, 1}: only the constants remain, dimension 1. Its link to ∏A = I: the image is all even-weight ⇔ one parity constraint holds for every column ⇔ the rows of H_X sum to the zero row ⇔ all the star checks multiply to I. Exactly 1 of the lm checks is redundant, rank deficit 1, quotient of dimension 1 — three ways of saying one thing.

四、一个「占得更少」的例子Four: an example that fills less

用一维的环 x⁴ = 1（4 个格子），比较两个生成元。(1 + x)：u(1 + x) 是全部偶数项多项式，4 维里占 3 维，商 1 维；矩阵上 I + S 的四行 1100、0110、0011、1001 秩为 3。(1 + x²)：因为 (1 + x²)² = 1 + x⁴ = 1 + 1 = 0，倍数只有 {0, 1 + x², x + x³, 1 + x + x² + x³}，占 2 维，商 2 维；矩阵上 I + S² 的四行是 1010、0101、1010、0101，秩只有 2。同样是两项的多项式，一个占 3 维、一个占 2 维——项数决定检查重量，不决定秩，正是 4.3 那句「三项不决定 k」。回到 gross：环 R 是 72 维（12 × 6 个格子），理想 (A, B) 占 66 维（rank H_X = 66），商 R/(A, B) 是 6 维：把所有 uA + vB 当作零后，72 维的多项式空间被压成 2⁶ = 64 个「剩余类」，而不是环面码的 2 个。对应地，72 条 X 检查里有 6 条多余（6 组乘起来等于 I 的组合），秩亏损 6，k = 2 × 6 = 12。「设计 BB 码」就是在挑 A、B，让 uA + vB 凑不出的东西尽量多——但也不能多到 d 塌掉，那是 4.3、4.4 的另一半故事。

On the one-dimensional ring x⁴ = 1 (4 sites), compare two generators. (1 + x): u(1 + x) runs over all even-term polynomials, filling 3 of 4 dimensions, quotient of dimension 1; the four rows 1100, 0110, 0011, 1001 of I + S have rank 3. (1 + x²): since (1 + x²)² = 1 + x⁴ = 1 + 1 = 0, its multiples are only {0, 1 + x², x + x³, 1 + x + x² + x³}, filling 2 dimensions, quotient of dimension 2; the rows 1010, 0101, 1010, 0101 of I + S² have rank only 2. Two two-term polynomials, one filling 3 dimensions and the other 2 — the number of terms fixes the check weight, not the rank, which is the “three terms do not determine k” of §4.3. Back to gross: the ring R has 72 dimensions (12 × 6 sites), the ideal (A, B) fills 66 (rank H_X = 66), and the quotient R/(A, B) has 6: once every uA + vB is declared zero, the 72-dimensional space of polynomials is squeezed to 2⁶ = 64 “residue classes”, not the toric code’s 2. Correspondingly 6 of the 72 X checks are redundant (6 combinations multiplying to I), rank deficit 6, k = 2 × 6 = 12. “Designing a BB code” means choosing A and B so that as much as possible cannot be assembled from uA + vB — but not so much that d collapses, the other half of the story in §4.3 and §4.4.

五、dim 是什么，它和 rank 有什么区别Five: what dim is, and how it differs from rank

dim 读作「维数」，dim V 是线性空间 V 的维数：里面最多能挑出几个线性独立的向量，或者说，需要几个独立的 0/1 坐标才能唯一确定一个元素。在 GF(2) 上有一个很直接的数法：d 维空间恰好有 2^d 个元素——d 维就是「d 个比特能存的东西」。对号：GF(2)⁴ 有 16 个元素，dim = 4；其中偶重量向量 8 个，dim = 3，一组基是 1100、0110、0011；商空间 GF(2)⁴/(偶重量) 把相差偶重量向量的两个向量算作同一个，16 个只剩「偶」「奇」两类，2 = 2¹，dim = 1。商的维数不用真的构造商，一减就行：dim(商) = dim(整体) − dim(被当作零的子空间)，这就是「秩亏损」dim R/(A, B) = lm − rank[A | B]。

dim is read “dimension”; dim V is the dimension of a linear space V: the largest number of linearly independent vectors it contains, or equivalently how many independent 0/1 coordinates are needed to pin down an element. Over GF(2) there is a direct way to count: a d-dimensional space has exactly 2^d elements — d dimensions is “what d bits can store”. Matching up: GF(2)⁴ has 16 elements, dim = 4; its even-weight vectors number 8, dim = 3, with basis 1100, 0110, 0011 for instance; the quotient GF(2)⁴/(even weight) identifies two vectors that differ by an even-weight vector, leaving only the classes “even” and “odd”, 2 = 2¹, dim = 1. The dimension of a quotient needs no construction, just a subtraction: dim(quotient) = dim(whole) − dim(subspace declared zero), which is the “rank deficit” dim R/(A, B) = lm − rank[A | B].

dim 和 rank 很接近，但不是一回事：rank 是矩阵的属性，dim 是空间的属性。rank M 定义为 M 的行空间（= 列空间 = 像）的维数，所以秩是「某一个特定空间的 dim」；反过来，很多空间的 dim 不是哪个矩阵的秩——整个空间 GF(2)⁴ 的 dim 是 4，这里没有矩阵；核 {v : Mv = 0} 的 dim = 列数 − rank M（秩–零化度定理）；商空间的 dim = 4 − 秩。公式 k = 2·dim R/(A, B) 里的 dim 恰恰不是秩，而是秩亏损 lm − rank[A | B]；用秩写同一件事就是 4.1 的 k = 2(lm − r)。一个数「占了多少」（秩），一个数「剩了多少」（商的维数）。一句话记法：dim 是通用词，问任何一个线性空间「你有几维」；rank 是把这个问题专门问矩阵的像时的专用名词。

dim and rank are close but not the same: rank is a property of a matrix, dim a property of a space. rank M is defined as the dimension of M’s row space (= column space = image), so a rank is “the dim of one particular space”; conversely many dims are not the rank of anything — the whole space GF(2)⁴ has dim 4 with no matrix in sight; the kernel {v : Mv = 0} has dim = number of columns − rank M (rank–nullity); the quotient has dim = 4 − rank. The dim in k = 2·dim R/(A, B) is precisely not a rank but the deficit lm − rank[A | B]; written with ranks, the same statement is the k = 2(lm − r) of §4.1. One counts “how much is taken” (rank), the other “how much is left” (the quotient’s dimension). A mnemonic: dim is the general word, asking any linear space “how many dimensions have you”; rank is that question asked specifically of a matrix’s image.

把定义拆成三块：「X 串」「与所有 Z 检查对易」「不是 X 检查乘积」。X 串就是在若干比特上各放一个 X 再乘起来的算符 X(v)，v 是标出哪些比特的 0/1 向量——和 X 检查是同一种形状的东西，只是不一定是检查。「与所有 Z 检查对易」= 不触发任何警报。若 X(v) 与某条 Z 检查 S 反对易，则对任何码态 |ψ⟩（S|ψ⟩ = |ψ⟩）有 S·X(v)|ψ⟩ = −X(v)·S|ψ⟩ = −X(v)|ψ⟩：作用之后的态在 S 上测出 −1，警报响了，这是一个能被发现的错误。反过来，若 X(v) 与所有 Z 检查都对易，作用后所有检查仍给 +1——它把码态送到码态，纠错系统对它完全无感（X 串与 X 检查永远对易，所以只需看 Z 检查）。矩阵语言：H_Z·v = 0 (mod 2)，v 在 H_Z 的核里。「不是 X 检查乘积」= 排除白干的。若 X(v) 恰好等于几条 X 检查的乘积（v 是 H_X 若干行 mod 2 之和，在行空间里），它对每个码态什么都不做：每条检查 S 都有 S|ψ⟩ = |ψ⟩，乘积也一样。它「不被发现」，但也没改动任何编码信息——是稳定子，不算逻辑算符。两条合起来：X 逻辑算符 = 不被任何检查发现、却真的把某个码态变成了另一个码态的 X 串。这正是「骗过全部检查的错误」，同时也是我们操作逻辑比特的工具——同一个东西的两张面孔。

Split the definition into three pieces: “X string”, “commutes with every Z check”, “not a product of X checks”. An X string is an operator X(v) made by placing an X on each of some qubits and multiplying, v the 0/1 vector marking which — the same shape of object as an X check, just not necessarily a check. “Commutes with every Z check” = raises no alarm. If X(v) anticommuted with some Z check S, then for every code state |ψ⟩ (S|ψ⟩ = |ψ⟩) we would have S·X(v)|ψ⟩ = −X(v)·S|ψ⟩ = −X(v)|ψ⟩: the state after the operation reads −1 on S, an alarm, a detectable error. Conversely, if X(v) commutes with every Z check, all checks still read +1 afterwards — it maps code states to code states and the correction system is blind to it (X strings always commute with X checks, so only the Z checks matter). In matrix terms H_Z·v = 0 (mod 2): v lies in the kernel of H_Z. “Not a product of X checks” = excluding the do-nothings. If X(v) happens to equal a product of X checks (v a mod-2 sum of rows of H_X, in its row space), it does nothing to any code state: every check S has S|ψ⟩ = |ψ⟩ and so does the product. It “goes undetected” but also alters no encoded information — a stabilizer, not a logical operator. Together: an X logical operator is an X string that no check detects yet which really turns some code state into another. That is exactly “an error that fools every check”, and at the same time the tool with which we manipulate logical qubits — two faces of one object.

用 [[4,2,2]] 把三类 X 串各举一个Three kinds of X string in [[4,2,2]]

H_X = H_Z = (1 1 1 1)，码空间由四个态张成：|0000⟩+|1111⟩、|0011⟩+|1100⟩、|0101⟩+|1010⟩、|0110⟩+|1001⟩（补课 0.D）。X₁（v = 1000）：与 Z₁Z₂Z₃Z₄ 共享 1 个比特，反对易。它把 |0000⟩+|1111⟩ 变成 |1000⟩+|0111⟩，每个串奇数个 1，Z 检查测出 −1。可发现的错误。X₁X₂X₃X₄（v = 1111）：对易，但它本身就是 X 检查，把 |0000⟩+|1111⟩ 变成 |1111⟩+|0000⟩——同一个态。白干，是稳定子。X₁X₂（v = 1100）：与 Z₁Z₂Z₃Z₄ 共享 2 个比特，对易；1100 不是 (1111) 的倍数，不在行空间里。它把 |0000⟩+|1111⟩ 变成 |1100⟩+|0011⟩——第二个码态。没有任何警报，编码信息却被改写了。这就是一个 X 逻辑算符，重量 2。

H_X = H_Z = (1 1 1 1); the code space is spanned by |0000⟩+|1111⟩, |0011⟩+|1100⟩, |0101⟩+|1010⟩, |0110⟩+|1001⟩ (Catch-up 0.D). X₁ (v = 1000): shares 1 qubit with Z₁Z₂Z₃Z₄, anticommutes. It turns |0000⟩+|1111⟩ into |1000⟩+|0111⟩, each string with an odd number of 1s, and the Z check reads −1. A detectable error. X₁X₂X₃X₄ (v = 1111): commutes, but it is the X check itself; it turns |0000⟩+|1111⟩ into |1111⟩+|0000⟩ — the same state. A do-nothing, a stabilizer. X₁X₂ (v = 1100): shares 2 qubits with Z₁Z₂Z₃Z₄, commutes; 1100 is not a multiple of (1111), so it is outside the row space. It turns |0000⟩+|1111⟩ into |1100⟩+|0011⟩ — the second code state. No alarm anywhere, yet the encoded information has been rewritten. That is an X logical operator, of weight 2.

用向量说：H_Z 的核是全部 8 个偶重量向量；H_X 的行空间是 {0000, 1111}；逻辑 X 就是核里去掉行空间剩下的 6 个：1100, 0011, 1010, 0101, 1001, 0110。X₃X₄ 把 |0000⟩+|1111⟩ 也变成 |0011⟩+|1100⟩，和 X₁X₂ 效果相同——两者只差一个稳定子 X₁X₂X₃X₄。所以逻辑算符是「按稳定子分类」来数的：6 个向量分成 3 类 {1100, 0011}、{1010, 0101}、{1001, 0110}，正好是 2 个逻辑比特上非平凡 X 型算符的个数 2² − 1 = 3；核的维数 3 减去行空间的维数 1，等于 k = 2。4.4「学名一瞥」里的「核减去像 = 同调」，说的就是「对易的减去白干的」。

In vectors: the kernel of H_Z is all 8 even-weight vectors; the row space of H_X is {0000, 1111}; the logical Xs are the 6 left when the row space is removed from the kernel: 1100, 0011, 1010, 0101, 1001, 0110. X₃X₄ also turns |0000⟩+|1111⟩ into |0011⟩+|1100⟩, the same effect as X₁X₂ — the two differ only by the stabilizer X₁X₂X₃X₄. Logical operators are therefore counted “up to stabilizers”: the 6 vectors fall into 3 classes {1100, 0011}, {1010, 0101}, {1001, 0110}, exactly the 2² − 1 = 3 nontrivial X-type operators on 2 logical qubits; the kernel’s dimension 3 minus the row space’s dimension 1 equals k = 2. The “kernel minus image = homology” of the scholarly aside in §4.4 is “the commuting ones minus the do-nothings”.

「X(v) 是检查的乘积」的三种读法Three readings of “X(v) is a product of checks”

数学条件只有一句：v 在 H_X 的行空间里。看你把 X(v) 当作什么，它有三种读法。当作一条检查去测：它的结果一定等于那几条检查结果的乘积（Z₁Z₃ 的值 = Z₁Z₂ 的值 × Z₂Z₃ 的值），在码态上必然是 +1；把它加进检查表，秩不增加，它就是一条不独立的检查——「可以由其他检查的结果算出来」。当作一个操作施加在码态上：X(v)|ψ⟩ = |ψ⟩，对编码信息什么都没做，这是 4.4 排除它的理由。当作一个错误：发生了等于没发生，不用纠；两个只差一个稳定子的错误（X₁X₂ 与 X₃X₄）症状相同、效果相同，译码器不必分辨——这就是 6.3 说的量子码的「退化」。所以「检查不独立」和「X 串是检查乘积」是同一个代数事实的两张脸；只有一点措辞要小心：4.4 里的 X(v) 本来不是一条检查，而是任意一个候选的 X 串，「它恰好等于几条检查的乘积」是在判定它平凡。

The mathematical condition is one sentence: v lies in the row space of H_X. Depending on what you take X(v) to be, it reads three ways. As a check to measure: its outcome always equals the product of those checks’ outcomes (the value of Z₁Z₃ = the value of Z₁Z₂ × that of Z₂Z₃), necessarily +1 on a code state; adding it to the check table leaves the rank unchanged, so it is a dependent check — “computable from the other checks’ results”. As an operation applied to a code state: X(v)|ψ⟩ = |ψ⟩, it does nothing to the encoded information, which is why §4.4 excludes it. As an error: it might as well not have happened and needs no correction; two errors differing by a stabilizer (X₁X₂ and X₃X₄) have the same syndrome and the same effect, and the decoder need not tell them apart — the “degeneracy” of quantum codes mentioned in §6.3. So “a dependent check” and “an X string that is a product of checks” are two faces of one algebraic fact; the only care needed is in wording: the X(v) of §4.4 is not a check to begin with but an arbitrary candidate X string, and “it happens to equal a product of checks” is the verdict that it is trivial.

X₁·Z₁Z₂Z₃Z₄ = Z₁Z₂Z₃Z₄·X₁ 成立吗？Does X₁·Z₁Z₂Z₃Z₄ = Z₁Z₂Z₃Z₄·X₁ hold?

不成立，差一个负号：X₁Z₁Z₂Z₃Z₄ = −Z₁Z₂Z₃Z₄X₁。把 X₁ 从左边挪到右边：越过 Z₂、Z₃、Z₄ 免费（不同比特），越过 Z₁ 付一个 −1（同一比特上 XZ = −ZX，补课 0.C 的 2 × 2 矩阵）。这个负号就是「可发现」的全部内容：S = Z₁Z₂Z₃Z₄，|ψ⟩ = |0000⟩ + |1111⟩，S|ψ⟩ = |ψ⟩；出错后 X₁|ψ⟩ = |1000⟩ + |0111⟩，S·X₁|ψ⟩ = −X₁·S|ψ⟩ = −X₁|ψ⟩，新状态是 S 的 −1 本征态，测量必然得 −1。对比 X₁X₂：越过 Z₁、Z₂ 各付一个 −1，(−1)² = +1，对易；作用后得到 |1100⟩ + |0011⟩，每个串仍是偶数个 1，S 测出 +1，没有警报。

It does not — there is a sign: X₁Z₁Z₂Z₃Z₄ = −Z₁Z₂Z₃Z₄X₁. Move X₁ from the left to the right: passing Z₂, Z₃, Z₄ is free (different qubits), passing Z₁ costs one −1 (XZ = −ZX on the same qubit, the 2 × 2 matrices of Catch-up 0.C). That sign is the whole content of “detectable”: with S = Z₁Z₂Z₃Z₄ and |ψ⟩ = |0000⟩ + |1111⟩, S|ψ⟩ = |ψ⟩; after the error, X₁|ψ⟩ = |1000⟩ + |0111⟩ and S·X₁|ψ⟩ = −X₁·S|ψ⟩ = −X₁|ψ⟩, a −1 eigenstate of S, so the measurement must give −1. Compare X₁X₂: passing Z₁ and Z₂ costs −1 each, (−1)² = +1, commuting; the result |1100⟩ + |0011⟩ still has an even number of 1s in each string, S reads +1, no alarm.

「测」一个算符与「作用」一个算符不是一回事Measuring an operator and applying it are different things

测检查 Z₁Z₂Z₃Z₄：码态不变。码态是它的 +1 本征态，−1 分支为零（P₋|ψ⟩ = 0），结果必然 +1，测完的状态还是 |ψ⟩——这是检查这个设计的全部意义：每一轮都测、反复测，编码信息毫发无损；只有错误已经发生时，测量才把态投影到「没错」或「错了」两种干脆的情形之一（补课 0.B）。X₁X₂ 不是检查，纠错过程中没有人去「做」它。它以两种身份出现：错误——比特 1、2 碰巧同时翻了，Z 检查毫无察觉而信息被改写，这正是 d = 2 的码脆弱的地方；或有意施加的逻辑门——我们想对逻辑比特做一次 X̄，就故意在比特 1、2 上各做一个 X。即便把检查算符当作门去作用，码态也不变：S|ψ⟩ = |ψ⟩ 说的就是这个。反过来若去测 X₁X₂：它与所有检查对易，不会把态踢出码空间，但它是逻辑算符，测它就是读出逻辑比特的值，会把逻辑叠加 α|0̄⟩ + β|1̄⟩ 塌到一边——这是逻辑测量，不是检查。

Measuring the check Z₁Z₂Z₃Z₄ leaves the code state alone. The code state is a +1 eigenstate, its −1 part is zero (P₋|ψ⟩ = 0), the outcome is certainly +1 and the state afterwards is still |ψ⟩ — the whole point of the design: measure every round, over and over, and the encoded information is untouched; only once an error has occurred does the measurement project the state onto one of the clean cases “no error” or “error” (Catch-up 0.B). X₁X₂ is not a check, and nobody “performs” it during error correction. It appears in two guises: as an error — qubits 1 and 2 happen to flip together, the Z checks notice nothing and the information is rewritten, exactly the weakness of a d = 2 code; or as a deliberate logical gate — to apply X̄ to the logical qubit, one applies an X to qubits 1 and 2 on purpose. Even applying a check operator as a gate leaves the code state unchanged: that is what S|ψ⟩ = |ψ⟩ says. Conversely, measuring X₁X₂: it commutes with every check, so it does not kick the state out of the code space, but it is a logical operator, and measuring it reads out the logical value, collapsing a logical superposition α|0̄⟩ + β|1̄⟩ to one side — a logical measurement, not a check.

码距 d：最少动几个比特能骗过全部检查The distance d: the fewest qubits that fool every check

把上面的话倒过来问：最少在几个比特上放 X，能让所有 Z 检查查不出来、却改变了码态？这就是 X 码距 d_X——满足 H_Z·v = 0 且 v 不在 H_X 行空间里的 X 串中重量最小者的重量。「不是检查乘积」这一条不能省，因为有些查不出来的 X 串根本没改码态（X₁X₂X₃X₄）。同样定义 Z 码距 d_Z：最少放几个 Z，X 检查查不出来却改了码态。整个码的 d = min(d_X, d_Z)。几个数字：[[4,2,2]] 里 X₁X₂ 就够，d = 2；L × L 环面码要沿环面绕一整圈放 L 个 X（一条不可收缩的闭合回路），d = L；gross 码 d = 12：任何 11 个以内的 X（或 Z）要么触发警报、要么白干，静悄悄地改写信息至少得动 12 个比特。

Turn the statement around: what is the smallest number of qubits on which one can place Xs so that no Z check notices, yet the code state changes? That is the X distance d_X — the least weight of an X string with H_Z·v = 0 and v outside the row space of H_X. The clause “not a product of checks” cannot be dropped, because some undetectable X strings change nothing at all (X₁X₂X₃X₄). The Z distance d_Z is defined the same way: the fewest Zs that the X checks miss yet which alter the code state. The code’s distance is d = min(d_X, d_Z). Some numbers: in [[4,2,2]] X₁X₂ suffices, d = 2; the L × L toric code needs L Xs all the way round the torus (a non-contractible closed loop), d = L; the gross code has d = 12: any 11 or fewer Xs (or Zs) either trip an alarm or do nothing, and rewriting the information silently takes at least 12 qubits.

d 直接换算成纠错能力。能发现的错误重量上限是 d − 1（任何更轻的错误都会报警或无害）；能纠正的上限是 ⌊(d − 1)/2⌋：两个重量 ≤ t 的错误若症状相同，它们的「差」是一个重量 ≤ 2t 的、不被发现的算符，只要 2t < d，这个差就只能是无害的稳定子，译码器猜哪一个都对。所以 d = 2 的 [[4,2,2]] 能发现 1 个错误、纠正 0 个（L0 与 R2 那类孪生比特上的错误症状相同，猜错就成了逻辑算符——2.4.2）；d = 12 的 gross 能发现 11 个、保证纠正任意 5 个（实际译码器平均能纠更多，保证值是 5）。

d converts directly into correcting power. The largest error weight that is always detected is d − 1 (anything lighter either alarms or is harmless); the largest always corrected is ⌊(d − 1)/2⌋: if two errors of weight ≤ t have the same syndrome, their “difference” is an undetected operator of weight ≤ 2t, and as long as 2t < d that difference can only be a harmless stabilizer, so the decoder is right whichever it guesses. Hence [[4,2,2]] with d = 2 detects 1 error and corrects 0 (errors on twin qubits such as L0 and R2 share a syndrome, and a wrong guess becomes a logical operator — §2.4.2); gross with d = 12 detects 11 and is guaranteed to correct any 5 (real decoders correct more on average; 5 is the guarantee).

因为上界和下界是两种不同类型的命题，难度天差地别。上界是「存在」命题。要证 d ≤ 12，只需拿出一个重量 12 的合格 X 串（或 Z 串）：验证它很便宜——一次矩阵乘向量看 H_Z·v = 0，一次高斯消元看 v 不在 H_X 的行空间里，几毫秒。找这个见证可以用任何启发式：随机搜，或者把 BP-OSD 当作「找最轻解」的工具去跑（Bravyi 等人对大码就是这么给上界的）。运气好就找到，找到就算数。下界是「全称」命题。要证 d ≥ 12，得证明重量 1 到 11 的所有 X 串和 Z 串里没有一个合格——不是找一个东西，而是排除所有东西。

Because the two bounds are different kinds of statement, worlds apart in difficulty. An upper bound is an “exists” statement. To show d ≤ 12 one need only produce one qualifying X string (or Z string) of weight 12, and checking it is cheap — one matrix–vector product to see H_Z·v = 0, one Gaussian elimination to see that v is outside the row space of H_X, milliseconds. Finding the witness may use any heuristic: random search, or BP-OSD run as a “find the lightest solution” tool (which is how Bravyi et al. bound the larger codes). Luck helps, and a find counts. A lower bound is a “for all” statement. To show d ≥ 12 one must prove that among all X and Z strings of weight 1 through 11 none qualifies — not finding one thing but excluding everything.

排除多少东西？144 个位置里挑 w 个放 1，有 C(144, w) = 144!/(w!·(144−w)!) 种挑法，把 w = 1 到 11 加起来：

How much must be excluded? Choosing w of 144 positions for the 1s can be done in C(144, w) = 144!/(w!·(144−w)!) ways; summing w = 1 to 11:

每往上一格重量，个数约乘 (144 − w)/w ≈ 12 倍，总和几乎全由最后一项贡献。不用计算器也能估：C(144, 11) ≈ 144¹¹/11! 再乘一个修正——144¹¹ = 1.44¹¹ × 10²² ≈ 55 × 10²²，11! ≈ 4.0 × 10⁷，相除约 1.4 × 10¹⁶，修正因子 ∏(1 − i/144)（i = 0…10）≈ e^−55/144 ≈ 0.68，得约 9 × 10¹⁵，与精确值吻合。换个思路只在 H_Z 的核里找也不行：核的维数是 144 − 66 = 78，共 2⁷⁸ ≈ 3 × 10²³ 个向量，比按重量枚举还糟，因为核里绝大多数向量重量很大、根本不是候选。bb5 之所以能「穷举验证」，是因为它的核只有 2¹⁷ = 131 072 个向量，几秒扫完；gross 差了 18 个数量级。换成时间感受：就算每秒校验 10⁹ 个串，10¹⁶ 个也要三百多年；13 万个不到一毫秒。这就是「小码能穷举、gross 不能」的分界线。

Each step up in weight multiplies the count by about (144 − w)/w ≈ 12, so the sum is almost all the last term. It can be estimated without a calculator: C(144, 11) ≈ 144¹¹/11! times a correction — 144¹¹ = 1.44¹¹ × 10²² ≈ 55 × 10²², 11! ≈ 4.0 × 10⁷, quotient about 1.4 × 10¹⁶, correction factor ∏(1 − i/144) (i = 0…10) ≈ e^−55/144 ≈ 0.68, giving about 9 × 10¹⁵, matching the exact value. Searching only inside the kernel of H_Z is no better: the kernel has dimension 144 − 66 = 78, hence 2⁷⁸ ≈ 3 × 10²³ vectors — worse than enumerating by weight, since most kernel vectors are heavy and no candidates at all. bb5 can be “verified by exhaustion” because its kernel has only 2¹⁷ = 131 072 vectors, scanned in seconds; gross is 18 orders of magnitude away. As a feeling for time: even at 10⁹ string checks per second, 10¹⁶ strings take over three hundred years; 130 thousand take under a millisecond. That is the line between “small codes can be exhausted” and “gross cannot”.

量子码还多一层麻烦：退化。我们要的不是「核里最轻的向量」，而是「核里不在行空间中的最轻向量」。核里最轻的往往就是稳定子本身——gross 的检查重量只有 6，比 d = 12 轻得多，随手找到的轻向量全是白干的检查乘积，必须在每个非平凡的类里去找最轻代表，经典编码里的最小距离算法要为此改造。它本质上是困难问题。经典线性码的最小距离问题是 NP 困难的（Vardy, 1997）；量子码把经典情形当特例包含在内——取 H_X = 0 的 CSS 码，X 码距就等于 ker H_Z 这个经典码的最小距离——所以至少一样难。这不是「算法还不够聪明」，而是目前没有理由相信存在多项式时间的通用算法。对比 n 和 k：一次高斯消元，n³ 级别，秒出。

Quantum codes add a further nuisance: degeneracy. What is wanted is not “the lightest vector in the kernel” but “the lightest vector in the kernel outside the row space”. The lightest kernel vectors are usually the stabilizers themselves — gross’s checks have weight only 6, far below d = 12, so any light vector found casually is a do-nothing product of checks, and one must look for the lightest representative inside each nontrivial class; classical minimum-distance algorithms have to be adapted for this. The problem is intrinsically hard. Computing the minimum distance of a classical linear code is NP-hard (Vardy, 1997), and quantum codes contain the classical case as a special case — a CSS code with H_X = 0 has X distance equal to the minimum distance of the classical code ker H_Z — so they are at least as hard. It is not that the algorithms are not clever enough; there is currently no reason to believe a general polynomial-time algorithm exists. Compare n and k: one Gaussian elimination, of order n³, done in a second.

那下界实际是怎么来的？三条路。其一，小码穷举（bb5 的 verified）。其二，几何论证：环面码的逻辑算符必须绕环面一整圈，长度自然 ≥ L，一句话就是下界——但 BB 码的检查伸到几格之外又绕过环面，没有这样的图像可用。其三，精确的组合搜索：Bravyi 等人在论文里说明，Table 3 的码距是用混合整数规划（MIP）算出来的——把「最小重量」写成整数优化问题，交给求解器做带剪枝的穷举；对 [[144,12,12]] 这个规模能算完，对 [[360,12,≤24]] 和 [[756,16,≤34]] 就算不完了，所以表里只留下「≤」，只有 BP-OSD 找到的上界。那两个 ≤ 号，就是「下界难算」留在论文里的痕迹。最后一点是本页给 d 标证据等级的原因：随机搜索跑一整天没找到比 12 更轻的，只是证据，不是证明——它永远不能排除第 10¹⁶ 个候选恰好合格。所以 QEC-Bank 把「文献下界 + 机器找到的上界相符」记为 bounded，只有自己穷举过的才敢写 verified。

So where do lower bounds actually come from? Three routes. One, exhaustion for small codes (bb5’s “verified”). Two, geometric arguments: a toric-code logical operator must wind once around the torus, so its length is ≥ L and the bound is one sentence — but BB checks reach several sites away and wrap around the torus, and no such picture is available. Three, exact combinatorial search: Bravyi et al. state that the distances in Table 3 were computed by mixed integer programming (MIP) — “minimum weight” written as an integer optimisation and handed to a solver that exhausts with pruning; feasible at the scale of [[144,12,12]], infeasible for [[360,12,≤24]] and [[756,16,≤34]], which is why those rows carry only a “≤” and the upper bound BP-OSD found. Those two ≤ signs are the trace “lower bounds are hard” left in the paper. This is also why this page grades the evidence behind every d: a random search that runs all day without finding anything lighter than 12 is evidence, not proof — it can never rule out that the 10¹⁶-th candidate happens to qualify. Hence the QEC-Bank records “literature lower bound + machine-found upper bound agreeing” as bounded, and writes verified only where it exhausted the search itself.