从环面平移到一罗存储器：
一次导览，一百四十四个坐标 From torus shifts to the gross memory:
one guided tour, one hundred forty-four coordinates

先把八站的题目抄下来，再看每一站在 tour.yaml 里带的 出处标签每一站的 origin 字段：kind 说这句话的可信方式（verified = 机器在这个仓库里现算并断言过；curated = 从一篇具体文献整理来的叙述，机器没有重算），method 或 ref 说具体是哪段代码、哪篇文献。。八站里七站是 verified，只有第 ⑦ 站是 curated——因为它说的是电路和阈值，而 QEC-Bank 的 BB 条目根本没有导出电路。

First copy down the eight stop titles, then look at the provenance labelThe origin field of each stop: kind says how the statement earns trust (verified = the machine recomputed and asserted it inside this repository; curated = a narrative organised from one specific paper, not recomputed), and method or ref names the exact code or paper. each carries in tour.yaml. Seven of the eight are verified; only stop ⑦ is curated — because it speaks about circuits and thresholds, and the QEC-Bank BB entry exports no circuit at all.

「高亮」一列里的数字是检查的编号：播放器把 72 条 X 检查排在前面（编号 0–71），72 条 Z 检查排在后面（编号 72–143），所以第 ③ 站高亮的「72」就是 Z 检查 0，第 ⑧ 站的「73」就是 Z 检查 1。这个顺序不是播放器定的，而是构造器导出文件里 focusByFilter: {all: 0, X: 0, Z: 72} 那一行定的；reproduce.py 逐字核对过它。说人话：播放器只是照着构造器给的清单点名，谁排第几、有几条腿，全由构造器说了算。

The numbers in the “highlight” column are check indices: the player lists the 72 X checks first (indices 0–71) and the 72 Z checks after them (72–143), so the “72” highlighted at stop ③ is Z check 0 and the “73” at stop ⑧ is Z check 1. The player did not choose this order; the constructor's export did, in the line focusByFilter: {all: 0, X: 0, Z: 72}, and reproduce.py checks it verbatim. In plain words: the player only calls the roll from the constructor's list; who comes in which position and with how many legs is entirely the constructor's decision.

第 ① 站的原话：「The gross view contains 72 sites in each of two interleaved data layers. All 144 coordinates and all check supports come from constructor.py; the drawing is not a hand-authored lattice.」拆开读。格点是一个 l × m = 12 × 6 的环面，共 72 个格子，格子用一对整数 (i, j) 标记，i 从 0 到 11，j 从 0 到 5。每个格子放两个数据比特，一个属于左层（layer 0），一个属于右层（layer 1）——这就是直觉教程3.1 节的「两层比特」。构造器给每个比特一个编号和一个平面坐标：

Stop ① verbatim: “The gross view contains 72 sites in each of two interleaved data layers. All 144 coordinates and all check supports come from constructor.py; the drawing is not a hand-authored lattice.” Unpack it. The lattice is an l × m = 12 × 6 torus with 72 sites, each labelled by a pair of integers (i, j), i from 0 to 11 and j from 0 to 5. Every site holds two data qubits, one in the left layer (layer 0) and one in the right layer (layer 1) — the “two layers” of the intuition guide's §3.1. The constructor gives each qubit an index and a planar coordinate:

说人话：先数左层，从 (0,0) 开始，先把 j 数完再进下一个 i——所以左层 (0,0) 是 0 号，(0,1) 是 1 号，(0,5) 是 5 号，(1,0) 是 6 号，(3,0) 是 18 号，(11,5) 是 71 号；然后右层从 72 号开始，右层 (0,3) 是 72 + 3 = 75 号，右层 (11,5) 是 143 号。反过来读也容易：给你一个编号 c，先看它是否 ≥ 72 定层，再用余数除以 6 得 i、取模 6 得 j。这条词典本篇要用几十次。

In plain words: count the left layer first, starting at (0,0), running through j before moving to the next i — so left (0,0) is index 0, (0,1) is 1, (0,5) is 5, (1,0) is 6, (3,0) is 18, (11,5) is 71; then the right layer starts at 72, right (0,3) is 72 + 3 = 75, right (11,5) is 143. Reading backwards is just as easy: given an index c, decide the layer by whether c ≥ 72, then divide the remainder by 6 for i and take it mod 6 for j. This dictionary will be used dozens of times on this page.

检查也有位置：每个格子配一条 X 检查和一条 Z 检查，X 检查的记号画在 (2i + 0.15, 2j + 0.15)，Z 检查画在 (2i + 0.4, 2j + 0.4)，所以一个格子里挤着四样东西：左层比特、X 记号、Z 记号、右层比特，沿对角线错开。导出文件还写明 layout.kind: periodic，基向量 (24, 0) 与 (0, 12)——意思是画到右边缘就从左边缘接回来，画到上边缘就从下边缘接回来：这是一个环面，不是一张有边的纸。

Checks have positions too: every site hosts one X check and one Z check, the X marker drawn at (2i + 0.15, 2j + 0.15) and the Z marker at (2i + 0.4, 2j + 0.4), so four things crowd each site — the left qubit, the X marker, the Z marker and the right qubit — staggered along the diagonal. The export also states layout.kind: periodic with basis vectors (24, 0) and (0, 12): reach the right edge and you re-enter from the left, reach the top and you re-enter from the bottom. This is a torus, not a sheet with edges.

回忆直觉教程的翻译词典：单项式 x^ay^b 是「把格子 (i, j) 平移到 (i + a, j + b)」的置换矩阵（每行、每列恰有一个 1 的 0/1 矩阵：第 s 行唯一的 1 所在的列，就是格子 s 被送到的地方），坐标超出范围就绕回mod l 与 mod m：i 数到 12 绕回 0，j 数到 6 绕回 0。环面上没有「出界」，只有绕回。。所以 H_X = [A | B] 的第 s 行（s 是格子 (i, j) 的编号 i·m + j）里，1 落在这些列上：A 的每一项 (a, b) 给出左层格子 (i + a, j + b) 的编号；B 的每一项 (a, b) 给出右层格子 (i + a, j + b) 的编号。项数就是腿数：gross 的 |A| = |B| = 3，所以每条 X 检查恰好六条腿，三条在左层、三条在右层。

Recall the intuition guide's translation dictionary: the monomial x^ay^b is the permutation matrix “move site (i, j) to (i + a, j + b)” (a 0/1 matrix with exactly one 1 in every row and every column: the column of the single 1 in row s is where site s is sent), wrapping aroundmod l and mod m: i counts up to 12 and wraps to 0, j counts up to 6 and wraps to 0. On a torus there is no “out of bounds”, only wrapping. when a coordinate runs off the end. So in row s of H_X = [A | B] (s is the index i·m + j of site (i, j)) the 1s sit in these columns: each term (a, b) of A gives the index of the left-layer site (i + a, j + b); each term (a, b) of B gives the index of the right-layer site (i + a, j + b). Term count equals leg count: gross has |A| = |B| = 3, so every X check has exactly six legs, three in the left layer and three in the right.

X 检查 0 在格子 (0, 0)。A = x³ + y + y² 的三项是 (3, 0)、(0, 1)、(0, 2)：从 (0, 0) 出发，往右三格到 (3, 0)，编号 3·6 + 0 = 18；往上一格到 (0, 1)，编号 1；往上两格到 (0, 2)，编号 2。B = y³ + x + x² 的三项是 (0, 3)、(1, 0)、(2, 0)，落在右层：往上三格 (0, 3)，编号 72 + 3 = 75；往右一格 (1, 0)，编号 72 + 6 = 78；往右两格 (2, 0)，编号 72 + 12 = 84。六个数字排好序：{1, 2, 18, 75, 78, 84}——与导览原话逐字相同，也是 reproduce.py 里那一行 assert np.flatnonzero(hx[0]).tolist() == [1, 2, 18, 75, 78, 84]。

X check 0 sits at site (0, 0). The three terms of A = x³ + y + y² are (3, 0), (0, 1), (0, 2): from (0, 0), three steps right to (3, 0), index 3·6 + 0 = 18; one step up to (0, 1), index 1; two steps up to (0, 2), index 2. The three terms of B = y³ + x + x² are (0, 3), (1, 0), (2, 0), landing in the right layer: three up to (0, 3), index 72 + 3 = 75; one right to (1, 0), index 72 + 6 = 78; two right to (2, 0), index 72 + 12 = 84. Sorted: {1, 2, 18, 75, 78, 84} — word for word the tour's sentence, and the line assert np.flatnonzero(hx[0]).tolist() == [1, 2, 18, 75, 78, 84] in reproduce.py.

导览让你把鼠标挪到旁边的检查上，看「被复制的平移」怎样变化。X 检查 1 在格子 (0, 1)，按同一条规则算出 {2, 3, 19, 76, 79, 85}——恰好是 X 检查 0 的每个编号加 1，因为整个形状往上挪了一格（j 加 1），六条腿一起挪。这就是平移不变：72 条 X 检查是同一个六腿形状的 72 份拷贝，只是起点不同（绕回边缘时编号会跳，见第 3 章）。到实验台上试：默认高亮的正是 X 检查 0，点任何一个橙色圆圈（X 检查）或蓝色方块（Z 检查）换一条检查，读数会告诉你它在哪个格子；画布下方的两行图例说明了哪种点是哪一层。

The tour asks you to hover a neighbouring check and watch “the copied translations” change. X check 1 sits at site (0, 1); the same rule gives {2, 3, 19, 76, 79, 85} — exactly X check 0 with every index increased by 1, because the whole shape moved one step up (j + 1) and all six legs moved with it. That is translation invariance: the 72 X checks are 72 copies of one six-leg shape with different starting points (indices jump when a leg wraps around the edge; see Chapter 3). Try it on the bench: the default highlight is X check 0; click any orange circle (X check) or blue square (Z check) to switch checks, and the readout names its site; the two legend lines under the canvas say which dots belong to which layer.

H_Z = [Bᵀ | Aᵀ]。两处变化：换位置——左层现在由 B 管、右层由 A 管；转置——直觉教程2.2 节证过 (x^ay^b)ᵀ = x^−ay^−b，即把每次平移倒过来走。所以 Z 检查 (i, j) 的腿是：B 的每一项 (a, b) 给左层格子 (i − a, j − b)，A 的每一项给右层格子 (i − a, j − b)。负数按 mod 12、mod 6 绕回：−1 ≡ 11，−2 ≡ 10，−3 ≡ 9（对 i）；−1 ≡ 5，−2 ≡ 4（对 j）。

H_Z = [Bᵀ | Aᵀ]. Two changes: the swap — the left layer is now governed by B and the right by A; the transpose — the intuition guide's §2.2 proved (x^ay^b)ᵀ = x^−ay^−b, i.e. every translation is walked backwards. So the legs of Z check (i, j) are: each term (a, b) of B gives the left-layer site (i − a, j − b), each term of A gives the right-layer site (i − a, j − b). Negatives wrap mod 12 and mod 6: −1 ≡ 11, −2 ≡ 10, −3 ≡ 9 (for i); −1 ≡ 5, −2 ≡ 4 (for j).

排好序：{3, 60, 66, 76, 77, 126}，与导览原话和 reproduce.py 的 assert np.flatnonzero(hz[0]).tolist() == [3, 60, 66, 76, 77, 126] 逐字相同。注意一个巧合和一个非巧合。巧合：y³ 倒着走仍是 y³，因为 m = 6 时 −3 ≡ 3，「往下三格」和「往上三格」在 6 格高的环面上是同一件事。非巧合：六条腿里有五条绕回了边缘（坐标 11、10、9、5、4 都是绕回来的），所以在画出来的格点上，Z 检查 0 的腿看起来「远远地伸向另一头」——那是环面在平面图上的假象，它们其实都只走了一到三格。

Sorted: {3, 60, 66, 76, 77, 126}, identical to the tour's sentence and to assert np.flatnonzero(hz[0]).tolist() == [3, 60, 66, 76, 77, 126] in reproduce.py. Note one coincidence and one non-coincidence. The coincidence: y³ walked backwards is still y³, because −3 ≡ 3 when m = 6; “three down” and “three up” are the same move on a torus six sites tall. The non-coincidence: five of the six legs wrap around the edge (the coordinates 11, 10, 9, 5, 4 are all wrapped), so on the drawn lattice Z check 0's legs seem to “reach far across to the other side” — an artefact of flattening a torus; each actually moves only one to three steps.

到实验台上把「A（正向平移）」切到「Aᵀ（反向平移）」，看三个箭头一起掉头。这个实验台默认是 6 × 6 的环面，把两个滑杆拉到 l = 12、m = 6 就是 gross 的尺寸；右侧的小方阵是 A 或 Aᵀ 的 72 × 72 矩阵，你点的那个起点对应被高亮的那一行——转置之后，同一行里 1 的位置换成了「谁平移到我这里」。

On the bench, switch “A (translations)” to “Aᵀ (reversed)” and watch all three arrows turn around. The bench opens on a 6 × 6 torus; drag the two sliders to l = 12, m = 6 for the gross size. The small square on the right is the 72 × 72 matrix of A or Aᵀ, and the source you click is the highlighted row — after the transpose, the 1s in that row mark “who translates onto me” instead.

直觉教程3.2 节用一行代数证明了 H_XH_Zᵀ = AB + BA = 0。这里换一个角度：直接数一对检查共享几个比特。取 X 检查 0 = {1, 2, 18, 75, 78, 84} 和 Z 检查 4（格子 (0, 4)），按 3.1 的规则算出 Z 检查 4 = {1, 64, 70, 74, 75, 130}。两者的公共比特是 {1, 75}——两个，偶数，对易 ✓。再看这两个公共比特各是怎么来的：

The intuition guide's §3.2 proved H_XH_Zᵀ = AB + BA = 0 in one line of algebra. Here is the other angle: count directly how many qubits a pair of checks shares. Take X check 0 = {1, 2, 18, 75, 78, 84} and Z check 4 (site (0, 4)); the rule of §3.1 gives Z check 4 = {1, 64, 70, 74, 75, 130}. The shared qubits are {1, 75} — two, even, commuting ✓. Now see where each shared qubit comes from:

看出规律了：左层的相遇是「A 的一项 + B 的一项 = 从 X 检查走到 Z 检查的位移」，右层的相遇是「B 的一项 + A 的一项 = 同一个位移」。两层各贡献一次同一个乘积——左层算的是 AB，右层算的是 BA，而 AB = BA（x、y 可交换）。于是在普通整数里，H_XH_Zᵀ 的每个元素要么是 0，要么是 2；模 2 后全部归零。对 gross 实例这不是比喻：整数乘积 H_XH_Zᵀ 里出现的数字只有 0 和 2，X 检查 0 恰与 3 × 3 = 9 条 Z 检查相遇（Z 检查 4、5、7、8、13、14、21、24、30），每一条都恰好共享 2 个比特——9 = |A|·|B| 个乘积项，每个出现两次。

The pattern: a left-layer meeting is “one term of A + one term of B = the displacement from the X check to the Z check”, a right-layer meeting is “one term of B + one term of A = the same displacement”. Each layer contributes one copy of the same product — the left layer computes AB, the right layer BA, and AB = BA (x and y commute). So over the ordinary integers every entry of H_XH_Zᵀ is 0 or 2; reduced mod 2, all vanish. For the gross instance this is not a figure of speech: the integer product H_XH_Zᵀ contains only the numbers 0 and 2, X check 0 meets exactly 3 × 3 = 9 Z checks (Z checks 4, 5, 7, 8, 13, 14, 21, 24, 30), and shares exactly 2 qubits with each — 9 = |A|·|B| product terms, each appearing twice.

第二行是换位置的理由：如果 Z 检查不交换 A、B，左层算的是 A·A、右层算的是 B·B，两块给出的是不同的矩阵，抵消不了。对 gross 的 A、B，A² + B² 确实不是零矩阵——这也是直觉教程3.2 节检查站的答案。reproduce.py 对交付的实例断言了两件事：hz == hstack([B.T, A.T])（Z 检查确实是交换后的转置），以及 (hx @ hz.T) % 2 全为零。

The second line is the reason for the swap: if the Z checks did not exchange A and B, the left layer would compute A·A and the right layer B·B — two different matrices that cannot cancel. For the gross A and B, A² + B² is indeed not the zero matrix — the answer to the intuition guide's §3.2 checkpoint. reproduce.py asserts both facts for the shipped instances: hz == hstack([B.T, A.T]) (the Z checks really are the swapped transposes) and that (hx @ hz.T) % 2 is all zeros.

toric_L3 的输入是 l = m = 3，A = 1 + x（项 (0, 0) 与 (1, 0)），B = 1 + y（项 (0, 0) 与 (0, 1)）。格子 9 个，比特 n = 2 × 9 = 18，编号规则不变：左层 (i, j) 是 3i + j，右层加 9。用第 2 章的读法算 X 检查 0（格子 (0, 0)）：A 的两项给左层 (0, 0) → 0 和 (1, 0) → 3；B 的两项给右层 (0, 0) → 9 和 (0, 1) → 10。支撑 {0, 3, 9, 10}，四条腿——第 ⑤ 站的原话：「The weight changes from six to four because sparsity follows the polynomial term count.」说人话：腿数就是项数，两项加两项等于四。Z 检查 0 按第 3 章的读法：Bᵀ 给左层 (0, 0) → 0 与 (0, −1) ≡ (0, 2) → 2；Aᵀ 给右层 (0, 0) → 9 与 (−1, 0) ≡ (2, 0) → 15。支撑 {0, 2, 9, 15}。构造器实际导出的两张矩阵（竖线左边 9 列是左层、右边 9 列是右层）：

toric_L3's inputs are l = m = 3, A = 1 + x (terms (0, 0) and (1, 0)), B = 1 + y (terms (0, 0) and (0, 1)). Nine sites, n = 2 × 9 = 18 qubits, the same indexing rule: left (i, j) is 3i + j, right adds 9. Chapter 2's rule for X check 0 (site (0, 0)): the two terms of A give left (0, 0) → 0 and (1, 0) → 3; the two terms of B give right (0, 0) → 9 and (0, 1) → 10. Support {0, 3, 9, 10}, four legs — stop ⑤ verbatim: “The weight changes from six to four because sparsity follows the polynomial term count.” In plain words: legs = terms, and two plus two is four. Z check 0 by Chapter 3's rule: Bᵀ gives left (0, 0) → 0 and (0, −1) ≡ (0, 2) → 2; Aᵀ gives right (0, 0) → 9 and (−1, 0) ≡ (2, 0) → 15. Support {0, 2, 9, 15}. The two matrices the constructor actually exports (the 9 columns left of the bar are the left layer, the 9 on the right the right layer):

第一行就是刚算的 {0, 3, 9, 10} 与 {0, 2, 9, 15}。每行恰四个 1；每列恰两个 1（每个比特被两条 X 检查、两条 Z 检查碰到）。把左层比特想成横边、右层比特想成竖边（图 4.1 之后的图 4.2 逐条画出这个对应），X 检查就是《从高考数学到 Toric Code》5.1 节的星形算符，Z 检查就是面算符——直觉教程5.1 节说的「BB(1 + x, 1 + y) 就是环面码」在这两张矩阵上是逐位成立的。

The first rows are exactly the {0, 3, 9, 10} and {0, 2, 9, 15} just computed. Every row has exactly four 1s; every column exactly two (each qubit meets two X checks and two Z checks). Think of left-layer qubits as horizontal edges and right-layer qubits as vertical edges (Figure 4.2, after Figure 4.1, draws this correspondence edge by edge), and the X checks are the star operators of “From High-School Math to the Toric Code”, §5.1, the Z checks the face operators — the intuition guide's §5.1 claim “BB(1 + x, 1 + y) is the toric code” holds bit for bit on these two matrices.

从错开的两层点到环面的边。图 4.1 画的是构造器的坐标：每个格子两个比特点。环面码的画法不同：比特在边上，检查在顶点和小方格上。把每个格子 (i, j) 看成环面码的一个顶点（格线的交叉点），对应规则只有两条：左层比特 (i, j)（编号 3i + j）是从顶点 (i − 1, j) 到 (i, j) 的那条横边；右层比特 (i, j)（编号 9 + 3i + j）是从顶点 (i, j − 1) 到 (i, j) 的那条竖边。坐标按 mod 3 算，所以 i = 0 的横边从顶点 (2, j) 绕回到 (0, j)。环面码里的星是连在一个顶点上的四条边，面是围成一个小方格的四条边。

From the two offset layers to the edges of the torus. Figure 4.1 draws the constructor's coordinates: two qubit dots per site. The toric code is drawn differently: qubits sit on edges, checks on vertices and small squares. Read each site (i, j) as a vertex of the toric code (a crossing of grid lines); then two rules give the correspondence: the left-layer qubit (i, j) (index 3i + j) is the horizontal edge from vertex (i − 1, j) to (i, j); the right-layer qubit (i, j) (index 9 + 3i + j) is the vertical edge from vertex (i, j − 1) to (i, j). Coordinates are taken mod 3, so the horizontal edge with i = 0 runs from vertex (2, j) around to (0, j). In the toric code a star is the four edges meeting at one vertex and a face is the four edges around one small square.

拿一颗星来验证。X 检查 (1, 1)：A = 1 + x 给左层 (1, 1) → 4 与 (2, 1) → 7，B = 1 + y 给右层 (1, 1) → 13 与 (1, 2) → 14。按规则，4 是顶点 (0, 1)–(1, 1) 之间的横边，7 是 (1, 1)–(2, 1)，13 是 (1, 0)–(1, 1) 之间的竖边，14 是 (1, 1)–(1, 2)：四条边都以顶点 (1, 1) 为端点，正是顶点 (1, 1) 的星。再验证一块面。Z 检查 (2, 2)：Bᵀ = 1 + y⁻¹ 给左层 (2, 2) → 8 与 (2, 1) → 7，Aᵀ = 1 + x⁻¹ 给右层 (2, 2) → 17 与 (1, 2) → 14。8 是 j = 2 那条上边，7 是 j = 1 那条下边，17 是 i = 2 那条右边，14 是 i = 1 那条左边：正好围成角点为 (1, 1) 与 (2, 2) 的小方格。一般地，X 检查 (i, j) 是顶点 (i, j) 的星，Z 检查 (i, j) 是右上角为顶点 (i, j) 的面。图 4.1 的 X 检查 0 = {0, 3, 9, 10} 也是一颗星（顶点 (0, 0) 的），只是其中 0 与 9 两条边绕过了边界；Z 检查 0 = {0, 2, 9, 15} 是右上角为 (0, 0) 的面，四条边都跨在边界上。

Check one star. X check (1, 1): A = 1 + x gives left (1, 1) → 4 and (2, 1) → 7, B = 1 + y gives right (1, 1) → 13 and (1, 2) → 14. By the rules, 4 is the horizontal edge between vertices (0, 1) and (1, 1), 7 joins (1, 1) and (2, 1), 13 is the vertical edge between (1, 0) and (1, 1), 14 joins (1, 1) and (1, 2): all four edges end at vertex (1, 1), so this is the star of vertex (1, 1). Now one face. Z check (2, 2): Bᵀ = 1 + y⁻¹ gives left (2, 2) → 8 and (2, 1) → 7, Aᵀ = 1 + x⁻¹ gives right (2, 2) → 17 and (1, 2) → 14. 8 is the top side at j = 2, 7 the bottom side at j = 1, 17 the right side at i = 2, 14 the left side at i = 1: together they surround the small square with corners (1, 1) and (2, 2). In general X check (i, j) is the star of vertex (i, j) and Z check (i, j) is the face whose top-right corner is vertex (i, j). X check 0 = {0, 3, 9, 10} of Figure 4.1 is also a star (of vertex (0, 0)); two of its edges, 0 and 9, wrap around the boundary. Z check 0 = {0, 2, 9, 15} is the face with top-right corner (0, 0), and all four of its edges straddle the boundary.

数字全部由机器现算：两张矩阵 9 × 18，秩各为 8（九行里有一条依赖——把九条 X 检查全乘起来是恒等，即环面码那条 ∏A = I 的恒等式，见同一教程 5.3 节），k = 18 − 8 − 8 = 2；QEC-Bank 的精确枚举器（方法名 exact-css-enum）穷举得 d = 3。所以 toric_L3 是 [[18,2,3]]，三个数字全部 verified。下面两个实验台：先用环面码的账本重数一遍 n、检查数与 k（第一个实验台打开时选的是 L = 3，即这里的 3 × 3 环面：18 条边 = 18 个比特，9 颗星、9 块面；点「逐颗相乘」看九颗星乘起来为什么是恒等），再在 BB 构造器里点这条四腿检查。

Every number is machine-computed: the two matrices are 9 × 18, each of rank 8 (one dependency among the nine rows — multiplying all nine X checks gives the identity, the toric code's ∏A = I identity of the same guide's §5.3), k = 18 − 8 − 8 = 2; the QEC-Bank exact enumerator (method name exact-css-enum) finds d = 3 by exhaustion. So toric_L3 is [[18,2,3]], all three numbers verified. Two benches follow: first recount n, the number of checks and k with the toric ledger (the first bench opens at L = 3, the 3 × 3 torus here: 18 edges = 18 qubits, 9 stars, 9 faces; press “multiply one by one” to see why the nine stars multiply to the identity), then click this four-leg check inside the BB constructor.

第 ④ 站的最后一句很谨慎：「This anchors the convention without reducing the gross block to toric copies.」两层意思。检验什么：约定。移位的方向（S 把第 i 格送到 i + 1 还是 i − 1）、转置有没有做、两块有没有交换、编号先数 j 还是先数 i——任何一处弄错，这个小例子都会立刻露馅：忘掉转置或两块不交换，H_XH_Zᵀ 就不为零——两个秩仍是 8 + 8，可这已经不是一个合法的 CSS 码。gross 太大，肉眼看不出这些错误；toric_L3 小到能和《从高考数学到 Toric Code》里的账本逐位比对。不检验什么：gross 码不是六份环面码拼起来的。k = 12 = 6 × 2 只是一个巧合的乘法，商空间 R/(A,B) 是 6 维（见第 5 章）并不意味着有 6 个互相独立的环面。文献里有两种相关但不同的说法：Sahay 等人用对称性把译码问题的一部分约化到环面状的圆柱上做匹配（sahay2026matching，据文献扫描报告，登记待补——意思是 QEC-Bank 的引文登记表里这篇还没有完整书目信息，题目与作者取自 QEC-Bank 自己的文献扫描报告），Chen 等人则在更一般的 BB 数据里发现「拓扑受挫」（chen2025anyon，同样登记待补）——前者是译码器的词典，后者说明有限 BB 码不能简单当作环面码的堆叠。这两条都记录在表示阶梯侧面里。

Stop ④ ends carefully: “This anchors the convention without reducing the gross block to toric copies.” Two layers of meaning. What it tests: conventions. The direction of the shift (does S send site i to i + 1 or i − 1), whether the transpose was applied, whether the two blocks were swapped, whether indices run through j first or i first — get any of these wrong and the small example gives you away at once: forget the transpose or skip the swap and H_XH_Zᵀ is nonzero — the ranks stay 8 + 8, but it is no longer a valid CSS code. Gross is too large to see such mistakes by eye; toric_L3 is small enough to compare bit by bit against the ledger in “From High-School Math to the Toric Code”. What it does not test: that the gross code is not six toric codes glued together. k = 12 = 6 × 2 is a coincidental multiplication; the quotient R/(A,B) having dimension 6 (Chapter 5) does not mean six independent tori exist. The literature holds two related but different statements: Sahay et al. use symmetries to reduce part of the decoding problem to toric-like cylinders where matching applies (sahay2026matching, from the scout report, registration pending: the QEC-Bank citation registry does not yet hold full bibliographic data for it, and the title and authors come from the QEC-Bank's own literature scan), while Chen et al. find “topological frustration” in more general BB data (chen2025anyon, also registration pending) — the former is a decoder dictionary, the latter says finite BB codes cannot simply be treated as stacks of toric codes. Both are recorded in the representation ladder facet.

H_X 有 72 行，但其中只有 66 行线性独立——rank H_X = 66，意思是有 6 条 X 检查可以由其他检查相乘得到，它们不提供新信息。H_Z 同样 rank = 66。直觉教程4.1 节证过两个秩必然相等（转置与改名不改变秩）。CSS 码的稳定子秩是两者之和 66 + 66 = 132，因为纯 X 的行与纯 Z 的行不可能互相抵消——reproduce.py 直接断言了 gf2.rank(checkmatrix.stab) == 132。于是 k = 144 − 132 = 12。（「k = n − 独立检查数」还要一个前提：没有哪几条检查的乘积等于 −I，否则没有状态能通过全部检查。CSS 码自动满足：全 X 的检查相乘仍是不带负号的全 X，全 Z 同理。）这里的 gf2.rank 就是第 ⑥ 站出处标签里的方法：在 GF(2) 上做高斯消元，机器现算。

H_X has 72 rows, but only 66 of them are linearly independent — rank H_X = 66, meaning 6 X checks are products of other checks and carry no new information. H_Z likewise has rank 66. The intuition guide's §4.1 proved the two ranks must be equal (transposing and renaming preserve rank). The CSS stabilizer rank is their sum, 66 + 66 = 132, because pure-X rows and pure-Z rows can never cancel each other — reproduce.py asserts gf2.rank(checkmatrix.stab) == 132 directly. So k = 144 − 132 = 12. (“k = n − number of independent checks” also needs one precondition: no product of checks may equal −I, or no state would pass them all. CSS codes satisfy it automatically: a product of all-X checks is again all-X with no minus sign, likewise for all-Z.) That gf2.rank is the method named in stop ⑥'s provenance label: Gaussian elimination over GF(2), recomputed by the machine.

对照环面锚点：那里 9 行只有 8 行独立，亏损 1，就是「所有星乘起来是恒等」那一条恒等式；gross 的亏损是 6，也就是有 6 条这样的恒等式，但它们不再有「全乘起来」这么简单的形状——它们是 R/(A,B) 这个 6 维商空间环 R = 所有 x、y 的多项式，按 x¹² = 1、y⁶ = 1 计算（即全部 72 × 72 的「平移组合」矩阵）。把 R 里所有形如 uA + vB 的多项式当成零之后剩下的空间，记 R/(A,B)；它的维数就是秩的亏损。直觉教程 4.2 节。的 6 个方向（直觉教程4.2 节）。reproduce.py 也断言了 torus_size − gf2.rank(hx) == 6。

Compare the toric anchor: there 9 rows have only 8 independent ones, deficit 1, which is the single identity “all stars multiply to the identity”; gross has deficit 6, so there are 6 such identities, but they no longer have the simple shape “multiply everything” — they are the 6 directions of the 6-dimensional quotient spaceThe ring R = all polynomials in x and y, computed with x¹² = 1, y⁶ = 1 (i.e. all 72 × 72 “combinations of translations”). What remains of R after every polynomial of the form uA + vB is set to zero, written R/(A,B); its dimension is the rank deficit. Intuition guide §4.2. R/(A,B) (intuition guide §4.2). reproduce.py also asserts torus_size − gf2.rank(hx) == 6.

第 ⑥ 站故意高亮 X 检查 1 而不是 0，让你看到「换一条检查，支撑变了」：X 检查 1 = {2, 3, 19, 76, 79, 85}，与 X 检查 0 的 {1, 2, 18, 75, 78, 84} 是同一个形状挪了一格。但秩没有变——秩不是某一条检查的性质，而是全部 72 条检查放在一起的性质：它们张成的空间有多少维。你在格点上无论盯着哪一条检查、哪个比特，都看不出 k；k 只能从 A、B 生成的理想ideal：环 R 里所有能写成 uA + vB 的多项式的集合。[A | B] 的像（所有能写成 [A | B] 乘某个向量的结果）就是它，秩就是它的维数。 (A, B) 占了 72 维里的多少维算出来。说人话：局部看形状，全局看秩。

Stop ⑥ deliberately highlights X check 1 rather than 0, so you see “change the check, the support changes”: X check 1 = {2, 3, 19, 76, 79, 85}, the same shape as X check 0's {1, 2, 18, 75, 78, 84} moved one step. But the rank did not change — rank is not a property of one check but of all 72 checks together: how many dimensions they span. Stare at whichever check or qubit on the lattice you like, k is invisible; it can only be computed from how many of the 72 dimensions the idealThe set of all polynomials in R of the form uA + vB. It is the image of [A | B] (everything of the form [A | B] times some vector), and the rank is its dimension. (A, B) generated by A and B occupies. In plain words: shape is local, rank is global.

最有说服力的证据是直觉教程5.5 节讲过的：把完全相同的 A、B 放到 9 × 6 的环面上（QEC-Bank 条目 bb108），每条检查的形状一模一样，还是六条腿，可秩亏损从 6 变成 4，k 从 12 掉到 8。形状没变，k 变了——因为 x⁹ = 1 与 x¹² = 1 是两个不同的环，同一对多项式在里面「占」的比例不同。在第 2 章的 BB 构造器上可以亲手看到：保持 gross 的两个多项式不动，把 l 的滑杆从 12 拉到 9，读数里每条检查仍是 6 条腿，k 却从 12 变成 8；或者在「A 的项」里只改一个指数：只要改完后 A 的三项在 mod 12、mod 6 之下仍互不相同，项数、腿数就都不变，k 却会跳。这个前提不能省：把 y 改成 y²，得到 A = x³ + y² + y²，两个 y² 相加为 0（1 + 1 = 0）而相消，A = x³，每条检查只剩 4 条腿。本篇的脚本在固定的 12 × 6 环面上逐个试过（B 不动）：只改 A 的一个指数、三项仍互不相同的 46 种改法里，k 只取 0、8、12；把 A 的一整项换成任意别的项（三项仍互不相同），k 只取 0、4、8、12。这些 k 值只针对 12 × 6 这一个环面。

The most convincing evidence is from the intuition guide's §5.5: put the identical A and B on a 9 × 6 torus (QEC-Bank entry bb108), every check has exactly the same shape, still six legs, yet the rank deficit drops from 6 to 4 and k from 12 to 8. Same shape, different k — because x⁹ = 1 and x¹² = 1 define two different rings, and the same pair of polynomials “occupies” a different share of each. You can see it yourself on Chapter 2's BB constructor: keep gross's two polynomials, drag the l slider from 12 to 9, and the readout still shows six legs per check while k drops from 12 to 8; or change a single exponent in “A terms”: as long as A's three terms stay distinct modulo 12 and 6, the term count and leg count stay the same, yet k jumps. The condition matters: changing y to y² gives A = x³ + y² + y², the two y² add to 0 (1 + 1 = 0) and cancel, so A = x³ and every check has only 4 legs. This guide's script tried every case on the fixed 12 × 6 torus (B unchanged): over the 46 single-exponent changes of A that keep three distinct terms, k is 0, 8 or 12; replacing one whole term of A by any other term (still three distinct terms), k is 0, 4, 8 or 12. These k values are for the 12 × 6 torus only.

第 ⑦ 站原话：「The explorer certifies stabilizer incidence only. It does not draw ancillas, CNOT order, detectors, or hook propagation. The reported depth-seven extraction and 0.8% family threshold belong to a separate standard-circuit-noise plus BP-OSD experiment.」说人话：你在屏幕上看到的每条腿，说的只是「这条检查碰这个比特」，没有说「什么时候碰、用哪个辅助比特碰、碰的顺序是什么、测出来的读数怎样组合成探测器」。这四件事合起来叫症状提取电路，QEC-Bank 的 BB 条目没有交付它。QEC-Bank 的推导页把缺的东西列成五条：

Stop ⑦ verbatim: “The explorer certifies stabilizer incidence only. It does not draw ancillas, CNOT order, detectors, or hook propagation. The reported depth-seven extraction and 0.8% family threshold belong to a separate standard-circuit-noise plus BP-OSD experiment.” In plain words: every leg on the screen says only “this check touches this qubit”, not “when it touches it, through which ancilla, in what order, or how the measured bits combine into detectors”. Those four things together are the syndrome-extraction circuit, and the QEC-Bank BB entry does not ship one. The QEC-Bank derivation page lists what is missing as five items:

所以要分清三种「距离」：静态码距（数据比特上最轻的非平凡逻辑 Pauli——gross 的 12，bounded）；电路码距（最小的不被探测却导致逻辑失败的故障集合——可以比 12 小，取决于调度）；译码器找到的失败重量（某个具体搜索或译码器找到的最小失败——找不到不等于不存在）。0.8% 的阈值和这三种距离都不是一回事：它是一整套实验流程的数字。Bravyi 等人的论文摘要（arXiv:2308.07915）原话是「an error threshold of 0.8% for the standard circuit-based noise model」，对象是他们那一族 BB 码，条件是标准电路噪声（每个门、空闲、制备、读出都可能出错）、他们的深度 7 电路与探测器构造、BP-OSD 译码器（置信传播加有序统计后处理），数值由模拟得到——直觉教程6.4 节的五个限定项，与《译码器 · 高中数学版》阈值账本规则同一套读法。播放器上没有任何一个像素与这五件事有关，所以第 ⑦ 站的标签是 curated：它是文献叙述，不是机器重算。

So keep three kinds of “distance” apart: the static code distance (the lightest nontrivial logical Pauli on the data qubits — gross's 12, bounded); the circuit distance (the smallest undetected fault set that causes a logical failure — it can be smaller than 12, depending on the schedule); and the decoder-found failure weight (the smallest failure some specific search or decoder found — not finding one does not mean none exists). The 0.8% threshold is none of these three: it is a number about a whole experimental pipeline. The abstract of Bravyi et al. (arXiv:2308.07915) says “an error threshold of 0.8% for the standard circuit-based noise model”, for their family of BB codes, under standard circuit noise (every gate, idle step, preparation and readout may fail), with their depth-7 circuit and detector construction and the BP-OSD decoder (belief propagation plus ordered-statistics post-processing), obtained from simulations — the five qualifiers of the intuition guide's §6.4, read with the same threshold-ledger rules as “Decoders · High-School Edition”. Not one pixel of the player concerns any of these five things, which is why stop ⑦ is labelled curated: literature narrative, not machine recomputation.

第 ⑧ 站高亮播放器编号 73，即 Z 检查 1（格子 (0, 1)）。按第 3 章的读法算它的支撑：{4, 61, 67, 72, 77, 127}。把它和 Z 检查 0 的 {3, 60, 66, 76, 77, 126} 并排放：3 → 4，60 → 61，66 → 67，76 → 77，126 → 127——每个编号加 1，就是每条腿往上挪一格（j + 1）；剩下那条 77 → 72：右层 (0, 5) 往上一格绕回 (0, 0)，编号从 77 跳到 72。六条腿一起挪，形状不变。这就是原话「Torus translations preserve these supports as a set」的意思：对所有 144 个比特同时做平移 y（两层各自的 (i, j) → (i, j + 1)），Z 检查 0 的支撑恰好变成 Z 检查 1 的支撑，Z 检查 1 变成 Z 检查 2……72 条检查只是被重新编号，作为一个集合一条也没多、一条也没少。X 检查同理。

Stop ⑧ highlights player index 73, i.e. Z check 1 (site (0, 1)). Chapter 3's rule gives its support: {4, 61, 67, 72, 77, 127}. Set it beside Z check 0's {3, 60, 66, 76, 77, 126}: 3 → 4, 60 → 61, 66 → 67, 76 → 77, 126 → 127 — each index plus 1, i.e. each leg moved one step up (j + 1); the remaining 77 → 72: right (0, 5) moved one up wraps to (0, 0), and the index jumps from 77 to 72. All six legs move together; the shape is unchanged. That is what “Torus translations preserve these supports as a set” means: translate all 144 qubits at once by y ((i, j) → (i, j + 1) in each layer) and the support of Z check 0 becomes exactly the support of Z check 1, Z check 1 becomes Z check 2, and so on. The 72 checks are merely renumbered; as a set, not one is added or lost. Likewise for the X checks.

写成矩阵，这就是 reproduce.py 里被断言的两条恒等式。令 P 是 72 × 72 的平移矩阵（x 或 y），对两层同时平移就是 144 × 144 的分块对角矩阵 diag(P, P)：

In matrix form, this is the pair of identities asserted in reproduce.py. Let P be the 72 × 72 translation matrix (x or y); translating both layers at once is the 144 × 144 block-diagonal matrix diag(P, P):

于是环面平移是码的自同构automorphism：把稳定子群映到自身的物理操作（这里是比特的一个置换）。它保证码空间不变，但对逻辑比特做了什么需要另算。。第 ⑧ 站的后半句才是重点：「That alone does not name a logical gate: the induced action on the twelve logical Pauli pairs and the routing cost must still be computed for the chosen block.」说人话：把 144 个比特整体挪一格，码空间确实回到自己。一个把稳定子群映回自身的比特置换，必然在 12 个逻辑比特上做某个 Clifford 操作（把每个逻辑 Pauli 变成另一个逻辑 Pauli 的操作，例如 H、S、CNOT；恒等也算一种）。问题是哪一个：上面的矩阵恒等式只证明码空间不变，算不出它对 24 个逻辑 Pauli（12 对 X̄、Z̄）的作用；导览和 QEC-Bank 的证书都没有算这一步，所以在 QEC-Bank 里，它的具体逻辑作用和实现代价都还是「未计算」。文献里算过：Bravyi 等人（arXiv:2308.07915 v2，9.2 节「Logical Gates based on Automorphisms」）选了一组以单项式编号的逻辑算符，平移 s 把编号为 n 的 X̄ 换成编号为 s·n 的 X̄（Z̄ 同理），于是每个平移都是一个逻辑 CNOT 电路（最多差一个逻辑 Pauli 修正）；作者还写道除 s = 1 外没有哪个平移作用成逻辑恒等，但对 gross 这一句不成立：逐一检验 72 个平移对全部逻辑 X̄、Z̄ 的作用，x⁶（沿长为 12 的方向平移半圈）作用成逻辑恒等，其余 70 个非恒等平移都作用非平凡（检验方法见直觉教程 6.5 节）。作者也说，还不清楚怎样把这些 CNOT 用于有用的计算。而且「挪一格」在真机上是把每个比特搬到邻居的位置，或者等价地把 144 根连线全部重接——布线代价要另算。QEC-Bank 因此只把它记为物理自同构（verified），不记为逻辑操作；直觉教程6.5 节说的正是这件事，逻辑操作侧面（逻辑操作）记录的五条操作全部是 claimed。

So torus translations are automorphismsA physical operation (here a permutation of qubits) that maps the stabilizer group to itself. It guarantees the code space is preserved, but what it does to the logical qubits must be computed separately. of the code. The second half of stop ⑧ is the point: “That alone does not name a logical gate: the induced action on the twelve logical Pauli pairs and the routing cost must still be computed for the chosen block.” In plain words: shift all 144 qubits one step and the code space does return to itself. A qubit permutation that maps the stabilizer group to itself necessarily performs some Clifford operation on the 12 logical qubits (an operation that turns every logical Pauli into another logical Pauli, such as H, S, CNOT; the identity counts too). The question is which one: the matrix identity above proves only that the code space is preserved and cannot give the action on the 24 logical Paulis (12 pairs X̄, Z̄). Neither the tour nor the QEC-Bank certificates compute that step, so in the QEC-Bank its specific logical action and implementation cost remain uncomputed. The literature has computed it: Bravyi et al. (arXiv:2308.07915 v2, section 9.2 “Logical Gates based on Automorphisms”) choose logical operators labelled by monomials; a translation s turns the X̄ labelled n into the X̄ labelled s·n (likewise for Z̄), so every translation is a logical CNOT circuit (up to a logical Pauli correction); the authors also write that no translation other than s = 1 acts as the logical identity, but for gross that does not hold: checking all 72 translations on every logical X̄ and Z̄ shows that x⁶ (a half-turn along the direction of length 12) acts as the logical identity, while the other 70 nonidentity translations have a nontrivial logical action (the check is described in §6.5 of the intuition guide). The authors add that it is not yet clear how to use these CNOTs for useful computation. And “one step” on real hardware means moving every qubit to its neighbour's place, or equivalently rewiring all 144 connections — a routing cost to be accounted separately. The QEC-Bank therefore records it only as a physical automorphism (verified), not as a logical operation; the intuition guide's §6.5 says exactly this, and all five operations recorded in the operations facet (logical operations) are claimed.

回放整条论证：12 × 6 的环面、每格两个比特，编号 layer·72 + i·6 + j，坐标 (2i + 0.55·layer, 2j + 0.55·layer)，共 144 个（①）→ X 检查 (i, j) 的腿 = A 的每一项加到格子上给左层、B 的每一项给右层：X 检查 0 = {1, 2, 18} ∪ {75, 78, 84}，重量 3 + 3 = 6（②）→ Z 检查用 [Bᵀ | Aᵀ]：每个指数取负、两块换位置，Z 检查 0 = {3, 60, 66, 76, 77, 126}；左层算 AB、右层算 BA，整数重叠只有 0 和 2（③）→ 同一个构造器换四个输入得 toric_L3：四腿、9 × 18、秩 8、k = 2、穷举 d = 3，锁死约定但不把 gross 拆成环面（④⑤）→ 72 行秩 66，亏损 6，k = 2 × 6 = 12，悬停换检查不换秩（⑥）→ 图上只有关联，电路、探测器、0.8% 在图外（⑦）→ 平移置换检查行，是自同构；它的逻辑作用（Bravyi 等人算出是逻辑 CNOT 电路）不在导览的验证之内（⑧）。七站 verified，每个数字都能用 reproduce.py 重算；一站 curated，说的正是机器没算的那部分。

Replay the whole argument: a 12 × 6 torus, two qubits per site, index layer·72 + i·6 + j, coordinate (2i + 0.55·layer, 2j + 0.55·layer), 144 in all (①) → the legs of X check (i, j) = each term of A added to the site for the left layer, each term of B for the right: X check 0 = {1, 2, 18} ∪ {75, 78, 84}, weight 3 + 3 = 6 (②) → Z checks use [Bᵀ | Aᵀ]: every exponent negated, the two blocks swapped, Z check 0 = {3, 60, 66, 76, 77, 126}; the left layer computes AB, the right BA, and the integer overlaps are only 0 and 2 (③) → the same constructor with four different inputs gives toric_L3: four legs, 9 × 18, rank 8, k = 2, exhaustive d = 3, pinning the conventions without splitting gross into tori (④⑤) → 72 rows of rank 66, deficit 6, k = 2 × 6 = 12, hovering changes the check but not the rank (⑥) → the picture holds incidence only; circuits, detectors and 0.8% lie outside it (⑦) → translations permute check rows: an automorphism, whose logical action (a logical CNOT circuit, computed by Bravyi et al.) lies outside what the tour verifies (⑧). Seven stops verified, every number recomputable with reproduce.py; one stop curated, speaking of precisely the part the machine did not compute.