两张测量时间表
是不是同一回事 Are two measurement schedules
the same thing?

记号：n = 物理比特数，k = 逻辑比特数，r = 独立检查条数（Toric Code 教程 4.4 节里叫「秩」），L = 环面边长，⊕ = 不进位加法。

Notation: n = number of physical qubits, k = number of logical qubits, r = number of independent checks (the “rank” of section 4.4 of the toric-code guide), L = side length of the torus, ⊕ = addition without carry.

四个比特 a、b、c、d，每个是 0 或 1，要算它们的奇偶 a ⊕ b ⊕ c ⊕ d。一台只会两个数相加的机器，得分步做，而分步的顺序有很多种：

Four bits a, b, c, d, each 0 or 1; compute their parity a ⊕ b ⊕ c ⊕ d. A machine that can only add two numbers must proceed in steps, and the order of steps can vary:

记号：a、b、c、d = 四个比特的值（0 或 1）；括号 = 先算谁；⊕ = 不进位加法（第 0 章事实 1）。

Notation: a, b, c, d = the values of the four bits (0 or 1); parentheses = what is computed first; ⊕ = addition without carry (fact 1 of Chapter 0).

三种算法给出同一个答案吗？最笨的办法：把 a、b、c、d 的全部 2⁴ = 16 种取值代进去，逐个比。可行，但 40 个比特就是 2⁴⁰ ≈ 10¹² 种，笨办法就死了。聪明的办法是规则。⊕ 只满足两条：

Do the three procedures give the same answer? The dumb way: substitute all 2⁴ = 16 assignments of a, b, c, d and compare one by one. Feasible, but at 40 bits that is 2⁴⁰ ≈ 10¹² assignments and the dumb way dies. The clever way is rules. ⊕ obeys exactly two:

记号：x、y、z = 任意三个 0/1 值（可以本身是括号里的算式）。R1 代入 x、y 的 4 种取值、R2 代入 x、y、z 的 8 种取值就能验证。

Notation: x, y, z = any three 0/1 values (each may itself be a bracketed expression). R1 is verified by the 4 assignments of x, y, and R2 by the 8 assignments of x, y, z.

现在从甲出发，一步只用一条规则：((a ⊕ b) ⊕ c) ⊕ d ＝_R2 (a ⊕ b) ⊕ (c ⊕ d)，这是乙，一步到。再从乙到丙，六步：(a ⊕ b) ⊕ (c ⊕ d) ＝_R2 a ⊕ (b ⊕ (c ⊕ d)) ＝_R1 a ⊕ ((c ⊕ d) ⊕ b) ＝_R2 a ⊕ (c ⊕ (d ⊕ b)) ＝_R1 a ⊕ ((d ⊕ b) ⊕ c) ＝_R2 a ⊕ (d ⊕ (b ⊕ c)) ＝_R2 (a ⊕ d) ⊕ (b ⊕ c)，这是丙。每一步只用了 R1 或 R2 中的一条，请逐步核对。这条链就是「甲、乙、丙是同一回事」的证明：不需要代 16 种值，任何人都能一步一步检查。

Now start from A, one rule per step: ((a ⊕ b) ⊕ c) ⊕ d =_R2 (a ⊕ b) ⊕ (c ⊕ d), which is B, in one step. From B to C, six steps: (a ⊕ b) ⊕ (c ⊕ d) =_R2 a ⊕ (b ⊕ (c ⊕ d)) =_R1 a ⊕ ((c ⊕ d) ⊕ b) =_R2 a ⊕ (c ⊕ (d ⊕ b)) =_R1 a ⊕ ((d ⊕ b) ⊕ c) =_R2 a ⊕ (d ⊕ (b ⊕ c)) =_R2 (a ⊕ d) ⊕ (b ⊕ c), which is C. Each step uses exactly one of R1, R2; check them one by one. This chain is the proof that A, B and C are the same thing: no 16 substitutions needed, and anyone can check it step by step.

QEC-Bank 的 Python 库里，一张时间表Schedule（qeclib/schedule.py）：Schedule(n, rounds)，rounds 是「一轮一轮」的列表，每一轮是一列泡利串；validate() 要求同一轮内两两对易。文件头注释：“Static codes are the period-1 special case.”就是 Schedule(n, rounds)：n 个比特，加上一份「轮次列表」，每一轮是这一轮要测的一列泡利串；validate() 只要求同一轮里的串两两对易（第 0 章事实 2），不同轮之间可以反对易。文件开头一句话：“Static codes are the period-1 special case.”——静态码就是只有一轮、反复放映的时间表。所以环面码 L = 3 的时间表是：

In the QEC-Bank Python library a scheduleSchedule (qeclib/schedule.py): Schedule(n, rounds), where rounds is a list of rounds, each a list of Pauli strings; validate() requires pairwise commutation within a round. The file's header comment: “Static codes are the period-1 special case.” is Schedule(n, rounds): n qubits plus a “list of rounds”, each round the list of Pauli strings measured in it; validate() only requires strings within one round to commute pairwise (fact 2 of Chapter 0), while different rounds may anticommute. The file opens with “Static codes are the period-1 special case.”: a static code is a one-round schedule played on repeat. So the toric code's schedule for L = 3 is:

而 QEC-Bank 的蜂窝码条目（honeycomb，本题 yaml 的 related 唯一一项）是真正的多轮时间表。它的登记原话（codes/honeycomb/card.yaml 的 description）：“A period-three dynamical stabilizer memory made only from weight-two Pauli measurements on a honeycomb torus. Edge operators are fixed as XX, YY, or ZZ by direction, while a plaquette three-coloring partitions them into three perfect-matching rounds. The code is the ordered schedule and its outcome-dependent instantaneous stabilizer group, not any one static set of mutually commuting edge checks; after startup that group carries two toric-code logical qubits.” 人话：比特住在蜂窝格的顶点上；每条边是一对相邻比特，按边的方向测 XX、YY 或 ZZ（两比特的检查，重量 2）；把六边形涂成三色，每条边按「它两侧六边形缺的那个颜色」分到第 0、1、2 轮；每一轮里的边两两不相邻（完美匹配perfect matching：一组边，每个顶点恰好被其中一条边碰到。这保证同一轮的检查支撑互不相交，因而两两对易。），所以同一轮的测量两两对易。最小实例 L3x3：n = 18，每轮 9 条两比特测量（3 条 XX、3 条 YY、3 条 ZZ）。

The QEC-Bank honeycomb entry (honeycomb, the only item in this yaml's related) is a genuinely multi-round schedule. Its registered description (codes/honeycomb/card.yaml): “A period-three dynamical stabilizer memory made only from weight-two Pauli measurements on a honeycomb torus. Edge operators are fixed as XX, YY, or ZZ by direction, while a plaquette three-coloring partitions them into three perfect-matching rounds. The code is the ordered schedule and its outcome-dependent instantaneous stabilizer group, not any one static set of mutually commuting edge checks; after startup that group carries two toric-code logical qubits.” In plain words: qubits live on the vertices of a honeycomb; each edge is a pair of neighbouring qubits measured as XX, YY or ZZ by direction (a two-qubit check, weight 2); colour the hexagons with three colours and assign each edge to round 0, 1 or 2 by “the colour missing from its two neighbouring hexagons”; within a round no two edges share a vertex (a perfect matchingA set of edges touching every vertex exactly once. It guarantees the checks of one round have disjoint supports, hence commute pairwise.), so the measurements of one round commute. The smallest instance L3x3: n = 18, 9 two-qubit measurements per round (3 XX, 3 YY, 3 ZZ).

图注：同一块 7 个六边形的蜂窝片画了两遍。比特在顶点上，每条边是一次两比特测量。左图边上的数是它在「按颜色分轮」下属于第几轮：例如标 0 的边，两侧是 B、C 两色的六边形，它两端伸向的是 A 色六边形。同一个数的边从不共用顶点，所以同一轮的测量两两对易。右图标的是每条边测什么：竖边 ZZ，两种斜边分别 XX、YY（哪个方向配哪个字母是约定，这里只是一种画法）。对照两图可以看到，每一轮里三种字母都有；1.3 节第 ③ 行的「按方向分轮」，就是改成按右图的字母分轮。边缘上的边只画出了一部分邻居。本篇用一段脚本检查过图里的这三点：三染色合法、每轮是匹配、每轮三种字母都有。

Caption: the same patch of 7 hexagons, drawn twice. Qubits sit on the vertices; each edge is one two-qubit measurement. On the left, the number on an edge is its round under the colour rule: an edge marked 0, for instance, has a B hexagon and a C hexagon beside it, and its two ends point into A hexagons. Edges with the same number never share a vertex, so the measurements of one round commute. On the right, each edge shows what it measures: vertical edges ZZ, the two slanted directions XX and YY (which direction gets which letter is a convention; this is one way to draw it). Comparing the two, every round contains all three letters; the “split by direction” of row ③ in 1.3 regroups the rounds by the letters on the right. Edges on the rim show only part of their neighbourhood. A script written for this guide checks those three facts in the figure: the 3-colouring is proper, each round is a matching, each round has all three letters.

不同轮的两条边若共用一个顶点，两个都不是 I 且字母不同（比如 XX 和 YY 在共用比特上是 X 与 Y），只有 1 个这样的位置——反对易。按第 0 章事实 3，测了第 1 轮就会抹掉第 0 轮的一部分信息。那么「码」在哪里？在瞬时稳定子群ISG, instantaneous stabilizer group：此刻状态满足的全部检查（含它们的乘积），每条带 + 或 − 号。理想测量（不出错）每测一条串 P 就按三种情况更新：(a) P 或 −P 已在群里 → 结果是确定的，由群里那条的符号决定，群不变；(b) P 与所有现有检查对易、但 P 和 −P 都不在群里 → 把 P 带上测得的符号加进去，结果 ±1 各有一半概率；(c) P 与某些现有检查反对易 → 挑其中一条当枢轴，把其它反对易的都乘上枢轴（乘完就与 P 对易了），再用带测得符号的 P 替换枢轴，条数不变。里：此刻状态满足的全部检查。三种情况 (a)、(b)、(c) 在弹窗里（出处：Hastings–Haah，arXiv:2107.02194，1.3 节）；下面马上用一个六比特的例子走一遍。QEC-Bank 的 ISGTracker 按这三条逐条更新，并记下每轮结束时独立检查的条数 r。蜂窝码 L3x3 从空清单出发的 r 依次是：

Two edges of different rounds sharing a vertex carry two different non-identity letters there (say X and Y for XX and YY), exactly 1 such position: they anticommute. By fact 3 of Chapter 0, measuring round 1 erases part of round 0's information. So where is the “code”? In the instantaneous stabilizer groupISG: all checks (and their products) the current state satisfies, each with a + or − sign. An ideal (error-free) measurement of a string P updates it in one of three ways: (a) P or −P is already in the group → the outcome is certain, fixed by that element's sign, and the group is unchanged; (b) P commutes with every current check but neither P nor −P is in the group → append P with the measured sign; the outcomes ±1 are equally likely; (c) P anticommutes with some current checks → pick one of them as pivot, multiply the other anticommuting ones by the pivot (they then commute with P), and replace the pivot by P with the measured sign; the count stays the same.: everything the state satisfies right now. The three cases (a), (b), (c) are in the tooltip (source: Hastings and Haah, arXiv:2107.02194, section 1.3); a six-qubit example below walks through them. The QEC-Bank ISGTracker updates the group string by string with these rules and records the number r of independent checks after each round. For honeycomb L3x3, starting from an empty list, r runs:

记号：r = 该轮结束时瞬时稳定子群里独立检查的条数；dynamic_k = n − 稳定后的 r，「整部电影放完还活着的逻辑比特数」。数字出自 codes/honeycomb/pedagogy/schedule-isg-cycle.md；instances.yaml 登记 L3x3：n = 18 verified，k = 2 verified，dynamic_k = 2 verified。

Notation: r = number of independent checks in the ISG at the end of the round; dynamic_k = n − the settled r, “the logical qubits still alive after the whole film”. Numbers from codes/honeycomb/pedagogy/schedule-isg-cycle.md; instances.yaml registers L3x3: n = 18 verified, k = 2 verified, dynamic_k = 2 verified.

先在一个六边形上手算。取一个六边形的 6 个顶点，从顶上顺时针编号 1 到 6，只看它的 6 条边（下图）。字母按方向：e₁₂ 和 e₄₅ 是 XX，e₂₃ 和 e₅₆（两条竖边）是 ZZ，e₃₄ 和 e₆₁ 是 YY；实线三条 e₁₂、e₃₄、e₅₆ 属第 0 轮，虚线三条 e₂₃、e₄₅、e₆₁ 属第 1 轮。第 0 轮测完，三条实线边互不相交、两两对易，按情况 (b) 各加一条：清单 = {X₁X₂, Y₃Y₄, Z₅Z₆}。现在逐条测第 1 轮，每一步都按弹窗的规则做：

First, by hand on one hexagon. Take the 6 vertices of one hexagon, numbered 1 to 6 clockwise from the top, and look only at its 6 edges (figure below). Letters by direction: e₁₂ and e₄₅ are XX, e₂₃ and e₅₆ (the two vertical edges) are ZZ, e₃₄ and e₆₁ are YY; the three solid edges e₁₂, e₃₄, e₅₆ belong to round 0, the three dashed edges e₂₃, e₄₅, e₆₁ to round 1. After round 0 the three solid edges are disjoint and commute pairwise, so case (b) appends each: list = {X₁X₂, Y₃Y₄, Z₅Z₆}. Now measure round 1 one string at a time, following the tooltip's rules at every step:

三条第 0 轮的边都被顶掉了，但它们的乘积 X₁X₂Y₃Y₄Z₅Z₆ 活了下来：这就是「替换」丢掉的只是与新测量冲突的那部分信息。再乘上三条第 1 轮的边，得到六边形算符 W = (X₁X₂Y₃Y₄Z₅Z₆)(Z₂Z₃)(X₄X₅)(Y₆Y₁)，逐比特相乘（不计符号），它是 Z₁Y₂X₃Z₄Y₅X₆，与这个六边形周围的每条边都对易。它的 ±1 取值是六个测得结果的乘积：四个因子两两对易，状态同时通过它们。清单从 3 条变成 4 条：多出来的一条就是六边形。

All three round-0 edges were pushed out, but their product X₁X₂Y₃Y₄Z₅Z₆ survived: replacement discards only the part of the information that clashes with the new measurement. Multiplying in the three round-1 edges gives the hexagon operator W = (X₁X₂Y₃Y₄Z₅Z₆)(Z₂Z₃)(X₄X₅)(Y₆Y₁); multiplied qubit by qubit (ignoring the sign) it is Z₁Y₂X₃Z₄Y₅X₆, and it commutes with every edge around this hexagon. Its ±1 value is the product of the six measured outcomes: the four factors commute pairwise and the state passes each of them. The list grew from 3 to 4 entries, and the extra one is the hexagon.

再数整张 L3x3。L3x3 有 9 个六边形，每种颜色 3 个。一条边的轮次是它两侧六边形都不是的那个颜色，所以一个颜色为 c 的六边形，边界上的 6 条边都不属于第 c 轮，而是另外两轮各 3 条交替出现。于是：

Now count the whole L3x3. L3x3 has 9 hexagons, 3 of each colour. An edge's round is the colour of neither hexagon beside it, so a hexagon of colour c has no round-c edge on its boundary: its 6 boundary edges alternate between the other two rounds, 3 each. Hence:

两条依赖为什么成立，都能手数。① 每条边夹在两个六边形之间，所以 9 个六边形之积里每条边出现两次，两次抵消，积为 I。② 每个顶点连着三条边，方向各不相同，所以 XX、YY、ZZ 各一条；全部 27 条边之积在每个顶点上是 X·Y·Z，只差一个符号就是 I。一个色 t 的六边形的边界边都不属第 t 轮，而每条不属第 t 轮的边恰好贴着一个色 t 的六边形，所以 3 个色 t 六边形之积 = 所有不属第 t 轮的边之积；再由 ②，它等于第 t 轮 9 条边之积（不计符号）。从第 3 轮起，每轮只是新一轮的边顶替上一轮的边，9 个六边形一直留着，r 停在 16：18 个比特，16 条独立检查，还剩 2 个逻辑比特，和环面码一样。这与 Hastings–Haah（arXiv:2107.02194，1.3 节）的一般计数一致：n_p 个六边形的环面上稳定后有 2n_p − 2 条独立检查，这里 n_p = 9，得 16。本篇的检验脚本也逐条模拟了这几轮，得到同样的 9、12、14、16。这就是「时间表是码」的意思：码的 k 不是任何一轮的性质，而是整部电影放完以后的性质。

Both dependencies can be checked by counting. ① Every edge lies between two hexagons, so in the product of all 9 hexagons each edge appears twice and cancels: the product is I. ② Every vertex meets three edges in three different directions, so one XX, one YY and one ZZ; the product of all 27 edges is X·Y·Z at every vertex, which is I up to a sign. A colour-t hexagon has no round-t edge on its boundary, and every edge outside round t touches exactly one colour-t hexagon, so the product of the 3 colour-t hexagons equals the product of all edges outside round t; by ② this equals the product of the 9 round-t edges (up to sign). From round 3 on, each round's edges just replace the previous round's, the 9 hexagons stay, and r stays at 16: 18 qubits, 16 independent checks, 2 logical qubits left, as in the toric code. This matches the general count of Hastings and Haah (arXiv:2107.02194, section 1.3): on a torus with n_p hexagons the settled group has 2n_p − 2 independent checks, here n_p = 9, giving 16. This guide's check script also simulated these rounds string by string and got the same 9, 12, 14, 16. That is what “the schedule is the code” means: the code's k is not a property of any single round but of the whole film once played.

现在给蜂窝码的时间表换几件「衣服」，看哪些是同一回事、哪些不是。三个候选，前两个能用第 0 章的事实判断，第三个 QEC-Bank 自己算过：

Now dress the honeycomb schedule in a few different “clothes” and ask which are the same thing and which are not. Three candidates; the first two can be judged with Chapter 0's facts, the third the QEC-Bank has computed itself:

第 ③ 行是这一篇的核心例子。QEC-Bank 推导页的原话：“The wrong sequence is not a small convention change; it preserves an extensive collection of logical degrees of freedom instead of the two toric logicals.”（错误的次序不是小小的约定差异；它保住了一大批逻辑自由度，而不是环面码的那两个。）两张时间表的每一轮都通过同样的局部检查（完美匹配、与六边形乘积对易），把任何一帧单独拿出来都分不出好坏；差别只在整部电影：一张剩 2 个逻辑比特，一张剩 20 个。所以「两张时间表是不是同一回事」不能逐帧判断，必须看整个序列。反过来，① 和 ② 又说明，看整个序列时还得允许「晚一秒开始」和「换衣服」这些无害的改动。规则该允许什么、禁止什么，就是 1.1 节说的语义。板上的原文：

Row ③ is the central example of this guide. The QEC-Bank derivation page's own words: “The wrong sequence is not a small convention change; it preserves an extensive collection of logical degrees of freedom instead of the two toric logicals.” Every round of both schedules passes the same local checks (perfect matching, commuting with the hexagon products); no single frame taken alone tells good from bad; the difference lies only in the whole film: one keeps 2 logical qubits, the other 20. So “are two schedules the same thing?” cannot be judged frame by frame; the entire sequence must be examined. Conversely, ① and ② show that when examining the entire sequence one must still allow harmless changes such as “start a second later” and “change clothes”. What the rules allow and forbid is the semantics of 1.1. The board's wording:

逐词翻译。「two measurement schedules」= 两个 Schedule 对象；「realize the same fault-tolerant object」= 整部电影放完，保护的是同一份逻辑信息、以同一种方式抓住错误——比 1.2 节的「dynamic_k 相同」更强，第 4 章细说；「the ZX local-equivalence picture … as target semantics」= 用一种叫 ZX 的图形语言里的重写规则，充当 1.1 节 R1、R2 那样的规则集；arXiv:2303.08829 是 QEC-Bank 文献注册表里的 bombin2023unifying（Bombín、Litinski、Nickerson、Pastawski、Roberts，“Unifying flavors of fault tolerance with the ZX calculus”，2023），第 4 章会描述 ZX 图长什么样。

Word by word. “Two measurement schedules” = two Schedule objects; “realize the same fault-tolerant object” = after the whole film, the same logical information is protected and errors are caught in the same way, stronger than 1.2's “equal dynamic_k”, as Chapter 4 explains; “the ZX local-equivalence picture … as target semantics” = the rewriting rules of a graphical language called ZX play the role of R1 and R2 in 1.1; arXiv:2303.08829 is bombin2023unifying in the QEC-Bank reference registry (Bombín, Litinski, Nickerson, Pastawski, Roberts, “Unifying flavors of fault tolerance with the ZX calculus”, 2023), and Chapter 4 describes what a ZX diagram looks like.

静态码的情形在《同一个码穿不同的衣服》2.1 节讲过：QEC-Bank 有一枚 checkmatrix_fingerprint，把检查矩阵的字节按原顺序交给 SHA-256，只认完全一致的复制品。动态码呢？看 honeycomb 卡片的构造记录：op: plaquette_colored_floquet, version 1；输入是一个叫 honeycomb_torus_schedule 的生成器（参数 L1、L2）；output: checkmatrix；match: exact-checkmatrix-v1。也就是说，构造器先把整张时间表放一遍，然后只导出稳定后某一轮的瞬时稳定子群，作为一张普通的检查矩阵登记；机器比对的是这一张矩阵的字节。卡片自己的视图 steady-isg-checks 说得很清楚：“After the declared startup, the constructor exports independent sign-free Pauli generators for one instantaneous stabilizer group as a symplectic CheckMatrix. This is the universal R1 snapshot for rank and commutation; it does not determine the protocol's spacetime distance.”

The static case was covered in §2.1 of “The same code in different clothes”: the QEC-Bank has a checkmatrix_fingerprint that feeds the check matrix's bytes in order to SHA-256 and recognises only exact copies. And dynamical codes? Look at the honeycomb card's construction record: op: plaquette_colored_floquet, version 1; the input is a generator called honeycomb_torus_schedule (parameters L1, L2); output: checkmatrix; match: exact-checkmatrix-v1. In other words the constructor plays the whole schedule, then exports only the instantaneous stabilizer group of one settled round, registering it as an ordinary check matrix; the machine compares the bytes of that one matrix. The card's own view steady-isg-checks says it plainly: “After the declared startup, the constructor exports independent sign-free Pauli generators for one instantaneous stabilizer group as a symplectic CheckMatrix. This is the universal R1 snapshot for rank and commutation; it does not determine the protocol's spacetime distance.”

（引文里的 symplectic CheckMatrix = 每个比特占两列、分别记 X 与 Z 的 0/1 检查矩阵，见静态那一篇 2.1 节。）机器另外核对的东西，写在 foundations/schedules-isg/intuition.md（一份标着 “STATUS: stub” 的存根）里：“Lean Complete v1 checks ordered commuting rounds, the declared finite snapshot, and periodic row-space recurrence where required. It does not formalize spacetime distance or dynamic logical transport.” 翻成人话，机器对一张时间表核对三件事：每一轮内部两两对易（1.2 节 validate()）；导出的那一帧和登记的字节一致；瞬时稳定子群生成的检查空间确实按周期重复（原文 row-space recurrence——不只是 r 的数值重复，而是同一组检查回来了）。再加上 instances.yaml 里 verified 的 dynamic_k。这四样对判「同一回事」有多大用？dynamic_k 是一个不变量——同一回事的两张表 dynamic_k 必相同，所以 1.3 节第 ③ 行的 2 ≠ 20 一票否决；但 dynamic_k 相同（比如两张都是 2）推不出同一回事，正如 n、k 相同推不出同一个码。「一帧的字节一致」更弱：① 晚一秒开始的表，导出的帧就换了一轮，字节不同；② 换了编号，字节不同。所以板上写 “None”：没有任何工具在说「相同」时可信。

(The quotation's “symplectic CheckMatrix” = a 0/1 check matrix with two columns per qubit, one for X and one for Z, see §2.1 of the static guide.) What else the machine checks is written in foundations/schedules-isg/intuition.md (a file marked “STATUS: stub”): “Lean Complete v1 checks ordered commuting rounds, the declared finite snapshot, and periodic row-space recurrence where required. It does not formalize spacetime distance or dynamic logical transport.” In plain words, the machine checks three things about a schedule: pairwise commutation within each round (1.2's validate()); that the exported frame matches the registered bytes; that the check space generated by the ISG really recurs periodically (the source's “row-space recurrence”: not merely the number r repeating, but the same set of checks returning). Plus the verified dynamic_k in instances.yaml. How much do these four help with “the same thing”? dynamic_k is an invariant: two schedules that are the same thing must have equal dynamic_k, so 2 ≠ 20 in row ③ of 1.3 is a veto; but equal dynamic_k (say both 2) does not imply the same thing, just as equal n and k do not imply the same code. “Identical bytes of one frame” is weaker still: ① a schedule started a second later exports a different round, different bytes; ② renumbered, different bytes. Hence “None” on the board: no tool is trustworthy when it says “same”.

honeycomb 卡片对「这张时间表是什么」给了八种视图view：card.yaml 里 views 列表的一条，字段有 rung（表示阶梯的层级）、type、description、origin、refs。origin 写 curated 表示人手登记，写 derived 表示由构造器算出。。把八种的 type 和 origin 列出来（codes/honeycomb/card.yaml）：

The honeycomb card gives eight viewsOne item of the views list in card.yaml, with fields rung (level on the representation ladder), type, description, origin, refs. origin curated means hand-registered; derived means computed by the constructor. of “what this schedule is”. Their types and origins (codes/honeycomb/card.yaml):

八段里只有第一段是机器算出来的（derived），第二段是构造器的规范定义（canonical），其余六段都是人写的（curated），而且它们之间没有一条机器核对过的连线：没有程序验证「schedule-isg 描述的三轮」「instantaneous-toric 说的环面码」「zx-spacetime 画的图」是同一个对象。卡片上唯一一条有类型的「同一」边也是人写的：same_bulk_phase_as → toric，origin curated，refs hastings2021dynamically、aasen2022automorphism，how 字段原文：“After each round, contracting the just-measured matching and applying a depth-one local Clifford change of basis maps the instantaneous stabilizer group to toric-code stabilizers on a coarser lattice. The equivalence is frame-by-frame; the full protocol still has spacetime detectors and a nontrivial anyon automorphism.”（前半句的「收缩」下一段拆开讲；anyon automorphism = 放完一个周期，环面码里两类缺陷的标签互换。）说人话：每一帧像环面码，整部电影不是环面码——这正是 1.3 节第 ③ 行教的「逐帧看不出来」的另一面：逐帧像，也不等于整体像。这句话今天靠两篇论文和写卡片的人背书，板上叫它 “curated identity claim”。

Of the eight, only the first is machine-computed (derived), the second is the constructor's defining convention (canonical), and the other six are written by people (curated); among them there is not one machine-checked link: no program verifies that “the three rounds of schedule-isg”, “the toric code of instantaneous-toric” and “the picture of zx-spacetime” are one object. The card's single typed “identity” edge is hand-written too: same_bulk_phase_as → toric, origin curated, refs hastings2021dynamically, aasen2022automorphism, how field verbatim: “After each round, contracting the just-measured matching and applying a depth-one local Clifford change of basis maps the instantaneous stabilizer group to toric-code stabilizers on a coarser lattice. The equivalence is frame-by-frame; the full protocol still has spacetime detectors and a nontrivial anyon automorphism.” (The next paragraph unpacks the “contracting” in the first sentence; the anyon automorphism = after one period, the labels of the toric code's two kinds of defect are exchanged.) In plain words: every frame resembles a toric code, the whole film is not one; the other face of row ③ in 1.3, “you cannot tell frame by frame”: resembling frame by frame does not make the whole alike either. Today this sentence rests on two papers and the card's author; the board calls it a “curated identity claim”.

how 字段的前半句说的是 Hastings–Haah（arXiv:2107.02194，1.4 节）的一步收缩。一轮刚测完，每条刚测的边（比如 Z_aZ_b，结果 ±1 已经知道）把它的两个比特 a、b 锁进一个二维子空间：两个比特本来有 4 个基态 |00⟩、|01⟩、|10⟩、|11⟩，检查只放行其中 2 个（结果 +1 时是 |00⟩ 和 |11⟩），所以这一对只剩一个有效比特。要把它显式地拆出来，就在这一对上做一个两比特门：ZZ 边和 XX 边用一个 CNOT，YY 边用一个受控 Y 门（论文原话：“one CNOT for each x or z edge and one control-Y for each y edge”）。以 ZZ 边为例，CNOT（a 控制、b 受控）把三个算符换成：

The first half of the how field is a contraction step of Hastings and Haah (arXiv:2107.02194, section 1.4). Right after a round, each just-measured edge (say Z_aZ_b, with its ±1 outcome known) locks its two qubits a and b into a two-dimensional subspace: two qubits have 4 basis states |00⟩, |01⟩, |10⟩, |11⟩, the check lets only 2 of them through (|00⟩ and |11⟩ for outcome +1), so the pair holds just one effective qubit. To split it out explicitly, apply one two-qubit gate to the pair: a CNOT for a ZZ or XX edge, a controlled-Y gate for a YY edge (in the paper's words, “one CNOT for each x or z edge and one control-Y for each y edge”). For a ZZ edge, the CNOT with control a and target b maps three operators to:

第一项：检查变成只作用在 b 上的 Z_b，b 被结果钉在 |0⟩ 或 |1⟩ 上，和其余一切无关，这就是「拆出去」。后两项：与检查对易的 X_aX_b 和 Z_a 变成比特 a 上的 X 和 Z，所以有效比特住在 a 上，它的 X 就是原来的 X_aX_b，它的 Z 就是 Z_a。（三项都可以用 4 × 4 矩阵直接乘出来核对，本篇的检验脚本做过。）刚测的边是一组完美匹配，这些门作用在两两不相交的比特对上，可以同时做完：这就是 depth-one（深度一），一层并行的门。local Clifford = 每个门只碰相邻的两个比特，并且把泡利串变成泡利串。门做完，每条刚测的边只剩一个有效比特，六边形算符在这些有效比特上就是一张更粗的六角格上的环面码检查（论文 1.4 节图 2）。注意这一步和第 0 章事实 5 的单比特改名不是一回事：改名只动一个比特、不减少比特数，这里每个门同时动一对比特，把其中一个拆出去。

The first: the check becomes Z_b, acting on b alone; the outcome pins b to |0⟩ or |1⟩, independent of everything else, which is what “split out” means. The other two: X_aX_b and Z_a, which commute with the check, become X and Z on qubit a, so the effective qubit lives on a, with the old X_aX_b as its X and Z_a as its Z. (All three can be checked by multiplying 4 × 4 matrices; this guide's check script does so.) The just-measured edges form a perfect matching, so these gates act on pairwise disjoint pairs and can all run at once: that is depth one, one parallel layer of gates. Local Clifford = each gate touches only two neighbouring qubits and maps Pauli strings to Pauli strings. After the layer, each just-measured edge leaves one effective qubit, and on those effective qubits the hexagon operators are the checks of a toric code on a coarser hexagonal lattice (the paper's section 1.4, Fig. 2). This step is not the single-qubit relabelling of fact 5 in Chapter 0: a relabelling touches one qubit and keeps the qubit count, whereas each gate here acts on a pair and splits one of its qubits out.

honeycomb 条目页的实例表写着：L3x3 n = 18 verified、k = 2 verified、d = ?；L6x6 n = 72 verified、k = 2 verified、d = ?。卡片的 claim_gaps 字段把这个问号指向另一道开放问题：{property: d, target: wanted:floquet-fault-distance}——《检查每一轮都在变，码距该怎么数》专讲。这里只提一句它和本篇的关系：一张时间表的「容错性质」（能抓住多少个错、d 是多少）是整部电影的性质；「两张表是不是同一回事」若有了答案，而且等价证明在规定的故障模型下附带一份保持权重的故障对应（3.2 节表格第三行），一张表上算出的 d 才能安全地借给另一张。反过来，没有等价判定，每张变体时间表的 d 都得从头算。

The honeycomb entry page's instance table reads: L3x3 n = 18 verified, k = 2 verified, d = ?; L6x6 n = 72 verified, k = 2 verified, d = ?. The card's claim_gaps field points that question mark at another open problem, {property: d, target: wanted:floquet-fault-distance}, the subject of “When the checks change every round, how do you count distance?”. Only its link to this guide is noted here: a schedule's “fault-tolerant properties” (how many errors it catches, what d is) are properties of the whole film; once “are two schedules the same thing?” has an answer, and the equivalence proof comes with a weight-preserving fault correspondence under a fixed fault model (row three of the table in 3.2), a d computed on one schedule can safely be lent to the other. Without an equivalence decision, every variant schedule's d must be computed from scratch.

1.1 节的甲、乙、丙是同一个奇偶的三种写法。若规定「标准写法 = 从左到右按字母顺序、括号全靠左」，即 ((a ⊕ b) ⊕ c) ⊕ d，那么任何写法都能用 R1、R2 改写到这一个标准形；两个写法相等 ⇔ 标准形相同。这叫典范化canonicalise：给每个等价类指定一个代表（典范形），并给出把任意成员改写成该代表的算法。分数约分是典范化；「按字母顺序、括号靠左」也是。，和《同一个码穿不同的衣服》1.4 节的「典范指纹」是一回事。对时间表，典范形可能是「从某个约定好的轮次开始、比特按约定编号、每轮的测量按约定排序」——但 1.3 节第 ③ 行提醒我们，还得知道哪些改写不允许（按方向重新分轮就不允许），这一点没有 ZX 那样的规则集是定不下来的。

A, B and C of 1.1 are three writings of one parity. If we decree “standard writing = alphabetical from left to right, all brackets to the left”, i.e. ((a ⊕ b) ⊕ c) ⊕ d, then every writing can be rewritten to this one standard form by R1 and R2; two writings are equal ⇔ their standard forms coincide. This is canonicalisationAssign every equivalence class one representative (the canonical form) and give an algorithm rewriting any member into it. Reducing fractions is canonicalisation; so is “alphabetical, brackets to the left”., the same thing as the “canonical fingerprint” of §1.4 of “The same code in different clothes”. For schedules the canonical form might be “start at an agreed round, number the qubits by an agreed rule, sort each round's measurements by an agreed order”; but row ③ of 1.3 reminds us that one must also know which rewrites are not allowed (regrouping rounds by direction is not), and that cannot be settled without a rule set such as ZX.

今天 QEC-Bank 有几张动态卡？在 codes/*/card.yaml 里带类别 dynamical 的只有两张：honeycomb 和 da_color_2d（本篇 grep 所得）。数量还小，但 honeycomb 的 intuition.md 已经在「Failure modes」里列出一串亲戚：“CSS honeycomb, X3Z3, hyperbolic, qudit, twist-network, and higher-dimensional descendants alter independent axes: Pauli pattern, geometry, boundaries, or circuit.” 每来一张这样的卡，都会面对同一个问题：它和已有的 honeycomb 是不是同一回事？有典范形，这个问题在提交时就能回答；没有，就得靠写卡片的人记得去查。

How many dynamical cards does the QEC-Bank have today? Only two in codes/*/card.yaml carry the category dynamical: honeycomb and da_color_2d (grep for this guide). Still few, but the honeycomb intuition.md already lists a string of relatives under “Failure modes”: “CSS honeycomb, X3Z3, hyperbolic, qudit, twist-network, and higher-dimensional descendants alter independent axes: Pauli pattern, geometry, boundaries, or circuit.” Every such card arriving faces the same question: is it the same thing as the existing honeycomb? With a canonical form the question is answered at submission; without one, it depends on the card's author remembering to check.

注意 zx-spacetime 视图末尾那半句：“without pretending that their hardware noise models are identical”。等价说的是容错对象相同，不是硬件表现相同：两张等价的表放在不同机器上，噪声不同，阈值就不同——就像静态那一篇 3.1 节说的，阈值不能跟着等价边走。在理想测量下能继承的是 k 和逻辑算符；抓错的能力（d）只有满足上表第三行的两个条件才能继承；不能继承的是任何带着具体电路和噪声模型的数字。

Note the half-sentence closing the zx-spacetime view: “without pretending that their hardware noise models are identical”. Equivalence says the fault-tolerant object is the same, not the hardware performance: two equivalent schedules on different machines see different noise and hence different thresholds, just as §3.1 of the static guide says thresholds must not travel along equivalence edges. Under ideal measurements, k and the logical operators can be inherited; the ability to catch errors (d) only when the two conditions in row three of the table hold; what cannot be inherited is any number tied to a specific circuit and noise model.

一，拿着一张自己写的三轮时间表问「这是不是 QEC-Bank 里的 honeycomb」：今天只能比一帧的字节，换了起始轮或编号就查不到。二，把 honeycomb 上 verified 的 dynamic_k = 2、或它的译码器与阈值记录，借给一张改过写法的表：没有等价证明，借了就是抄；而阈值即便有了证明也不能借。三，相信 same_bulk_phase_as 那句话超过「写卡片的人读过这两篇论文」的程度。三件事都不需要新的物理，需要的是 1.1 节那种规则集加上按规则改写的程序。

One, hold up a three-round schedule you wrote and ask “is this the QEC-Bank honeycomb?”: today only one frame's bytes can be compared, and a changed starting round or numbering makes it invisible. Two, lend honeycomb's verified dynamic_k = 2, or its decoder and threshold records, to a rewritten schedule: without an equivalence proof lending is copying, and the threshold may not be lent even with one. Three, trust the same_bulk_phase_as sentence beyond “the card's author read those two papers”. None of the three needs new physics; they need a rule set like that of 1.1 and a program that rewrites by the rules.

ZX 图ZX diagram / ZX calculus：一种画量子过程的图形语言。导线代表比特（沿导线是时间），点代表操作，点只有两种颜色（Z 型、X 型），每个点可以接任意多根导线。图与图之间有一套「局部改写规则」，规定哪些局部改动不改变图所代表的过程。是一种画量子过程的图形语言。规矩极少：导线代表比特，沿着导线走就是时间在流；点代表操作，只有两种颜色，本篇用蓝色画 Z 型点、琥珀色画 X 型点；一个点可以接任意多根导线（叫它的「腿」）。不带任何角度参数的点只表达两种约束：一个 Z 型点接 m 根腿，说的是「这 m 根线上的比特全都相等」（正是 3 比特重复码那种约束）；一个 X 型点接 m 根腿，说的是「这 m 根线上的比特里 1 的个数是偶数」——正是第 0 章事实 1 的奇偶检查。QEC-Bank 表面码卡片的 zx 视图把这一点说成一句话：“A phase-free ZX diagram and a CSS code encode the same binary linear subspace”（refs kissinger2022phasefree、debeaudrap2020zx、bombin2023unifying）。下图是 1.1 节的玩具画成 ZX 图的样子：

A ZX diagramZX diagram / ZX calculus: a graphical language for quantum processes. Wires are qubits (time runs along the wire), dots are operations, dots come in only two colours (Z type, X type), and a dot may attach to any number of wires. A set of “local rewriting rules” says which local changes leave the represented process unchanged. is a graphical language for quantum processes with very few conventions: wires are qubits, and walking along a wire is time passing; dots are operations and come in two colours only, drawn here blue for Z-type and amber for X-type; a dot may attach to any number of wires (its “legs”). Dots without any angle parameter express just two constraints: a Z-type dot with m legs says “the bits on these m wires are all equal” (exactly the constraint of the 3-bit repetition code); an X-type dot with m legs says “the number of 1s among the bits on these m wires is even”, which is the parity check of fact 1 in Chapter 0. The zx view of the QEC-Bank surface card puts it in one sentence: “A phase-free ZX diagram and a CSS code encode the same binary linear subspace” (refs kissinger2022phasefree, debeaudrap2020zx, bombin2023unifying). The figure below is the toy of 1.1 drawn as a ZX diagram:

图注：左边导线上的 a、b、c、d 是四个输入比特，右边伸出的导线 p 是输出，点是 X 型（琥珀色）。一个 X 点要求它所有腿上的值之和为偶，所以多接一条输出腿 p，就等于规定 p 取「其余各腿的奇偶」。左图：上面的点接 a、b、w，要求 a ⊕ b ⊕ w = 0，即 w = a ⊕ b；下面的点接 c、d、w、p，要求 c ⊕ d ⊕ w ⊕ p = 0，即 p = w ⊕ c ⊕ d = (a ⊕ b) ⊕ (c ⊕ d)，正是算法乙。右图：一个点接全部五条腿，要求 a ⊕ b ⊕ c ⊕ d ⊕ p = 0，即 p = a ⊕ b ⊕ c ⊕ d。手算核对：把左图两个式子相加，w ⊕ w = 0 消掉，剩下 a ⊕ b ⊕ c ⊕ d ⊕ p = 0，正是右图；再代一个输入，a b c d = 0001 时两图都给 p = 1。两图相等，是下面规则 ① 的一次应用，也就是 1.1 节「先算两两的奇偶、再合并」等于「一次算四个的奇偶」。若去掉 p，剩下的四腿 X 点就不再算奇偶，只表示「a ⊕ b ⊕ c ⊕ d = 0」这一条偶校验约束（输入 0001 不满足它）。

Caption: a, b, c, d on the left wires are the four input bits, the wire p leaving on the right is the output, and the dots are X-type (amber). An X dot demands that the values on all its legs sum to an even number, so one extra output leg p is set to “the parity of the other legs”. Left: the upper dot has legs a, b, w and demands a ⊕ b ⊕ w = 0, so w = a ⊕ b; the lower dot has legs c, d, w, p and demands c ⊕ d ⊕ w ⊕ p = 0, so p = w ⊕ c ⊕ d = (a ⊕ b) ⊕ (c ⊕ d), which is procedure B. Right: one dot with all five legs demands a ⊕ b ⊕ c ⊕ d ⊕ p = 0, so p = a ⊕ b ⊕ c ⊕ d. Check by hand: adding the two left equations, w ⊕ w = 0 drops out and a ⊕ b ⊕ c ⊕ d ⊕ p = 0 remains, which is the right diagram; and for the input a b c d = 0001 both give p = 1. The two are equal by one application of rule ① below, which is 1.1's “pairwise parities first, then combined” equalling “one parity of all four”. Without p, the four-legged X dot no longer computes the parity; it only states the even-parity constraint “a ⊕ b ⊕ c ⊕ d = 0” (the input 0001 violates it).

ZX 的规则不多，本篇只用口头说三条，不推导：

ZX has few rules; three are stated here in words only, without derivation:

为什么 Wanted 板要用它当规则集？因为一张时间表——先测这些、再测那些、每轮的结果如何组合——可以整个画成一张 ZX 图：导线沿时间延伸，每一次测量是接在导线上的一小组点，外加一根送出测量结果的经典输出（下面马上画），几轮之间的关系是点与点之间的导线。honeycomb 卡片的 zx-spacetime 视图写的就是这件事：“A ZX diagram represents the whole measurement history as a spacetime tensor network. Different circuit, fusion, and Floquet descriptions can be related by local rewrites.”（spacetime tensor network，时空张量网络：把许多小的操作按导线连成一张大图来表示整个过程的写法；ZX 图就是其中一种。）于是「两张时间表是不是同一回事」变成「两张 ZX 图能不能用规则互相改写到」，和 1.1 节「甲能不能改写成丙」是同一种问题。bombin2023unifying（arXiv:2303.08829）正是把电路式、融合式、Floquet 式三种容错方案放进同一张 ZX 图、用局部改写互相翻译的那篇论文——板上说的 “the ZX local-equivalence picture” 就指它。它的内容远超高中范围，本篇只描述它是什么类型的东西，没有读它的推导。

Why does the board choose it as the rule set? Because a whole schedule, measure these first, then those, and combine the rounds' outcomes so, can be drawn as one ZX diagram: wires extend along time, each measurement is a small group of dots on the wires plus a classical output that carries its result (drawn just below), and the relations between rounds are wires between dots. The honeycomb card's zx-spacetime view says exactly this: “A ZX diagram represents the whole measurement history as a spacetime tensor network. Different circuit, fusion, and Floquet descriptions can be related by local rewrites.” (A spacetime tensor network is a way of writing a whole process as many small operations joined by wires into one big diagram; a ZX diagram is one such.) So “are two schedules the same thing?” becomes “can two ZX diagrams be rewritten into each other by the rules?”, the same kind of question as “can A be rewritten into C?” in 1.1. bombin2023unifying (arXiv:2303.08829) is the paper that places circuit-based, fusion-based and Floquet fault-tolerance schemes into one ZX diagram and translates between them by local rewrites; that is the “ZX local-equivalence picture” the board names. Its content lies far beyond high-school level; this guide describes only what kind of thing it is and did not read its derivations.

测量和门有一处根本不同：它吐出一个经典结果，这个结果可能是随机的（态恰好是被测算符的本征态时，结果是确定的，例如在 |00⟩ 上测 ZZ 必得 b = 0），但无论哪种情况都得把它记下来。所以上面三条规则还不够，图里得画出结果。arXiv:2303.08829 第 2 节的做法是给点加一根粗黑线，叫经典输出，它带一个比特 b（0 或 1），b 决定这个点的角度是 0 还是 π（原话：“Each classical output is a bit b (0 or 1) which determines whether the phase of the spider is α or α+π”）。用本篇的读法，不带角度的 X 点要求各腿的奇偶为偶，角度为 π 时要求奇偶为奇；合起来就是「各腿的奇偶 = b」。下图是测两比特 Z₁Z₂ 而不毁掉比特的画法：

A measurement differs from a gate in one basic way: it emits a classical outcome, which may be random (on an eigenstate of the measured operator it is deterministic: measuring ZZ on |00⟩ always gives b = 0), and in either case it has to be recorded. The three rules above are therefore not enough; the diagram has to show the outcome. Section 2 of arXiv:2303.08829 adds a thick black line to a dot, a classical output carrying a bit b (0 or 1), and b sets the dot's angle to 0 or π (in the paper's words, “Each classical output is a bit b (0 or 1) which determines whether the phase of the spider is α or α+π”). In this guide's reading, an X dot without an angle demands even parity on its legs and one with angle π demands odd parity; together, “the parity of the legs = b”. The figure below draws a measurement of Z₁Z₂ on two qubits that leaves the qubits in place:

图注：两根细导线是比特 1、2，从左边进、从右边出；蓝点是 Z 型，琥珀点是 X 型，从琥珀点伸出的那条粗线是它的经典输出 b（论文里画成粗黑线）。逐点读：每个蓝点有三条腿（进、出、通向琥珀点的一条），要求三条腿上的值相等，所以通向琥珀点的两条腿分别带着比特 1、2 的 Z 基取值 x₁、x₂；琥珀点要求 x₁ ⊕ x₂ = b。于是 b = 0 的图只放行 x₁ = x₂ 的状态（测得 Z₁Z₂ = +1），b = 1 的图只放行 x₁ ≠ x₂ 的状态（测得 −1）。论文图 2c 从「一个辅助比特 + 两个 CNOT + 一次单比特 Z 测量」的电路出发，用规则化简到三个点，就是这个形状（这里按本篇的颜色重画）。

Caption: the two thin wires are qubits 1 and 2, entering on the left and leaving on the right; blue dots are Z-type, the amber dot X-type, and the thick line leaving the amber dot is its classical output b (drawn as a thick black line in the paper). Read dot by dot: each blue dot has three legs (in, out, and one to the amber dot) and demands equal values on all three, so the two legs into the amber dot carry the Z-basis values x₁ and x₂ of qubits 1 and 2; the amber dot demands x₁ ⊕ x₂ = b. So the diagram with b = 0 lets through only states with x₁ = x₂ (outcome Z₁Z₂ = +1), and the one with b = 1 only states with x₁ ≠ x₂ (outcome −1). The paper's Fig. 2c starts from the circuit “one ancilla qubit + two CNOTs + one single-qubit Z measurement” and simplifies it by the rules to three dots, which is this shape (redrawn here in this guide's colours).

改写规则怎样对待这些结果？论文给了三点。第一，把所有 b 都固定下来，剩下的就是一张普通 ZX 图（“for any fixed outcome configuration, we recover a plain vanilla ZX network”）。第二，融合和变色这两条规则对带经典输出的点照样成立，② 两腿即导线则不能用在带输出的点上（论文把 ② 叫 identity 规则，原话：“apart from the identity rule, these rules also work with the proposed extension”）。第三，两个同色、都带输出的点融合时，结果只剩一个输出，取值 b₁ ⊕ b₂；论文说只有当我们只关心这两个结果的奇偶时才能这样合（“A merge is possible, as long as only the joint parity of the outcomes is relevant”）。也就是说，改写保住的不是每一个单独的结果，而是一些结果的奇偶组合：无错时取值固定、用来抓错的那些组合（论文叫 checks，对应「探测器」），以及读出逻辑信息的那些组合。两张时间表的图即使量子部分相同，挂着的结果也可以不同；论文自己就说，它的融合式网络与电路式网络「严格说并不等价，因为挂着一组更大、不同的经典结果」（“strictly speaking, not equivalent … because there is a larger and different set of classical outcomes attached”），两者要靠结果组合之间的对应才连得起来。所以「两张图能互相改写」本身还不是时间表等价：还得说清一张表的每个检查组合、每个逻辑读数对应到另一张表的哪个组合。另外，QEC-Bank 的 Schedule(n, rounds) 是一份固定的轮次列表，下一轮测什么不看结果，结果只决定瞬时稳定子群里各条检查的符号；若将来的时间表要按结果选下一步，图里还得画进这种分支，本篇不讨论。

How do the rewrite rules treat these outcomes? The paper makes three points. First, fixing every b leaves an ordinary ZX diagram (“for any fixed outcome configuration, we recover a plain vanilla ZX network”). Second, fusion and colour change still hold for dots with a classical output, while ② (two legs is a wire) may not be used on such a dot (the paper calls ② the identity rule: “apart from the identity rule, these rules also work with the proposed extension”). Third, when two dots of the same colour, both with outputs, are fused, only one output is left, with value b₁ ⊕ b₂; the paper allows this only when just the parity of the two outcomes matters (“A merge is possible, as long as only the joint parity of the outcomes is relevant”). So rewriting preserves not each individual outcome but certain parity combinations of outcomes: those that are fixed when nothing goes wrong and are used to catch errors (the paper's checks, the “detectors”), and those that read out logical information. Two schedules' diagrams may agree in their quantum part and still carry different outcomes; the paper itself says its fusion-based network is “strictly speaking, not equivalent” to the circuit-based one “because there is a larger and different set of classical outcomes attached”, and the two are linked through a correspondence between outcome combinations. So “the two diagrams can be rewritten into each other” is not yet schedule equivalence: one must also say which combination in the other schedule each check combination and each logical readout corresponds to. Also, a QEC-Bank Schedule(n, rounds) is a fixed list of rounds: what is measured next never depends on an outcome, and outcomes only set the signs of the checks in the instantaneous stabilizer group. A future schedule that chose its next step from an outcome would need that branching drawn into the diagram too; this guide does not treat it.

一台程序，输入两个 Schedule 对象，做三步：把每张时间表画成带经典输出的 ZX 图（4.1 节）；判定两张图能否用允许的规则互相改写到（或者把每张图改写到一个典范形再比较）；输出「同一回事 / 不是」，并在答「是」时交出改写链——像 1.1 节那六步一样，每一步只用一条规则，任何人（或任何程序）都能逐步核对——外加一张结果对照表：一张表的每个检查组合、每个逻辑读数，对应到另一张表的哪个结果组合（4.1 节末段说了为什么缺它不行）。若还要说两张表的 d 相同，还得先规定故障模型，并交出保持权重的故障对应（3.2 节表格第三行）。答「不是」时最好也给理由：一个在规则下不变、却在两张图上取值不同的量（比如 dynamic_k 的 2 与 20）。有了这台程序，第 2 章那六段 curated 的话中「像」的部分就能变成一条条有证书的 derived 边；「不是」的部分（逐帧像、整体不像）也各有凭据。

A program that takes two Schedule objects and does three things: draw each schedule as a ZX diagram with classical outputs (4.1); decide whether the two diagrams can be rewritten into each other by the allowed rules (or rewrite each into a canonical form and compare); output “the same thing / not”, and when it says “yes” hand over the rewrite chain, like the six steps of 1.1, each step one rule, checkable step by step by any person or program, together with an outcome table: which outcome combination in the other schedule each check combination and each logical readout corresponds to (the end of 4.1 says why it cannot be left out). To claim also that the two schedules have the same d, one must first fix a fault model and hand over a weight-preserving fault correspondence (row three of the table in 3.2). When it says “no” it should ideally give a reason: a quantity invariant under the rules that differs between the two diagrams (such as dynamic_k, 2 versus 20). With this program, the “alike” parts of Chapter 2's six curated paragraphs become derived edges with certificates, and the “not” parts (alike frame by frame, not as a whole) each get their evidence.

Wanted 板给每道题两种难度。hard-engineering = 「知道怎么做，但要做很多」；open-research = 「没人知道怎么做」。这道题标的是 open-research。诚实地说难在哪里：

The board grades every problem one of two ways. hard-engineering = “we know how, but there is a lot to do”; open-research = “nobody knows how”. This problem is rated open-research. Honestly, where the difficulty lies:

所以这不是「把 ZX 库接进 QEC-Bank」那种工程量：真正缺的是一条定理——「这套规则下的这套不变量相同 ⇔ 两张时间表实现同一个容错对象」——和把它算出来的方法。在它出现之前，任何比对工具都只能像 dynamic_k 那样，说「不同」时可信，说「相同」时不可信。本篇不假装知道这条定理长什么样。

So this is not the engineering of “wiring a ZX library into the QEC-Bank”: what is missing is a theorem, “equal values of this set of invariants under these rules ⇔ the two schedules realise the same fault-tolerant object”, and a way to compute it. Until it appears, any comparison tool can only behave like dynamic_k: trustworthy when it says “different”, untrustworthy when it says “same”. This guide does not pretend to know what that theorem looks like.

时间表 P：一轮，测全部 9 条星检查和 9 条面检查，重复。时间表 Q：第 0 轮只测 9 条星，第 1 轮只测 9 条面，重复。算 r。P：第一轮之后，18 条检查里独立的是 16 条（第 0 章事实 4），r = 16，之后一直 16。Q：第 0 轮 9 条星，其中 9 条的乘积是单位（每条边被两颗星各碰一次），所以独立的只有 8 条，r = 8；第 1 轮的 9 条面与所有星对易（Toric Code 教程 5.1 节的对易定理），按 1.2 节弹窗里的情况 (b)「对易但不在群里 → 带测得的符号加进去」，加上 8 条独立的面，r = 16；第 2 轮再测星，每条星都已在群里，按情况 (a) 结果是确定的（等于上次的读数），群不变，r 不变。两条序列：

Schedule P: one round measuring all 9 star checks and 9 plaquette checks, repeated. Schedule Q: round 0 measures only the 9 stars, round 1 only the 9 plaquettes, repeated. Compute r. P: after the first round, 16 of the 18 checks are independent (fact 4 of Chapter 0), r = 16, and 16 ever after. Q: round 0's 9 stars have product equal to the identity (every edge is touched by two stars), so only 8 are independent, r = 8; round 1's 9 plaquettes commute with every star (the commutation theorem of section 5.1 of the toric-code guide), so by case (b) in the tooltip of 1.2, “commutes but lies outside → append with the measured sign”, 8 independent plaquettes are added, r = 16; round 2 measures stars again, each star is already in the group, so by case (a) its outcome is certain (equal to the last reading) and the group, and r, are unchanged. The two sequences:

dynamic_k 相同只是不否决；P 和 Q 是同一回事吗？在「理想测量、没有测错」的意义上是，而且能证：Q 的两轮里所有串两两对易，对易的测量先后顺序不影响结果（第 0 章事实 3：只有反对易的串才会抹掉信息），所以把 Q 的第 0 轮和第 1 轮合成一轮就是 P。相同的是对齐的完整周期结束时的状态：Q 每做完一个周期（第 2t、2t + 1 两轮），它的瞬时稳定子群和逻辑算符与 P 做完第 t 轮时相同，符号也按对应的读数对得上：Q 第 2t 轮的 9 个星读数和第 2t + 1 轮的 9 个面读数，与 P 第 t 轮的 18 个读数一一对应（同一条检查对同一条检查），两边的瞬时稳定子群都由对应的读数定符号。中间时刻并不相同：Q 第 0 轮刚结束时群里只有 8 条独立的星（r = 8），P 此时已有 16 条。这是一条「对易的轮次可以合并或拆开」的规则，作用和 1.1 节的 R1 一样；在 ZX 语言里它对应一条允许的局部改写，本篇不画。诚实地说，这只证明了两张表是同一个码，没有证明它们是同一个容错对象：一旦测量本身会出错，P 一轮读 18 个数、Q 一轮只读 9 个，探测器和能抓住的错误可能不同，那一层本篇没有碰。反过来看 honeycomb：它三轮之间反对易，这条规则用不上，这正是它的等价问题比环面码难得多的原因。

Equal dynamic_k merely fails to veto; are P and Q the same thing? In the sense of “ideal measurements, no measurement errors”, yes, provably: within Q's two rounds all strings commute pairwise, and the order of commuting measurements does not affect the result (fact 3 of Chapter 0: only anticommuting strings erase information), so merging Q's rounds 0 and 1 into one round gives P. What agrees is the state at matched ends of complete cycles: each time Q completes a cycle (rounds 2t and 2t + 1), its ISG and logical operators equal P's after round t, with signs matching under the outcome correspondence: Q's 9 star readings in round 2t and 9 plaquette readings in round 2t + 1 correspond one to one to the 18 readings of P's round t (each check to the same check), and on both sides the ISG takes its signs from the corresponding readings. In between they differ: right after Q's round 0 the group holds only 8 independent stars (r = 8), while P already has 16. This is a rule, “commuting rounds may be merged or split”, playing the role of R1 in 1.1; in ZX language it corresponds to one allowed local rewrite, not drawn here. Honestly, this proves only that the two schedules are the same code, not the same fault-tolerant object: once measurements themselves can fail, P reads 18 numbers per round and Q only 9, so the detectors and the errors caught may differ; that layer is untouched here. Look back at honeycomb: its three rounds anticommute, this rule does not apply, and that is exactly why its equivalence problem is so much harder than the toric code's.

在下面 L = 3 的环面沙盘上放几个 Z 错误，再放几个 X 错误。Z 错误只让星报警，X 错误只让面报警；两族检查各看各的，谁先测、谁后测都不改变对方的读数。这就是 5.1 节那条「对易的轮次可以合并」在眼前的样子。想象把星的读数和面的读数分在两轮里读，或一轮里一起读——报警的图案一样。

On the L = 3 toric sandbox below, place a few Z errors, then a few X errors. Z errors make only stars fire, X errors only plaquettes; each family watches its own, and which is measured first changes nothing in the other's readout. That is 5.1's rule “commuting rounds may be merged” before your eyes. Imagine reading the stars and the plaquettes in two separate rounds or together in one: the alarm pattern is the same.

真的那张时间表。QEC-Bank 条目页 honeycomb（它的表示阶梯列出 2.2 节的八种视图，推导页有 r 序列与反例的复现脚本 reproduce.py）；框架页 foundations/schedules-isg/intuition.md 目前是存根，一句话定义：“Dynamical codes are sequences of measured Pauli products; the ISG is the state's instantaneous stabilizer.” 本题 yaml 没有 working_repo。相邻的开放问题。静态版本：《同一个码穿不同的衣服》（每一帧的等价）；蜂窝码的 d = ?：《检查每一轮都在变，码距该怎么数》；ZX 也出现在《用费米子的语言写电路》里，那里它是翻译的目标语言之一。「测量也会错」的那一层，本篇没有碰：Surface Code 译码器教程 5.1 节的「探测器」——只报「变化」的检查——是 honeycomb 卡片 spacetime-detector 视图说的东西。

The real schedule. The QEC-Bank entry page honeycomb (its representation ladder lists the eight views of 2.2; its derivations page has the r sequence and the counterexample's reproduction script reproduce.py); the framework page foundations/schedules-isg/intuition.md is currently a stub with a one-line definition: “Dynamical codes are sequences of measured Pauli products; the ISG is the state's instantaneous stabilizer.” This item's yaml has no working_repo. Neighbouring open problems. The static version: “The same code in different clothes” (equivalence of each frame); honeycomb's d = ?: “When the checks change every round, how do you count distance?”; ZX also appears in “Writing circuits in the language of fermions”, where it is one of the target languages of translation. The layer where measurements themselves fail, untouched here: the “detectors” of §5.1 of the Surface Code decoders guide, checks that report only “change”, are what the honeycomb card's spacetime-detector view speaks of.

回放一遍。四个比特的奇偶有很多种算法，R1、R2 两条规则把它们连成一家：一条改写链就是一份证书，不必代入 2ⁿ 种输入。一张测量时间表是「一轮一轮的泡利串」，静态码是周期 1 的特例；蜂窝码周期 3，每轮 9 条两比特测量，r 序列 9、12、14、16 停住，dynamic_k = 2。两张表是不是同一回事，不能逐帧判断：按颜色分轮与按方向分轮每一帧都合法，整部放完却是 2 对 20。QEC-Bank 今天对动态码的机器比对只落在一帧的字节和 dynamic_k 这个不变量上，说「相同」时不可信；honeycomb 卡片上六段 curated 视图与一条 curated 边全靠人写。合格的答案是一台按 ZX 规则改写并交出改写链的程序；难在改写没有方向、语义还在被定、要保持的对象自己还没算全——open-research。环面码的 P 与 Q 是高中水平能完整证明的一对「同一个码」（理想测量意义下）；蜂窝码不是，因为它的三轮反对易。

Replay. The parity of four bits has many procedures, and the two rules R1, R2 tie them into one family: a rewrite chain is a certificate, with no need to substitute 2ⁿ inputs. A measurement schedule is “Pauli strings round by round”, a static code being the period-1 special case; the honeycomb code has period 3, 9 two-qubit measurements per round, an r sequence 9, 12, 14, 16 that then stops, dynamic_k = 2. Whether two schedules are the same thing cannot be judged frame by frame: grouping by colour and grouping by direction are legal in every frame, yet the whole film ends at 2 versus 20. Today the QEC-Bank machine comparison for dynamical codes rests on the bytes of one frame and the invariant dynamic_k, untrustworthy when it says “same”; the honeycomb card's six curated views and one curated edge are all written by people. A qualifying answer is a program that rewrites by the ZX rules and hands over the chain; the difficulty is that rewriting has no direction, the semantics is still being fixed, and the object to be preserved is itself not fully computed: open-research. The toric code's P and Q are a pair of “the same code” (under ideal measurements) fully provable at high-school level; the honeycomb code is not, because its three rounds anticommute.