把五个「为什么」
算到底 Five “whys”,
worked to the bottom

你在直觉教程里已经看见了这五件事（下表第二列逐条给出位置），这里要把它们证出来：

You have already seen these five things in the intuition guide (the table's second column links each place); here they get proved:

QEC-Bank 对这些页面立了一条规矩：凡是「算出来」的陈述，都必须能在仓库里重跑。脚本 codes/surface/pedagogy/reproduce.py 导入随 QEC-Bank 一起发布的构造器，逐条断言本教程用到的每个计算结果：检查矩阵、局域性、秩、逻辑代表元、症状走位、两个精确码距、L=5 的带种子上界、资源计数、以及 L=3 的矩形合并。任何一条不符，脚本立刻以非零状态退出。另有独立的验证器重跑 instances.yaml 里的参数。

The QEC-Bank imposes one rule on these pages: every statement that was “computed” must rerun inside the repository. The script codes/surface/pedagogy/reproduce.py imports the constructor shipped with the QEC-Bank and asserts every computed result this tutorial uses: check matrices, locality, ranks, logical representatives, the syndrome walk, the two exact distances, the seeded L=5 upper bound, resource counts, and the L=3 rectangular merge. On the first disagreement it exits nonzero. An independent verifier reruns the parameters in instances.yaml.

出处的划分是刻意的，本教程每一章都会沿用这套标签：

The provenance split is deliberate, and every chapter below reuses these labels:

令 H = rep_parity(L)长度 L 的重复码的奇偶检查矩阵：L−1 行、L 列，第 i 行只在第 i、i+1 列为 1，即「相邻两位相等」的检查。，一张 (L−1)×L 的 0/1 矩阵，每行是「相邻两位相等吗」：

Let H = rep_parity(L)The parity-check matrix of the length-L repetition code: L−1 rows, L columns, row i has 1s only in columns i and i+1, i.e. the check “are two neighbouring bits equal?”., an (L−1)×L binary matrix whose rows each ask “are two neighbouring bits equal?”:

三个事实。行独立：第 0 列只在第 0 行出现，所以任何「加起来为零」的行组合必须不含第 0 行；去掉它后第 1 列只剩第 1 行，同理……逐列推进，每个系数都被迫为零。于是 rank秩：矩阵里线性独立的行数（= 独立的列数）。这里在模 2 意义下计算。(H) = L−1。核是一维的：ker核（kernel）：使 H·v = 0 的全部向量 v 组成的空间。dim ker H = 列数 − rank(H)。(H) 只有两个元素：零向量与全 1 向量（每对相邻位都相等，只能全 0 或全 1）；全 1 向量是它唯一的基向量，dim ker H = L − (L−1) = 1。转置的核是零维的：Hᵀ 有 L 行、L−1 列且列独立，所以 dim ker Hᵀ = (L−1) − (L−1) = 0。

Three facts. The rows are independent: column 0 appears only in row 0, so any combination of rows summing to zero cannot contain row 0; remove it and column 1 survives only in row 1, and so on, column by column, every coefficient is forced to zero. Hence rankThe number of linearly independent rows (= independent columns) of a matrix, computed here mod 2.(H) = L−1. The kernel is one-dimensional: kerThe kernel: the space of all vectors v with H·v = 0. dim ker H = number of columns − rank(H).(H) has exactly two elements, the zero vector and the all-ones vector (every neighbouring pair equal forces all bits equal, so all 0 or all 1); the all-ones vector is its single basis vector, and dim ker H = L − (L−1) = 1. The transpose kernel is zero-dimensional: Hᵀ has L rows, L−1 independent columns, so dim ker Hᵀ = (L−1) − (L−1) = 0.

最后那个 0 值得记住。若把链首尾相接成 L 条边的圈，就要多加一行「第 L−1 位与第 0 位相等」——但这一行是前面各行之和，依赖。普通核仍是一维，转置核却变成一维。这一个数字的差别，正是平面与环面的差别（1.4 节）。

Remember that final 0. Close the chain into an L-edge cycle and you add one row, “bit L−1 equals bit 0” — but that row is the sum of all the others: dependent. The ordinary kernel stays one-dimensional while the transpose kernel becomes one-dimensional. That single digit is the whole difference between plane and torus (§1.4).

超图乘积Hypergraph product (HGP)：Tillich–Zémor 的构造，把两条经典检查矩阵 H₁、H₂ 组合成一对对易的量子 CSS 检查矩阵。这里两条都取 H。（HGP，tillich2009quantum）拿两份 H，把量子比特放进两块：比特×比特块，L×L = L² 个；检查×检查块，(L−1)×(L−1) = (L−1)² 个。合计 n = L² + (L−1)² = 2L²−2L+1，正是直觉教程账本里的 d² + (d−1)²。两张检查矩阵各有 L(L−1) 行，用⊗（张量积：A⊗B 把 B 整份复制进 A 的每个 1 所在位置）写成：

The hypergraph productHGP: the Tillich–Zémor construction combining two classical check matrices H₁, H₂ into a commuting pair of quantum CSS check matrices. Here both are H. (HGP, tillich2009quantum) takes two copies of H and places qubits in two blocks: the bit×bit block, L×L = L² qubits; the check×check block, (L−1)×(L−1) = (L−1)² qubits. In total n = L² + (L−1)² = 2L²−2L+1, exactly the d² + (d−1)² of the intuition guide's ledger. The two check matrices, each with L(L−1) rows, are written with ⊗ (the tensor product: A⊗B copies all of B into the position of each 1 in A):

CSS 码要求每条 X 检查与每条 Z 检查对易，即重叠格数为偶数；写成矩阵就是 H_XH_Zᵀ = 0（模 2）。要算这个乘积，需要张量积的三条规则（A、B、C、D 是任意矩阵）：

A CSS code needs every X-check to commute with every Z-check, i.e. an even number of overlapping cells; in matrix form, H_XH_Zᵀ = 0 (mod 2). Computing this product takes three rules of the tensor product (A, B, C, D are any matrices):

1. 尺寸：A 是 p×q、B 是 r×s，则 A⊗B 是 pr × qs（p×q 个格子，每格放一份 r×s 的 B，乘上 A 在该格的数）。
2. 转置：(A⊗B)ᵀ = Aᵀ⊗Bᵀ（块的位置互换，每块自己也转置）。
3. 混合乘积：(A⊗B)(C⊗D) = (AC)⊗(BD)，只要 AC 与 BD 本身能乘（A 的列数 = C 的行数，B 的列数 = D 的行数）。理由：乘积的第 (r,t) 块 = Σ_u (a_ruB)(c_utD) = (Σ_u a_ruc_ut)·BD = (AC)_rt·BD。

1. Size: if A is p×q and B is r×s, then A⊗B is pr × qs (p×q cells, each holding a copy of the r×s matrix B times A's entry in that cell).
2. Transpose: (A⊗B)ᵀ = Aᵀ⊗Bᵀ (the blocks swap places and each block is transposed).
3. Mixed product: (A⊗B)(C⊗D) = (AC)⊗(BD), provided AC and BD are defined (columns of A = rows of C, columns of B = rows of D). Reason: block (r,t) of the product is Σ_u (a_ruB)(c_utD) = (Σ_u a_ruc_ut)·BD = (AC)_rt·BD.

第一块：(H⊗I_L)(I_L⊗H)ᵀ = (H⊗I_L)(I_L⊗Hᵀ) = (H·I_L)⊗(I_L·Hᵀ) = H⊗Hᵀ。尺寸对得上：H 是 (L−1)×L、I_L 是 L×L，可乘；I_L 是 L×L、Hᵀ 是 L×(L−1)，可乘。结果是 (L−1)L × L(L−1) 的方阵，每个元素对应一对（X 检查, Z 检查）；L=3 时是 6×6。第二块同理：(I_L−1⊗Hᵀ)(Hᵀ⊗I_L−1)ᵀ = (I_L−1⊗Hᵀ)(H⊗I_L−1) = (I_L−1·H)⊗(Hᵀ·I_L−1) = H⊗Hᵀ。汇总成一行：

Block one: (H⊗I_L)(I_L⊗H)ᵀ = (H⊗I_L)(I_L⊗Hᵀ) = (H·I_L)⊗(I_L·Hᵀ) = H⊗Hᵀ. The sizes fit: H is (L−1)×L and I_L is L×L, so they multiply; I_L is L×L and Hᵀ is L×(L−1), so they multiply. The result is an (L−1)L × L(L−1) square matrix with one entry per (X-check, Z-check) pair; at L=3 it is 6×6. Block two works the same way: (I_L−1⊗Hᵀ)(Hᵀ⊗I_L−1)ᵀ = (I_L−1⊗Hᵀ)(H⊗I_L−1) = (I_L−1·H)⊗(Hᵀ·I_L−1) = H⊗Hᵀ. In one line:

用 L=3 算一个元素。H⊗I₃ 的行按（H 的行 i, I₃ 的行 j）排成第 3i+j 行，所以 X1 = (i=0, j=1)；I₃⊗H 的行按（k, l）排成第 2k+l 行，所以 Z2 = (k=1, l=0)。H⊗Hᵀ 在这一格的值是 H[i,k]·Hᵀ[j,l] = H[0,1]·H[0,1] = 1·1 = 1（H 的第 0 行是 1 1 0）。对照下面的表：比特×比特块里 X1 = {q1, q4}、Z2 = {q3, q4}，共享 q4，一格；检查×检查块里 X1 = {q9, q10}、Z2 = {q9, q11}，共享 q9，又一格。两块各 1，合计 2，偶数。

Compute one entry at L=3. The rows of H⊗I₃ are ordered by (row i of H, row j of I₃) as row 3i+j, so X1 = (i=0, j=1); the rows of I₃⊗H are ordered by (k, l) as row 2k+l, so Z2 = (k=1, l=0). H⊗Hᵀ has the value H[i,k]·Hᵀ[j,l] = H[0,1]·H[0,1] = 1·1 = 1 there (row 0 of H is 1 1 0). Compare the tables below: in the bit×bit block X1 = {q1, q4} and Z2 = {q3, q4} share q4, one cell; in the check×check block X1 = {q9, q10} and Z2 = {q9, q11} share q9, one more. One from each block, 2 in total, even.

两项相同，相加为零。所以第二块不是装饰：它提供了对易缺陷的第二份拷贝，让缺陷成对相消。在整数意义下（先不取模），H_XH_Zᵀ 的每个元素只能是 0 或 2，reproduce.py 对 L=3,4,5 都断言了这一点。L=3 时，构造器给出的两张矩阵是（竖线左边 9 列对应 q0…q8，右边 4 列对应 q9…q12）：

The two terms are identical, so they sum to zero. Block two is therefore not decorative: it supplies the second copy of the would-be commutation defect, so the defects cancel in pairs. Over the integers (before reducing), every entry of H_XH_Zᵀ is 0 or 2; reproduce.py asserts this for L=3,4,5. At L=3 the constructor gives (the 9 columns left of the bar are q0…q8, the 4 on the right are q9…q12):

动手核对一次：X1 的支撑是 {q1, q4, q9, q10}，Z2 的支撑是 {q3, q4, q9, q11}，重叠 {q4, q9} 两格，偶数，对易。X0 = {q0, q3, q9} 与 Z0 = {q0, q1, q9} 重叠也是两格。每行的 1 的个数只有 3 或 4，这将在下一节得到几何解释。

Check one by hand: X1 has support {q1, q4, q9, q10}, Z2 has {q3, q4, q9, q11}, overlapping in {q4, q9}, two cells, even, so they commute. X0 = {q0, q3, q9} and Z0 = {q0, q1, q9} also overlap in two. Every row has 3 or 4 ones, which the next section explains geometrically.

矩阵没有几何；几何来自构造器给每个下标分配的坐标。比特×比特块的比特 (a,b) 放在 (2b, 2a)；检查×检查块的比特 (a,b) 放在 (2b+1, 2a+1)；X 检查 (a,b) 放在 (2b, 2a+1)；Z 检查 (a,b) 放在 (2b+1, 2a)。这样每条检查行里的每个 1 都连到曼哈顿距离两点在格点上的距离 |Δx| + |Δy|，只沿横竖方向走。恰为 1 的位置。内部检查有四个邻居；到了左右或上下边缘，一个邻居不存在，检查降为三腿。reproduce.py 对每个发布尺寸的每一行都核对了「距离集合 = {1}」，不只对画出来的 L=3。

A matrix has no geometry; the geometry comes from the coordinates the constructor assigns to each index. A bit×bit qubit (a,b) sits at (2b, 2a); a check×check qubit (a,b) at (2b+1, 2a+1); an X-check (a,b) at (2b, 2a+1); a Z-check (a,b) at (2b+1, 2a). Then every 1 in a check row joins a site at Manhattan distanceThe distance |Δx| + |Δy| between two lattice points, walking only horizontally and vertically. exactly one. Interior checks have four neighbours; at a left/right or top/bottom edge one neighbour is missing and the check drops to three legs. reproduce.py checks “distance set = {1}” for every row of every shipped size, not only the drawn L=3.

每张量子检查矩阵有 L(L−1) 行。它们独立吗？用 1.1 节证 H 行独立的同一招，逐列推进。看 H_X 的比特×比特块：X 检查 (a,b) 在这一块里只碰 (a,b) 与 (a+1,b) 两个比特。取 a = 0 的那些比特 (0,b)：每个只被 X 检查 (0,b) 碰到，所以任何「加起来为零」的行组合都不含 a = 0 的检查；去掉它们后，比特 (1,b) 只剩 X 检查 (1,b) 碰得到，于是它们也不在；一路推到 a = L−2。所以 H_X 的 L(L−1) 行全部独立，H_Z 换成沿 b 方向推进，同理。L = 3 时可以在 1.2 节的表里直接看：q0、q1、q2 三列各自只在 X0、X1、X2 有 1，去掉这三行后 q3、q4、q5 三列各自只在 X3、X4、X5 有 1。于是：

Each quantum check matrix has L(L−1) rows. Are they independent? Use the same trick that proved H's rows independent in §1.1, advancing column by column. Look at the bit×bit block of H_X: within it, X check (a,b) touches only the qubits (a,b) and (a+1,b). Take the qubits (0,b) with a = 0: each is touched only by X check (0,b), so no combination of rows adding up to zero contains a check with a = 0; with those gone, qubit (1,b) can only be touched by X check (1,b), so those are out too; continue up to a = L−2. So all L(L−1) rows of H_X are independent, and H_Z likewise, advancing along b. For L = 3 you can see it in the tables of §1.2: columns q0, q1, q2 have their only 1 in X0, X1, X2, and once those rows are removed, columns q3, q4, q5 have their only 1 in X3, X4, X5. Hence:

所以每一行都独立，没有一条白送的恒等式，与直觉教程「平面上没有恒等式」的论证一致。同一个结果还能从 HGP 的维数公式直接读出，这个写法把 1.1 节那个 0 的意义说得最清楚：

So every row is independent, no identity comes free, matching the intuition guide's “no identities on a plane” argument. The same result also reads off the HGP dimension formula, which makes the meaning of §1.1's 0 clearest:

把两条开链都闭合成 L 条边的圈，转置核从 0 变成 1，公式给 2——正是环面码存 2 个逻辑比特的账。平面与环面之间只差这一个数字。下面的沙盘就是 L=3 的这块贴片（13 个比特、12 条检查）：点击比特放错误，观察哪些检查报警，并对照图 1.1 的坐标。注意沙盘沿用直觉教程的画法（比特画在边上，毛边界在左右），与图 1.1 的坐标差 90°：沙盘的一行横边对应图 1.1 的一列实心点。

Close both open chains into L-edge cycles: the transpose kernel goes from 0 to 1 and the formula gives 2 — exactly the ledger of the toric code's two logical qubits. Plane and torus differ by that one digit. The sandbox below is this very L=3 patch (13 qubits, 12 checks): click qubits to place errors, watch which checks fire, and compare with the coordinates of Fig. 1.1. Note that the sandbox keeps the intuition guide's drawing (qubits on edges, rough boundaries left and right), turned 90° from Fig. 1.1: one row of horizontal edges in the sandbox corresponds to one column of filled dots in Fig. 1.1.

给比特×比特块编号 (a,b)，0 ≤ a,b < L。固定 a，在全部 (a,b) 上放 X，得一条横穿的「X 行」（图 1.1 里就是同一条 y=2a 水平线上的实心点）。每条 Z 检查位于 (2b'+1, 2a')，只有 a'=a 时才碰到这一行，而且恰碰两个比特 (a,b') 与 (a,b'+1)——0 或 2 次，永远对易。固定 b，在全部 (a,b) 上放 Z，得一条竖穿的「Z 列」，同理与每条 X 检查相遇 0 或 2 次。

Index the bit×bit block by (a,b), 0 ≤ a,b < L. Fix a and put X on every (a,b): a horizontal “X row” (in Fig. 1.1, the filled dots on one line y=2a). A Z-check at (2b'+1, 2a') meets this row only when a'=a, and then in exactly two qubits (a,b') and (a,b'+1) — zero or two times, always commuting. Fix b and put Z on every (a,b): a vertical “Z column”, likewise meeting every X-check zero or two times.

一行与一列恰好相交一次（在 (a,b)），所以按碰撞规则两者反对易。与某个通过全部检查的算符反对易的东西，不可能是稳定子（稳定子与一切通过检查的算符对易）；反过来亦然。所以两条串都不是稳定子，都是逻辑算符，重量都是 L。于是 d ≤ L。

A row and a column intersect exactly once (at (a,b)), so by the collision rule they anticommute. Anything anticommuting with an operator that passes every check cannot be a stabilizer (stabilizers commute with everything that passes the checks), and vice versa. So neither string is a stabilizer; both are logicals of weight L. Hence d ≤ L.

共有 L 条 X 行（a = 0…L−1）与 L 条 Z 列。它们代表同一个逻辑算符吗？看相邻两行 a 与 a+1 之间的那条「带」：X 检查 (a, b') 位于 (2b', 2a+1)，b' = 0…L−1，各连着上下两个比特×比特比特 (a,b')、(a+1,b') 和左右两个检查×检查比特。把带里全部 L 条 X 检查乘起来：每个检查×检查比特 (a,b'') 被左右两条检查各碰一次，成对抵消；剩下的恰好是整条第 a 行加整条第 a+1 行。所以「行 a」×「行 a+1」= 稳定子，两行等价。逐带推进，全部 L 条 X 行都在同一个逻辑类里。对 Z 列，用 Z 检查组成的竖直带做同样的事。

There are L X-rows (a = 0…L−1) and L Z-columns. Do they represent the same logical? Look at the “strip” between adjacent rows a and a+1: the X-checks (a, b') at (2b', 2a+1), b' = 0…L−1, each join the two bit×bit qubits (a,b'), (a+1,b') above and below and the check×check qubits to their left and right. Multiply all L X-checks in the strip: every check×check qubit (a,b'') is touched once by the check on its left and once by the one on its right, cancelling in pairs; what remains is exactly row a plus row a+1. So “row a” × “row a+1” = a stabilizer, and the two rows are equivalent. Strip by strip, all L X-rows lie in one logical class. For Z-columns, do the same with vertical strips of Z-checks.

同时，同一族内各条代表元的支撑两两不相交：行 a 与行 a' 没有公共比特。这两点合起来（等价 + 不交）就是下界的全部弹药；图 2.1 把两者在 L=3 上画了出来。

At the same time, the representatives within one family have pairwise disjoint supports: row a and row a' share no qubit. These two facts together (equivalent + disjoint) are all the ammunition the lower bound needs; Figure 2.1 draws both at L=3.

因为 k = 1，每个非平凡逻辑类都能写成 X_L^aZ_L^b，其中指数 a、b 各取 0 或 1（「用不用这个生成元」的开关位，与 2.1 节的坐标下标 (a,b) 无关），且 (a,b) ≠ (0,0)：三种取法给出 X_L、Z_L、Y_L = X_LZ_L。设 P 是任意一个非平凡逻辑算符。它至少与 X_L、Z_L 之一反对易（若两者都对易，它就与全部逻辑算符对易，只能是稳定子，平凡）。

Since k = 1, every nontrivial logical class is X_L^aZ_L^b, where the exponents a, b are bits, each 0 or 1 (an on/off switch for that generator, unrelated to the coordinate indices (a,b) of §2.1), with (a,b) ≠ (0,0): the three choices give X_L, Z_L, Y_L = X_LZ_L. Let P be any nontrivial logical. It anticommutes with at least one of X_L, Z_L (commuting with both would mean commuting with every logical, hence a stabilizer, hence trivial).

设 P 与 Z 类反对易。关键一步：与类反对易 = 与类中每个代表元反对易，因为给一个代表元乘上稳定子，不会改变它与逻辑算符的对易性（稳定子与 P 对易）。于是 P 与全部 L 条 Z 列都反对易（图 2.1b）。要与一条纯 Z 的列反对易，P 必须在这条列上某处有 X 或 Y 支撑。L 条列互不相交，所以 P 至少在 L 个不同的比特上非平凡：wt(P) ≥ L。若 P 与 X 类反对易，换成 L 条不相交的 X 行，同理。

Suppose P anticommutes with the Z class. The key step: anticommuting with a class = anticommuting with every representative of it, because multiplying a representative by a stabilizer cannot change its commutator with a logical (stabilizers commute with P). So P anticommutes with all L Z-columns (Figure 2.1b). To anticommute with a pure-Z column, P must have X or Y support somewhere on that column. The L columns are disjoint, so P is nontrivial on at least L distinct qubits: wt(P) ≥ L. If instead P anticommutes with the X class, use the L disjoint X-rows, and the same argument runs.

到实验台上画一条：一条横跨的串通过全部检查就是逻辑算符；试着少画一格，看警报如何揭发它；再画两条平行的、试着用检查的乘积把一条变成另一条，体会「等价」。

Draw one on the bench: a spanning string that passes every check is a logical; stop one cell short and watch the alarms expose it; then draw two parallel ones and try turning one into the other with a product of checks, to feel “equivalence”.

定理已经对所有 L 成立，为什么还要机器？因为 QEC-Bank 的证书不信任论证本身，只信任重跑。reproduce.py 在 L=3 断言：X 行都是逻辑、彼此等价、两两不交（True）；Z 列同理；逻辑 X 支撑 [0, 1, 2]（a=0 那一行，即 q0 q1 q2）；逻辑 Z 支撑 [0, 3, 6]（b=0 那一列，即 q0 q3 q6）；精确码距 3，方法 exact-css-enum。L=4 的穷举 CSS 逻辑枚举返回 4。这两条在 instances.yaml 里是 verified。

The theorem already holds for every L, so why a machine? Because QEC-Bank certificates trust reruns, not arguments. At L=3, reproduce.py asserts: the X-rows are logical, mutually equivalent and pairwise disjoint (True); likewise the Z-columns; logical X support [0, 1, 2] (the a=0 row, i.e. q0 q1 q2); logical Z support [0, 3, 6] (the b=0 column, i.e. q0 q3 q6); exact distance 3 by exact-css-enum. At L=4, exhaustive CSS logical enumeration returns 4. Both are verified in instances.yaml.

L=5 时穷举不在验证器里。下界 d ≥ 5 来自上面的定理与 dennis2002topological（Dennis, Kitaev, Landahl, Preskill, “Topological quantum memory”, 2002）；上界来自一次确定性的低重量搜索，method=rand-lowweight-v1, seed=0, iters=2000，找到了一个重量 5 的逻辑算符。所以条目写的是 lower 5、upper 5、origin: bounded。「bounded」这个词是刻意的：定理给下界，验证器能重跑上界见证，但流水线不称这个结果为穷举。

At L=5, exhaustive enumeration is not part of the verifier. The lower bound d ≥ 5 comes from the theorem above and dennis2002topological (Dennis, Kitaev, Landahl, Preskill, “Topological quantum memory”, 2002); the upper bound from a deterministic low-weight search, method=rand-lowweight-v1, seed=0, iters=2000, which finds a weight-5 logical. So the entry records lower 5, upper 5, origin: bounded. The word “bounded” is intentional: the theorem supplies the lower bound and the verifier reruns the upper-bound witness, but the pipeline does not call the result exhaustive.

把一个 X 错误的支撑写成 0/1 向量 e_X（长 n，出错的比特处为 1）。报警的 Z 检查就是向量 H_Ze_X（模 2）：第 j 个分量是「Z 检查 j 的支撑与错误支撑重叠的格数」的奇偶，正是碰撞规则。沿着一条链，每个内部检查被两段相邻的错误各碰一次，模 2 抵消，只有端点留下来。这就是∂E（读「E 的边界」，一条链的端点集合）：

Write the support of an X error as a 0/1 vector e_X (length n, a 1 on each faulty qubit). The fired Z-checks are the vector H_Ze_X (mod 2): component j is the parity of “how many cells Z-check j's support overlaps the error's”, which is the collision rule. Along a chain, each interior check is touched once by each of two adjacent error segments, cancelling mod 2; only the endpoints remain. This is ∂E (read “the boundary of E”, the set of a chain's endpoints):

在凝聚边界condensing boundary：能让某一类错误链的端点无声消失的边界。X 链在光边界（三腿 X 检查所在边）凝聚，Z 链在毛边界凝聚。上，链可以终止而没有第二个物理检查报警——这就是直觉教程「边界吃掉警报」的代数版本。在译码器的图里，这件事表示为把剩下的那个缺陷配到一个「边界节点」上。

At a condensing boundaryA boundary where the endpoint of one type of error chain vanishes silently. X-chains condense at the smooth boundary (where the three-leg X-checks sit), Z-chains at the rough boundary. a chain can end without a second physical check firing — the algebraic version of the intuition guide's “the boundary swallows the alarm”. In a decoder graph this is represented by pairing the leftover defect with a “boundary node”.

用 1.2 节的矩阵直接相乘。构造器把中央比特叫 q4，中间一行是 q3、q4、q5（图 1.1 里 y=2 那条线）。五次乘法给出五个症状：

Multiply with §1.2's matrices directly. The constructor calls the central qubit q4, and the middle row is q3, q4, q5 (the line y=2 in Fig. 1.1). Five products give five syndromes:

核对第一行：q4 是第 4 列，在 H_Z 里第 4 列为 1 的行是 Z2（000110000）与 Z3（000011000），正是 {Z2, Z3}。最后一行最重要：{q3, q4, q5} 是 2.4 节那条 a=1 的 X 行，「没有症状」不等于「没有错误」——它是一个逻辑 X，reproduce.py 用 _is_logical_x 断言它通过全部 Z 检查且不在 X 稳定子的行空间里。整个序列就是一个缺陷从光边界进入、走过贴片、消失在对面光边界的过程。

Verify the first row: q4 is column 4, and the rows of H_Z with a 1 in column 4 are Z2 (000110000) and Z3 (000011000), exactly {Z2, Z3}. The last row matters most: {q3, q4, q5} is §2.4's a=1 X-row, and “no syndrome” is not “no error” — it is a logical X, which reproduce.py asserts with _is_logical_x: it passes every Z-check and is not in the row space of the X stabilizers. The whole sequence is one defect entering at a smooth boundary, walking across the patch, and disappearing at the opposite smooth boundary.

给定症状 s，任何候选修复 C 都满足 ∂C = s。若真实错误是 E，则 ∂(E+C) = s + s = 0：E+C 是一个圈（相对于凝聚边界，允许端点落在边界上）。修复成功，当且仅当这个圈是稳定子的乘积；失败，当且仅当它落在非平凡的相对同调类relative homology class：把「差一个稳定子」的圈视为相同后剩下的类别。这里 k=1：单看 X 型（或 Z 型）的圈，只有两个类，平凡（稳定子的乘积）与非平凡（横跨串条数为奇，即 X_L 或 Z_L 乘稳定子）；把两种类型合起来，逻辑 Pauli 共四类：I、X_L、Z_L 与乘积 Y_L = X_LZ_L。里。怎么判断落在哪类？X 部分与 Z 部分分开数。E⊕C 的 X 部分通过全部 Z 检查；k=1 时这样的 X 型算符只有两种：X 稳定子（与每条 Z 列重叠偶数格，因为稳定子与 Z_L 对易），或 X 稳定子乘 X_L（重叠奇数格）。所以只要数它与任意一条 Z 列（2.1 节的 Z_L）重叠几格：偶数则 X 部分无害，奇数则留下一个逻辑 X 错误。Z 部分同理，数它与一条 X 行的重叠。在图上，这个奇偶就是 E⊕C 里横跨串条数的奇偶：一条横跨串是逻辑算符，两条平行的横跨串合起来是一条带里检查的乘积（图 2.1a），无害。判据是「奇数条」，不是「出现了横跨串」。图 3.1 用同一个症状的两种修复把这件事算了一遍；直觉教程的译码游戏用的也是这个判据。

Given a syndrome s, every candidate correction C satisfies ∂C = s. If the actual error is E, then ∂(E+C) = s + s = 0: E+C is a cycle (relative to the condensing boundaries, so endpoints may rest on them). Recovery succeeds exactly when that cycle is a product of stabilizers, and fails exactly when it lies in a nontrivial relative homology classThe classes left after identifying cycles that differ by a stabilizer. Here k=1: looking at X-type (or Z-type) cycles alone there are just two classes, trivial (a product of stabilizers) and nontrivial (an odd number of spanning strings, i.e. X_L or Z_L times stabilizers); combining both types, the logical Paulis form four classes: I, X_L, Z_L and the product Y_L = X_LZ_L.. Which class is it? Count the X part and the Z part separately. The X part of E⊕C passes every Z-check, and at k=1 such an X-type operator is one of two kinds: an X stabilizer (it overlaps every Z column in an even number of cells, because stabilizers commute with Z_L), or an X stabilizer times X_L (an odd number of cells). So count its overlap with any one Z column (§2.1's Z_L): even means the X part is harmless, odd means a logical X error remains. The Z part works the same way, counting overlap with an X row. On the picture, this parity is the parity of the number of spanning strings in E⊕C: one spanning string is a logical, while two parallel spanning strings together are the product of the checks in one strip (Figure 2.1a) and do no harm. The criterion is “an odd number”, not “a spanning string is present”. Figure 3.1 works this out for two repairs of the same syndrome; the intuition guide's decoding game uses the same criterion.

于是「译码」不是猜出 E 本身，而是在类之间二选一。最小重量匹配挑代价最低的端点配对（一条最短链）；最大似然译码则对每一类里所有链的概率求和。两者的差别叫路径退化，它能把匹配与最优两种码容量阈值分开——具体数字在第 5 章的账本里。译码器教程把这两种策略讲成了一门课：从症状到类、最优译码 = 押概率最大的类、最小重量完美匹配、退化：一类里有多少条链。

So “decoding” is not guessing E itself; it is choosing between classes. Minimum-weight matching picks the cheapest pairing of endpoints (one shortest chain); maximum-likelihood decoding instead sums the probabilities of all chains in each class. The difference is path degeneracy, and it can separate the matching and optimal code-capacity thresholds — the exact numbers live in Chapter 5's ledger. The decoders guide teaches both strategies as a course: from syndrome to class, optimal decoding = bet on the most probable class, minimum-weight perfect matching, degeneracy: how many chains in a class.

测量本身会错时，改用探测器detector：比较同一条检查在相邻两轮的读数，只有「变了」才算事件。数据错误产生空间上分离的一对事件，测量错误产生时间上分离的一对事件。：比较同一条检查在相继两轮的结果。数据错误造出空间上分离的事件对；测量错误造出时间上分离的事件对；电路传播还会造出相关的小图案。于是译码在一个 2+1 维的探测器图里进行——详见译码器教程假警报与只报「变化」的探测器和两种指纹，一张时空图。

When measurements themselves err, switch to detectorsA detector compares the same check's outcome in two consecutive rounds; only a “change” counts as an event. Data errors make spacelike-separated event pairs, measurement errors timelike-separated pairs.: compare the same check's outcome in successive rounds. Data faults create spacelike-separated event pairs; measurement faults create timelike-separated pairs; circuit propagation can create correlated small patterns. Decoding then happens in a 2+1-dimensional detector graph — see the decoders guide on false alarms and change-only detectors and two fingerprints, one spacetime graph.

两点诚实提醒。第一，不是每个物理故障都必须点亮探测器：太晚发生的故障与下一轮的故障观测等价，无害的 Pauli 会抵消，有些故障只影响被追踪的观测量。正确的不变量是：探测器错误模型列出每种故障机制的可观测「探测器/逻辑」签名。第二，辅助比特的故障：在一次四邻居检查测量中，一个辅助比特上的 Pauli 可以通过后续 CNOT 传播成两个数据比特上的钩子错误hook error：一个辅助比特故障经 CNOT 传播后落在两个数据比特上的相关错误。若它的方向与最短逻辑方向一致，电路码距会低于静态码距。。若调度顺序让钩子与最短逻辑方向对齐，电路码距会下降，即使静态检查矩阵的码距仍是 d。静态码距与故障码距是两个不同的主张，必须分别验证——本教程第 2 章证明的只是前者。

Two honest reminders. First, not every physical fault must light a detector: a late fault is observationally equivalent to one in the next round, a harmless Pauli can cancel, and some faults affect only a tracked observable. The correct invariant is that the detector error model lists the observable detector/logic signature of every fault mechanism. Second, ancilla faults: during a four-neighbour check measurement, one Pauli on the ancilla can propagate through later CNOTs into a hook errorA correlated error on two data qubits produced when one ancilla fault propagates through CNOTs. If its direction aligns with the shortest logical, the circuit distance falls below the static distance. on two data qubits. A schedule that aligns hooks with a shortest logical direction reduces the circuit distance even though the static check matrix still has distance d. Static-code distance and fault distance are different claims and must be verified separately — Chapter 2 of this tutorial proved only the former.

把两块未旋转的 L=3 贴片并排放置：贴片 A 占 x = 0…4，贴片 B 占 x = 6…10，中间缺的一列 x = 5 是缝合线。按 1.3 节的坐标，x=4 与 x=6 是两块贴片的光边界（三腿 X 检查所在）。加入两个水平方向的缝合数据比特 (5,1) 与 (5,3)，制备在 |+⟩（X 值确定为 +1）。原来在边界上的三腿 X 星向缝合线延伸成四腿，其新增的 X 支撑落在 |+⟩ 的缝合比特上，贡献已知的 +1。然后测量三条新的 Z 面检查，中心在 (5,0)、(5,2)、(5,4)：

Place two unrotated L=3 patches side by side: patch A occupies x = 0…4, patch B occupies x = 6…10, and the missing column x = 5 is the seam. In §1.3's coordinates, x=4 and x=6 are the two patches' smooth boundaries (where the three-leg X-checks sit). Add two horizontal seam data qubits at (5,1) and (5,3), prepared in |+⟩ (X value fixed at +1). The old boundary three-leg X-stars extend across the seam to four legs; their new X support lands on the |+⟩ seam qubits and contributes a known +1. Then measure three new Z-plaquettes centred at (5,0), (5,2), (5,4):

写出三条缝合检查的支撑：(5,0) 连 (4,0)、(6,0)、(5,1)，三腿（下毛边界）；(5,2) 连 (4,2)、(6,2)、(5,1)、(5,3)，四腿；(5,4) 连 (4,4)、(6,4)、(5,3)，三腿。把三个测量结果相乘：缝合比特 (5,1) 出现在 (5,0) 与 (5,2) 两条里，(5,3) 出现在 (5,2) 与 (5,4) 两条里——各被 Z 碰两次，Z·Z = I，抵消。剩下的是：

Write out the three seam checks' supports: (5,0) joins (4,0), (6,0), (5,1), three legs (bottom rough boundary); (5,2) joins (4,2), (6,2), (5,1), (5,3), four legs; (5,4) joins (4,4), (6,4), (5,3), three legs. Multiply the three outcomes: seam qubit (5,1) appears in both (5,0) and (5,2), and (5,3) in both (5,2) and (5,4) — each is hit by Z twice, Z·Z = I, and cancels. What remains is:

左边三个 Z 是贴片 A 的 Z_L 的右列代表元（2.2 节：任何一列都等价），右边三个是贴片 B 的 Z_L 的左列代表元。所以三条局域检查读数的乘积，就是两个逻辑比特的联合 Z 奇偶。这就是格点手术的全部内容：拓扑把一个非局域的观测量变成一组可同时测量的局域检查的乘积（horsman2012surface，Horsman, Fowler, Devitt, Van Meter, “Surface code quantum computing by lattice surgery”, 2012）。对偶地，把毛边界贴在一起、缝合比特置 |0⟩、缝合检查用 X 星，测的就是 X_L⊗X_L。格点手术教程用同一个连乘讲了「测到奇偶、学不到内容」的含义，并在对偶一节做了毛边版本。

The three Z's on the left are the right-column representative of patch A's Z_L (§2.2: any column is equivalent), the three on the right the left-column representative of patch B's Z_L. So the product of three local check outcomes is the joint Z parity of two logical qubits. That is the whole content of lattice surgery: topology turns a nonlocal observable into a product of simultaneously measurable local checks (horsman2012surface, Horsman, Fowler, Devitt, Van Meter, “Surface code quantum computing by lattice surgery”, 2012). Dually, glue rough boundaries, prepare the seam qubits in |0⟩ and use X-stars as seam checks, and you measure X_L⊗X_L. The lattice-surgery guide uses the same product to explain “learn the parity, not the content”, and does the rough version in its duality section.

合并前，两块贴片共 13+13 = 26 个数据比特，各存一个逻辑比特，k=2。加两个缝合比特，n = 28。合并后独立检查有 12+12+3 = 27 条，所以 k = 28 − 27 = 1：测一次联合逻辑奇偶，恰好抹去一个逻辑自由度。合并后的整体不是别的，正是矩形超图乘积 HGP(rep₃, rep₆)：比特×比特块 3×6 = 18，检查×检查块 2×5 = 10，合计 28；H_X 有 2×6 = 12 行，H_Z 有 3×5 = 15 行，合计 27。reproduce.py 把这个矩形交给引擎精确求参，得到：

Before the merge, the two patches have 13+13 = 26 data qubits and store one logical qubit each, k=2. Add two seam qubits: n = 28. After the merge there are 12+12+3 = 27 independent checks, so k = 28 − 27 = 1: measuring one joint logical parity removes exactly one logical degree of freedom. The merged object is nothing but the rectangular hypergraph product HGP(rep₃, rep₆): bit×bit block 3×6 = 18, check×check block 2×5 = 10, total 28; H_X has 2×6 = 12 rows, H_Z has 3×5 = 15 rows, total 27. reproduce.py hands this rectangle to the engine for exact parameters and obtains:

注意 d = 3 而不是 6。水平方向的逻辑串变长了（要横跨 x = 0…10），竖直方向的逻辑串仍然只有 3 格（y = 0…4）。合并保持原来的空间码距，不会魔法般地把矩形变成距离 6。格点手术教程的重新记账一节对一般 d 做了同一笔账。

Note d = 3, not 6. The horizontal logical string grew (it must span x = 0…10), but the vertical one is still only 3 cells long (y = 0…4). The merge preserves the original spacelike distance; it does not magically turn the rectangle into distance six. The lattice-surgery guide's ledger section does the same accounting for general d.

如果唯一可能的故障是「每轮独立地翻转一次推断出的缝合奇偶」，那么重复测量再表决，就是一条时间方向的一维重复码，d 轮给出时间方向的码距 d。这个玩具约化不是完整的容错论证。真实的提取电路还有数据错误、辅助比特传播、以及跨越合并起点或终点的故障；它们在空间与时间上造出相关的探测事件，还可能改变「正在追踪的是联合逻辑观测量的哪个代表元」。所以合并期间的症状必须作为一段时空历史整体译码：跑 d 轮提供时间方向的码距，而把缝合探测器与体内探测器合起来推断逻辑奇偶的，是译码器，不是裸表决。格点手术教程在一次读错就够了与真相：不是表决，是时空译码两节里把这件事讲透了。

If the only possible fault were an independent flip of the inferred seam parity in each round, repeating the measurement and voting would be a one-dimensional repetition code in time, and d rounds would supply timelike distance d. That toy reduction is not the full fault-tolerance argument. Real extraction circuits also contain data faults, ancilla propagation, and faults crossing the start or end of the merge; they create correlated detection events in space and time, and can change which representative of the joint logical observable is being tracked. The merge syndrome must therefore be decoded as one spacetime history: running d rounds supplies timelike distance, and it is the decoder, not a bare majority rule, that combines seam and bulk detectors to infer the logical parity. The lattice-surgery guide covers this thoroughly in one misread is enough and the truth: not a vote but spacetime decoding.

出处的全名：dennis2002topological = Dennis, Kitaev, Landahl, Preskill, “Topological quantum memory” (2002)；wang2003confinement = Wang, Harrington, Preskill, “Confinement-Higgs transition in a disordered gauge theory and the accuracy threshold for quantum memory” (2003)；fowler2012surface = Fowler, Mariantoni, Martinis, Cleland, “Surface codes: Towards practical large-scale quantum computation” (2012)；google2024below = Google Quantum AI, “Quantum error correction below the surface code threshold” (2024)。

The provenance keys in full: dennis2002topological = Dennis, Kitaev, Landahl, Preskill, “Topological quantum memory” (2002); wang2003confinement = Wang, Harrington, Preskill, “Confinement-Higgs transition in a disordered gauge theory and the accuracy threshold for quantum memory” (2003); fowler2012surface = Fowler, Mariantoni, Martinis, Cleland, “Surface codes: Towards practical large-scale quantum computation” (2012); google2024below = Google Quantum AI, “Quantum error correction below the surface code threshold” (2024).

固定一个症状，某个逻辑类的概率是该类中全部错误链的概率之和。在随机键 Ising 模型的映射里，这个和是一个配分函数；最优译码在 Nishimori 线上比较各类的自由能。最小链译码器只比较能量（最短链的长度），丢掉了近乎退化的众多路径贡献的熵。所以这 0.6 个百分点的差距是同一个完美症状模型内部「译码器 / 统计力学」的区别，不是同一个数字的实验误差。这正是 3.3 节路径退化的数字后果，译码器教程在退化一节算过一个可以数出来的例子。

Fix a syndrome; the probability of a logical class is the sum over all error chains in that class. In the random-bond Ising mapping this sum is a partition function, and optimal decoding compares free energies on the Nishimori line. A minimum-chain decoder compares only energies (the length of the shortest chain) and discards the entropy contributed by the many nearly degenerate paths. So the 0.6-percentage-point gap is a decoder/statistical-mechanics distinction inside one perfect-syndrome model, not experimental uncertainty on one number. It is the numerical consequence of §3.3's path degeneracy; the decoders guide works a countable example in its degeneracy section.

加入带噪的症状比特，就多了一个时间方向，配对问题变成三维的匹配 / 规范问题（译码器教程第 5 章）。但现象学模型里的「每轮数据错误率」与「每轮测量比特翻转率」没有指定任何物理位置：没有制备、CNOT、空闲、泄漏、复位、读出。这个阈值对译码器物理很有价值，却不能与一个电路位置阈值直接比较。

Adding noisy syndrome bits creates a time direction and turns matching into a three-dimensional matching/gauge problem (Chapter 5 of the decoders guide). But the phenomenological “data error per round” and “measurement-bit flip per round” specify no physical locations: no preparation, CNOT, idle, leakage, reset or readout. The threshold is valuable for decoder physics yet cannot be compared directly with a circuit-location threshold.

Fowler 等人的模拟把 p 定义为每步的故障率，并明确使用每周期八步；文中「约 4% 每周期」是那个模型的换算。另一种六层电路也可以是合法的表面码调度，但不能把 Fowler 的八步换算直接贴到它身上——必须重建噪声账。归一化（每位置、每步、每轮、每周期、每单位时间）是账本的必填字段。

Fowler et al.'s simulation defines p per step and explicitly uses eight steps per cycle; the quoted “roughly four percent per cycle” is the conversion for that model. A different six-layer circuit may also be a valid surface-code schedule, but Fowler's eight-step conversion cannot be attached to it without rebuilding the noise accounting. Normalization (per location, step, round, cycle, or unit time) is a required field of the ledger.

对简单的独立噪声模型，低 p 时主导的逻辑失败机制需要 ⌈d/2⌉ 个故障，于是有经验公式（直觉教程曾在纸上推过）：

For simple independent models, the leading low-p logical failure mechanism needs ⌈d/2⌉ faults, motivating the empirical form (the intuition guide derived it on paper):

硬件的 Λ 是从完整的「器件 + 译码器」整体拟合出来的：Willow 报告 Λ = 2.14 ± 0.02，d=7 时每周期 0.143% ± 0.003%。它不应被等同于 p_th/p——前因子、关联噪声与非均匀性都混在里面。

Hardware Λ is fitted from the complete device-and-decoder stack: Willow reports Λ = 2.14 ± 0.02 and, at d=7, 0.143% ± 0.003% per cycle. It should not be identified with p_th/p — prefactors, correlated noise and heterogeneity are all folded in.

向 QEC-Bank 新增一个阈值时必须记录：① 数据错误信道；② 症状是完美、现象学还是由电路导出；③ 若适用，完整的电路位置约定；④ 译码器，以及它是否利用关联 / 退化；⑤ 归一化——每位置、每步、每轮、每周期或每单位时间。五个字段缺任何一个，数字只能留在文献扫描里，不得升格为面向读者的内容。译码器教程的「一个数字，五个限定项」用同一张清单。

When a new threshold is added to the QEC-Bank, record: ① the data-error channel; ② whether the syndrome is perfect, phenomenological or circuit-derived; ③ the complete circuit-location convention, if applicable; ④ the decoder, and whether it uses correlations/degeneracy; ⑤ the normalization — per location, step, round, cycle or unit time. Missing any of the five, the number stays in the literature sweep and is not promoted into reader-facing content. The decoders guide's “one number, five qualifiers” uses the same checklist.

下面的实验台就是「码容量」玩具：每轮每个比特独立地以概率 p 中一个错误，症状完美，用一个简单的匹配类译码器，对 d = 3、5、7 各跑成百上千轮，画出失败率曲线。它属于账本的前两行那个世界（完美症状），不属于后三行；而且它的译码器比最优差、也未必和文献里的最小重量匹配完全一样，所以交叉点只会落在「百分之几到 10%」这个带子里，不该被当成 10.9% 或 10.3% 的复现。看的是形状：低 p 时大码更好，高 p 时次序翻转。

The bench below is the “code-capacity” toy: each round every qubit independently suffers an error with probability p, the syndrome is perfect, a simple matching-type decoder runs, and d = 3, 5, 7 are each simulated for hundreds to thousands of rounds to draw the failure-rate curves. It lives in the world of the ledger's first two rows (perfect syndrome), not the last three; and its decoder is worse than optimal and not necessarily identical to the literature's minimum-weight matching, so the crossing lands somewhere in the “several percent to 10%” band and must not be read as a reproduction of 10.9% or 10.3%. Watch the shape: at low p bigger codes win, at high p the order flips.

回放整条推理链：开链奇偶矩阵的转置核为零 → 超图乘积给两块比特、两张对易且局域的检查矩阵、k=1（第 1 章）→ 一行一列给 d ≤ L，L 条不交的等价代表元给 d ≥ L，机器对 L=3、4 枚举、对 L=5 说 bounded（第 2 章）→ 症状 = H·e = 链的边界，零症状的横跨串是逻辑而非稳定子，译码在类之间二选一（第 3 章）→ 缝合检查连乘望远镜式地缩成 Z_L⊗Z_L，n=28、k=1、d=3，d 轮由时空译码而非表决消化（第 4 章）→ 五行阈值账，绝不跨行比较（第 5 章）。每一步都在 QEC-Bank 的「推导与指南」侧面有对应的页面：HGP 构造、码距证明、症状与译码、格点手术、阈值账本。

Replay the whole chain: the open chain's parity matrix has a zero transpose kernel → the hypergraph product gives two qubit blocks, two commuting local check matrices, and k=1 (Chapter 1) → a row and a column give d ≤ L, L disjoint equivalent representatives give d ≥ L, the machine enumerates L=3, 4 and says “bounded” at L=5 (Chapter 2) → syndrome = H·e = the chain's boundary, the zero-syndrome spanning string is a logical rather than a stabilizer, and decoding chooses between classes (Chapter 3) → seam checks telescope into Z_L⊗Z_L, n=28, k=1, d=3, and d rounds are digested by spacetime decoding rather than voting (Chapter 4) → a five-row threshold ledger, never compared across rows (Chapter 5). Each step has its page in the QEC-Bank “Derivations & guides” facet: HGP construction, distance proof, syndrome & decoding, lattice surgery, threshold ledger.

QEC-Bank 的直觉短文以八道问题收尾，用来检验读者是否真的掌握了这个条目。先自己答，再展开对照。Q3、Q7、Q8 涉及本教程未展开的内容（XZZX 变体、逻辑 H 与 T 门），答案给出链接。

The QEC-Bank intuition essay closes with eight questions meant to test whether a reader has really mastered this entry. Answer first, then unfold and compare. Q3, Q7 and Q8 touch material this tutorial did not develop (the XZZX variant, logical H and T); their answers link onward.