同一个码
穿不同的衣服 The same code
in different clothes

记号：n = 物理比特数，k = 逻辑比特数，d = 码距，L = 环面边长，H = 检查矩阵（每行一条检查）。「重量」= 一条泡利串触碰的比特数。

Notation: n = number of physical qubits, k = number of logical qubits, d = distance, L = side length of the torus, H = check matrix (one row per check). “Weight” = the number of qubits a Pauli string touches.

取 Toric Code 教程 2.2 节的 3 比特重复码：合法的码字只有 000 和 111。它的检查清单可以写成两条：「第 1 位 = 第 2 位吗」「第 2 位 = 第 3 位吗」。按第 0 章事实 1 写成矩阵，每行一条检查、每列一个比特：

Take the 3-bit repetition code of section 2.2 of the toric-code guide: the only legal codewords are 000 and 111. Its check list can be written as two lines: “is bit 1 = bit 2?” and “is bit 2 = bit 3?”. As a matrix per fact 1 of Chapter 0, one row per check and one column per bit:

记号：H₁ = 第一套写法的检查矩阵；分号隔开两行；每行三个数对应比特 1、2、3。

Notation: H₁ = the check matrix of the first way of writing; the semicolon separates the two rows; the three numbers in a row belong to bits 1, 2, 3.

第一件事：换编号。把比特 1 和比特 3 的名字对调。第一条检查变成「第 3 位 = 第 2 位吗」，第二条变成「第 2 位 = 第 1 位吗」；矩阵变成 [ 0 1 1 ; 1 1 0 ]——两行掉了个头，两列也掉了个头。码字 000 和 111 对调编号之后还是 000 和 111。清单换了样子，码没变。

First: renumber. Swap the names of bit 1 and bit 3. The first check becomes “is bit 3 = bit 2?”, the second “is bit 2 = bit 1?”; the matrix becomes [ 0 1 1 ; 1 1 0 ], the two rows turned around and the two columns turned around. The codewords 000 and 111 are still 000 and 111 after the renaming. The list changed its look; the code did not.

第二件事：换一组检查。还是原来的编号，但这次写「第 1 位 = 第 2 位吗」和「第 1 位 = 第 3 位吗」：

Second: pick a different set of checks. Keep the original numbering, but this time write “is bit 1 = bit 2?” and “is bit 1 = bit 3?”:

H₂ 和 H₁ 只有一行相同。它们是同一个码吗？是：一个串通过 H₂ 的两条检查，就是「1 = 2 且 1 = 3」，于是三位全等，只剩 000 和 111；反过来也一样。更机械的看法：H₁ 的第二行 0 1 1 等于 H₂ 两行按位相加（1+1 = 0，不进位）：1 1 0 + 1 0 1 = 0 1 1。第 0 章事实 3 说过，清单里几条检查的乘积（这里是按位相加）也算检查；所以两份清单生成的是同一组检查，只是各挑了两条当代表。人话：一个码不是它的检查清单，而是清单能生成的全部检查。

H₂ and H₁ share only one row. Are they the same code? Yes: a string passing both checks of H₂ satisfies “1 = 2 and 1 = 3”, so all three bits agree and only 000 and 111 remain; and conversely. More mechanically: the second row of H₁, 0 1 1, equals the bitwise sum of the two rows of H₂ (1+1 = 0, no carry): 1 1 0 + 1 0 1 = 0 1 1. Fact 3 of Chapter 0 said that products of list entries (bitwise sums here) count as checks; so the two lists generate the same set of checks and merely picked two different representatives each. In plain words: a code is not its check list but everything the list generates.

现在到量子码。下面的沙盘是 L = 3 的环面码：18 个比特住在边上，9 个顶点各一条 X 型星检查（碰周围 4 条边），9 块面各一条 Z 型面检查（碰四周 4 条边）。点一条边放一个 Z 错误，看是哪两颗星报警。

Now a quantum code. The sandbox below is the toric code with L = 3: 18 qubits on the edges, an X-type star check at each of 9 vertices (touching its 4 edges), a Z-type plaquette check on each of 9 faces (touching its 4 sides). Click an edge to place a Z error and see which two stars fire.

第三件事：在每个比特上把 X 和 Z 对调。有一个 2 × 2 矩阵专门做这件事（怎么乘见本节末的补课），叫阿达马矩阵 HHadamard：H = (1/√2)·[1 1 ; 1 −1]。用高中矩阵乘法可以验证 H·X·H = Z，H·Z·H = X（H 自己乘自己是单位矩阵）。它是一个「单比特换基」：换一种坐标看同一个比特，X 和 Z 的角色互换。——注意它和检查矩阵 H 撞了名字，本篇之后写 H_ad。在全部 18 个比特上各做一次 H_ad，每条 X 型星检查变成 Z 型，每条 Z 型面检查变成 X 型。新清单：顶点上是 Z 型 4 腿检查，面上是 X 型 4 腿检查。它和原来的清单一个字母都对不上。

Third: swap X and Z on every qubit. A 2 × 2 matrix does exactly this (the catch-up at the end of this section shows how to multiply it out), the Hadamard matrix HH = (1/√2)·[1 1 ; 1 −1]. High-school matrix multiplication verifies H·X·H = Z and H·Z·H = X (H times itself is the identity). It is a “single-qubit change of basis”: look at the same qubit in different coordinates and the roles of X and Z swap.; it clashes in name with the check matrix H, so from here on it is written H_ad. Apply H_ad once on each of the 18 qubits: every X-type star check becomes Z type, every Z-type plaquette check becomes X type. The new list: Z-type 4-leg checks at vertices, X-type 4-leg checks on faces. Not one letter matches the old list.

它是同一个码吗？先数不变的东西：n 还是 18；检查还是 9 + 9 条、各 4 腿、独立的还是 16 条，所以 k 还是 2；最轻的逻辑算符还是绕一圈的 3 条边，d 还是 3。再看几何：在环面上，把每个顶点换成一块面、每块面换成一个顶点（每条边换成穿过它的那条边），得到的还是一张 3 × 3 的正方形网格。所以答案是「是」，而且比「换了基」还多一点：把新清单里每个比特改记在穿过它的那条对偶边上（图 1.1 ③），面上的 X 型检查正好变成对偶格的一颗 X 型星，顶点上的 Z 型检查变成对偶格的一块 Z 型面。对偶格还是 3 × 3 方格，于是「Z 型星、X 型面」这份清单只换编号就变回原来的「X 型星、Z 型面」。在环面码上，「全体换基」这件衣服恰好也能用「换编号」这件衣服穿出来。

Is it the same code? Count what did not change first: n is still 18; there are still 9 + 9 checks with 4 legs each, still 16 independent ones, so k is still 2; the lightest logical is still a loop of 3 edges, so d is still 3. Then the geometry: on the torus, replacing every vertex by a face and every face by a vertex (every edge by the edge crossing it) yields again a 3 × 3 square grid. So the answer is yes, and slightly more than “it was re-based”: record every qubit of the new list on the dual edge crossing it (Fig. 1.1 ③); the X-type plaquette checks become X-type stars of the dual grid and the Z-type star checks become its Z-type plaquettes. The dual grid is again a 3 × 3 square grid, so the list “Z-type stars, X-type plaquettes” returns to the original “X-type stars, Z-type plaquettes” by renumbering alone. On the toric code the outfit “re-base every qubit” can also be worn as the outfit “renumber”.

三种换衣服的方式，合起来叫局部等价local equivalence：两份检查清单，若能通过「重新给比特编号」「在单个比特上换基（把 X、Y、Z 三个字母重新命名）」「换一组生成同样检查的代表」这三种操作互相变到，就说它们是同一个码的两种写法。「局部」指的是每一步只碰一个比特。。说人话：

The three ways of changing clothes together are called local equivalenceTwo check lists are two ways of writing the same code if one can be turned into the other by “renumbering the qubits”, “changing basis on single qubits (renaming the three letters X, Y, Z)”, and “choosing a different set of representatives generating the same checks”. “Local” means every step touches only one qubit.. In plain words:

为什么只允许这三种？因为它们都不会改变任何逻辑算符的重量：编号和改名只是换名字，换代表根本没动码本身。一旦允许同时碰两个比特的操作（比如把比特 1 的错误「传」到比特 2 上），一条重量 1 的错误可以变成重量 2，码距就会变，那就不是换衣服而是换人了。QEC-Bank 登记检查时不记符号（sign-free），所以本篇也不追究 ± 号。

Why only these three? Because none of them changes the weight of any logical operator: renumbering and renaming are just names, and changing generators does not touch the code at all. Once operations acting on two qubits at once are allowed (say, “copying” an error from qubit 1 onto qubit 2), a weight-1 error can become weight 2 and the distance can change; that is no longer new clothes but a new person. The QEC-Bank records checks without signs (sign-free), so this guide does not track ± signs either.

现在可以说出这道开放问题了。给两份检查清单，判定它们是否局部等价；更好的是给每个码算出一个典范指纹canonical fingerprint：由码算出来的一串数或字符，满足两条：(i) 换任何衣服它都不变；(ii) 真正不同的两个码，它必然不同。有了它，「是不是同一个码」就变成「两串指纹相等吗」。——换衣服不变、不同的码必不同。高中里最熟的典范形是分数约分：2/4 和 3/6 长得不一样，约成最简分数都是 1/2，于是一比就知道相等；「最简分数」就是分数的典范形。Wanted 板的原文是：

Now the open problem can be stated. Given two check lists, decide whether they are locally equivalent; better still, compute for every code a canonical fingerprintA string of numbers or characters computed from the code with two properties: (i) it does not change under any change of clothes; (ii) two genuinely different codes must get different fingerprints. With it, “same code?” becomes “equal fingerprints?”., unchanged by clothes and different for different codes. The most familiar canonical form from school is reducing fractions: 2/4 and 3/6 look different, both reduce to 1/2, and equality is read off at a glance; “lowest terms” is the canonical form of a fraction. The Wanted board's wording:

逐词翻译。「two entries」= QEC-Bank 的两张卡片；「the same code up to local equivalence」= 1.3 节的三种换衣服之下是同一个码；「canonical fingerprints」= 上面说的典范指纹；「beyond (n, k, d-bounds, weight histograms)」= 要比这四样更细：n、k 是两个整数，d-bounds 是码距的上下界（《大码的码距》讲为什么大码只有界没有精确值），重量直方图weight histogram：数一数码里有多少条重量 1、多少条重量 2、……的检查（或码字），排成一张表。换衣服不改变任何一条的重量，所以直方图是不变量。是「各种重量的检查各有几条」的一张表。n、k、真正的 d 和直方图换衣服都不变，所以都是不变量invariant：换衣服前后不变的量。不变量不同 ⇒ 码不同；不变量相同 ⇒ 什么都推不出（第 2 章有反例）。（登记的「d 的上下界」本身只是一个装着 d 的区间，两张卡的区间可以不一样；只有两个区间不相交时才能否决）；但第 2 章会看到，四样全相同的两个码，仍可能不是同一个。

Word by word. “Two entries” = two QEC-Bank cards; “the same code up to local equivalence” = the same code beneath the three changes of clothes of 1.3; “canonical fingerprints” = as above; “beyond (n, k, d-bounds, weight histograms)” = finer than these four: n and k are two integers, d-bounds are lower and upper bounds on the distance (“Distance for large codes” explains why large codes have bounds rather than exact values), and the weight histogramCount how many checks (or codewords) of weight 1, of weight 2, … the code has, in a table. Changing clothes changes no weight, so the histogram is an invariant. is a table of “how many checks of each weight”. n, k, the true d and the histogram do not change with clothes, so they are invariantsQuantities unchanged by a change of clothes. Different invariants ⇒ different codes; equal invariants ⇒ nothing follows (Chapter 2 has a counterexample). (the recorded “bounds on d” are merely an interval containing d, and two cards may record different intervals; only disjoint intervals veto); but Chapter 2 will show two codes agreeing on all four that are still not the same.

QEC-Bank 的 Python 代码库 qeclib 里，真正给一个码算「指纹」的函数只有一个：qeclib/benchmarks.py 里的 checkmatrix_fingerprint(cm)。它的注释原文是 “Fingerprint exact stabilizer/gauge values, shapes, rows, and qubits.” 它做的事，逐行读是这样的：先写下一个版本标签 stab-gauge-uint8-v1；再写下检查矩阵的形状（几行乘几列，比如 toric_L3 是 18 行 × 36 列——每个比特占两列，一列记 X、一列记 Z）；再把矩阵的全部 0/1 按原来的顺序逐字节写下；如果这个码另有一组「不在乎」的检查（gauge，《不在乎的比特》专讲），也写下，否则写 no-gauge；最后把这一长串字节交给 SHA-256一种哈希函数：把任意长的一串字节压成固定的 64 个十六进制字符。同样的输入永远得到同样的输出；输入改一个比特，输出面目全非；从输出反推输入被认为不可行。不同的输入也可能得到同一个输出（叫「碰撞」），设计要求只是这样的一对在计算上找不到。，得到 64 个字符。

In the QEC-Bank Python library qeclib exactly one function computes a “fingerprint” of a code: checkmatrix_fingerprint(cm) in qeclib/benchmarks.py. Its docstring reads “Fingerprint exact stabilizer/gauge values, shapes, rows, and qubits.” Line by line, this is what it does: write a version tag stab-gauge-uint8-v1; write the shape of the check matrix (rows × columns; toric_L3 is 18 rows × 36 columns, two columns per qubit, one for X and one for Z); write every 0/1 of the matrix in its original order, byte by byte; if the code has a second list of “don't-care” checks (gauge, the subject of “Don't-care qubits”) write it too, otherwise write no-gauge; finally hand the whole byte string to SHA-256A hash function: it compresses a byte string of any length into a fixed 64 hexadecimal characters. Same input, same output, always; change one bit of input and the output is unrecognisable; recovering the input from the output is believed infeasible. Two different inputs can give the same output (a “collision”); the design requirement is only that no one can compute such a pair. and get 64 characters.

记号：‖ 读「接上」，把两串字节首尾相连；标签 = 版本标签 stab-gauge-uint8-v1；矩阵字节按原顺序写入；gauge 一项没有时写 no-gauge。「按原顺序」是下面这段话的全部要点。

Notation: ‖ reads “concatenated with”, joining two byte strings end to end; tag = the version tag stab-gauge-uint8-v1; the matrix bytes are written in their original order; the gauge item reads no-gauge when absent. “In order” is the whole point of the next paragraph.

用第 1 章的三件事去试它。操作 ①，把两个比特换编号：矩阵的两列对调，字节顺序变了，SHA-256 给出完全不同的 64 个字符。操作 ②，在一个比特上 X ↔ Z：那个比特的两列互换，同样变。操作 ③，H₁ 换成 H₂：一行的内容变了，同样变。也就是说，这枚指纹对三种换衣服全都敏感——它是衣服的指纹，不是人的指纹。它认得出的只有「字节完全一致的复制品」。QEC-Bank 也正是这样用它的：每张卡片的构造记录里写着 match: exact-checkmatrix-v1，复现契约里写着期望的比对结果是 “byte-and-semantic-identical”——机器重新构造一次，和登记的矩阵逐字节相同才算通过。这里有一个细节：两枚指纹相同，逻辑上并不等于两串字节相同。输入有无穷多种，64 个十六进制字符只有 16⁶⁴ = 2²⁵⁶ 种，所以必然有不同的输入撞上同一个输出。SHA-256 的设计目标是让这样的一对「在计算上找不到」（NIST 对抗碰撞性的定义：“computationally infeasible to find two different inputs to the hash function that have the same hash value”），因此把「指纹相同」当作「字节相同」，实际风险可以忽略；但要把「完全一致」写成一张证书，指纹对上之后还应把两份矩阵逐字节再比一遍，这一步很便宜。这枚指纹对「同一台构造器有没有被改动」很合用；对「两台不同的构造器造出的是不是同一个码」则一个字也说不了。

Try the three moves of Chapter 1 on it. Move ①, renumber two qubits: two columns of the matrix swap, the byte order changes, SHA-256 returns 64 entirely different characters. Move ②, X ↔ Z on one qubit: that qubit's two columns swap; changes again. Move ③, H₁ to H₂: one row's content changes; changes again. So this fingerprint is sensitive to all three changes of clothes: it is a fingerprint of the clothes, not of the person. All it recognises is “a byte-for-byte identical copy”. And that is exactly how the QEC-Bank uses it: every card's construction record says match: exact-checkmatrix-v1, and the reproduction contract expects the comparison result “byte-and-semantic-identical”; the machine rebuilds the code and passes only if the result matches the registered matrix byte for byte. One detail: two equal fingerprints do not logically imply two equal byte strings. There are infinitely many inputs and only 16⁶⁴ = 2²⁵⁶ strings of 64 hexadecimal characters, so different inputs must share an output. What SHA-256 is designed for is that no one can compute such a pair (NIST's definition of collision resistance: “computationally infeasible to find two different inputs to the hash function that have the same hash value”), so treating “equal fingerprints” as “equal bytes” carries a negligible practical risk; but to write “identical” into a certificate, compare the two matrices byte by byte once the fingerprints match, which is cheap. For “has the same constructor been tampered with?” this fingerprint serves well; for “do two different constructors build the same code?” it says nothing at all.

换个方向：不看字节，只看换衣服不变的量。n、k、d、重量直方图，四样若有一样不同，两个码就一定不同——这是不变量的正用。反过来，四样全同能不能断定「同一个码」？不能。下面是本篇自己找的最小反例（用 notes/wanted-code-equivalence/check_pair.py 穷举全部 6 比特 3 位信息的经典码，按直方图分组、再按换编号判等价；本篇另把 n ≤ 5 的全部经典码穷举了一遍，没有这样的一对，所以 6 比特是最短的），它是经典码，8 个码字都能手写出来：

Change direction: ignore the bytes and look only at quantities unchanged by clothes. n, k, d, weight histogram: if any of the four differs, the two codes certainly differ. That is the proper use of an invariant. Conversely, does agreement on all four prove “the same code”? No. Below is the smallest counterexample this guide found itself (the script notes/wanted-code-equivalence/check_pair.py exhausts every classical code with 6 bits and 3 information bits, groups them by histogram, then tests equivalence under renumbering; this guide also exhausted every classical code with n ≤ 5 and found no such pair, so 6 bits is the shortest); it is a classical code, and all 8 codewords can be written by hand:

记号：码字 = 码里合法的 0/1 串。这里的「码」用生成行写：三行的所有按位和（含全零）就是全部 8 个码字。同一个码也可以改用一份检查清单来写（列出所有码字都通过的检查），两种写法描述的是同一组码字，本篇不区分。「甲」「乙」只是名字。

Notation: a codeword = a legal 0/1 string of the code. The codes here are written by generator rows: all bitwise sums of the three rows (including all-zero) are the 8 codewords. The same code can instead be written as a check list (the checks every codeword passes); both writings describe the same set of codewords, and this guide does not distinguish them. “A” and “B” are just names.

前四行完全一样：n、k、d、直方图都分不开甲和乙。最后一行分开了它们，而且分得很牢：「两个码字有没有共用的比特」在换编号之后不会变（名字变了，共用还是共用），所以甲不可能是乙换了编号。人话：不变量相同只说明「还没找到区别」，不说明「没有区别」；而找到一个不同的不变量，就一票否决。Wanted 板要的「beyond (n, k, d-bounds, weight histograms)」，就是要一套足够细、细到「全相同 ⇒ 必是同一个码」的不变量——这就是典范指纹。上面这一对是经典码，但同样的盲区在量子码里也有。做法：甲的「检查」是那些与甲的每个码字都有偶数个共同 1 的 0/1 串（共 8 个，含全零）；把每条检查写成泡利串，1 的位置放 Z、0 的位置放 I，就得到一个全 Z 型的量子码。乙同样处理。下表是本篇用脚本算出的生成元，其余检查都是它们的乘积：

The first four rows agree completely: n, k, d and the histogram cannot tell A from B. The last row separates them, and firmly: “do two codewords share a bit?” cannot change under renumbering (names change, sharing does not), so A cannot be B renumbered. In plain words: equal invariants only mean “no difference found yet”, not “no difference”; whereas one differing invariant is a veto. What the board wants with “beyond (n, k, d-bounds, weight histograms)” is a set of invariants fine enough that “all equal ⇒ the same code”, which is precisely a canonical fingerprint. The pair above is classical, but the same blind spot exists for quantum codes. The recipe: the “checks” of A are the 0/1 strings that share an even number of 1s with every codeword of A (8 of them, including all-zero); write each as a Pauli string with Z where it has a 1 and I where it has a 0, and you get an all-Z quantum code. Do the same for B. The table gives the generators computed by script for this guide; every other check is a product of them:

手核一条：ZIIZZZ 碰第 1、4、5、6 位，甲的码字 111001 在这四位上是 1、0、0、1，共同的 1 有两个，偶数，所以通过。k：每边 3 条独立的检查、6 个比特；检查全是 Z，乘不出 −I，所以 k = 6 − 3 = 3。d：一条 X 串通过全部 Z 检查，当且仅当它的 1 的位置组成一个码字，所以最轻的 X 型逻辑算符重 2；而任何一个比特上的单个 Z 与所有检查对易（Z 与 Z 对易），却不在检查组的 8 个元素里（它们的重量只有 0、2、4、6），所以它通过全部检查、本身又不是检查，是一个重量 1 的逻辑算符：d = 1。表中第二行数的是检查组的全部 8 个元素（三条生成元任取几条相乘，一条也不取就是 I）。最后，能把一份全 Z 清单变成另一份全 Z 清单的单比特改名，只能在每个比特上保持 Z 不变（ZZZZZZ 在检查组里，每个比特都被碰到），所以这两个量子码是否局部等价，就等于甲、乙能否换编号互变：不能。n、k、d、检查的重量直方图全同，码却不同。（脚本：notes/wanted-code-equivalence/quantum_pair.py。）

Check one by hand: ZIIZZZ touches bits 1, 4, 5, 6; the codeword 111001 of A reads 1, 0, 0, 1 there, two shared 1s, even, so it passes. k: 3 independent checks on 6 qubits on each side; all checks are Z, so no product gives −I, and k = 6 − 3 = 3. d: an X string passes every Z check exactly when the positions of its 1s form a codeword, so the lightest X-type logical operator has weight 2; but a single Z on any qubit commutes with every check (Z commutes with Z) and is not among the 8 elements of the check group (their weights are only 0, 2, 4, 6), so it passes every check without being a check: a logical operator of weight 1, and d = 1. The table's second row counts all 8 elements of the check group (products of any choice of the three generators; choosing none gives I). Finally, a single-qubit renaming that turns one all-Z list into another all-Z list must keep Z as Z on every qubit (ZZZZZZ is in the check group, so every qubit is touched), so whether the two quantum codes are locally equivalent is exactly whether A and B are renumberings of each other: they are not. Same n, k, d and check weight histogram, different codes. (Script: notes/wanted-code-equivalence/quantum_pair.py.)

机器只认字节，所以「这两张卡其实是一回事」这类话今天全部由人来写，写成卡片上有类型的关系relation：card.yaml 里 relations 列表下的一条记录，四个字段：type（受控词表里的类型）、target（另一张卡的 id）、how（一句话说怎么回事）、refs（文献键）。origin 标 curated，即人手登记。。受控词表里与「同一」有关的类型有 same_bulk_phase_as（内部是同一种物相：「内部」指远离边界的地方，「同一种物相」指在那里看是同一种东西，比如都由同样的星和面检查拼成）、special_case_of（是……的特例）、product_of（是……的乘积）等；这类边的 origin 一律是 curated——「人手登记的」，不是机器算出的。看两条真实的边怎么写「同一」，又怎么小心地不写满：

Since the machine recognises only bytes, every sentence of the form “these two cards are really the same” is written by people today, as a typed relationA record under the relations list of card.yaml with four fields: type (from a controlled vocabulary), target (another card's id), how (one sentence), refs (bibkeys). Its origin is curated, i.e. registered by hand. on the card. The controlled vocabulary's identity-flavoured types include same_bulk_phase_as (the same phase inside: “inside”, the bulk, means away from any boundary, and “the same phase” means that there it looks like the same thing, for instance built from the same star and plaquette checks), special_case_of and product_of; the origin of such edges is always curated, “registered by hand”, never machine-derived. Two real edges show how “the same” is written, and how carefully it is not over-written:

两句都在说「像」，也都在最后一句划清「不是同一个码」：环面码有 k = 2、表面码有 k = 1，内部一样但码空间（能通过全部检查的量子态的全体）不同；蜂窝码的每一帧要先「把刚测过的每对比特合成一个比特」（原文 contracting，比特数减半——这已经超出 1.3 节三种换衣服的范围），再做单比特换基（原文 “local Clifford change of basis”，即操作 ②），才像环面码，而整部电影不是。这正是人写边的好处——能写下细微的限定；也是坏处——只有人想到了、写了，边才存在。下表前两行各是同一个码穿着两套衣服：第一行有一条人画的边和一个机器算出的视图（恰好是字节完全一致的情形），第二行机器不认，人也还没画。第三行只在格子和边界都对得上时才是同一个码，每个条目都要单独写出那件衣服：

Both say “alike”, and both end by drawing the line “not the same code”: the toric code has k = 2, the surface code k = 1, same bulk but different code spaces (the code space is the set of all quantum states passing every check); every frame of the honeycomb code first has “each just-measured pair of qubits merged into one” (the card's “contracting”, halving the qubit count, which already lies outside the three changes of clothes of 1.3) and then a single-qubit change of basis (the card's “local Clifford change of basis”, move ②) before it looks like a toric code, and the whole movie is not one. That is the virtue of hand-written edges, they can carry fine print; and their vice, an edge exists only when someone thought of it and wrote it. The first two rows of the table are each one code in two outfits: the first has a hand-drawn edge and a machine-derived view (precisely the byte-identical case), the second is unrecognised by the machine and not yet drawn by hand. The third row is one code only when the lattice and the boundaries match, and each entry needs its own explicit change of clothes:

第二行最值得停一下。gross 的两张卡登记的是同一张矩阵，一张写 d = 12 bounded，一张写 d = ?。两个字都是诚实的：家族卡的实例有两份证书（文献下界 + 随机搜索找到的重量 12 见证，《大码的码距》第 2 章），成员卡是 T1 层级、只重算了秩。但一个读 QEC-Bank 的人看到「d = ?」，无法从卡片上得知隔壁就有 bounded 的答案——因为没有任何机器认得出这两张矩阵是一回事，也没有人画那条边。

The second row deserves a pause. The two gross cards register the same matrix; one says d = 12 bounded, the other d = ?. Both words are honest: the family card's instance has two certificates (a literature lower bound plus a weight-12 witness found by random search, “Distance for large codes”, Chapter 2), the member card is tier T1 and recomputed ranks only. But a reader of the QEC-Bank who sees “d = ?” cannot learn from the card that a bounded answer sits next door, because no machine recognises the two matrices as one, and nobody has drawn that edge.

「the zoo」指 Error Correction Zoo，QEC-Bank 把自己的条目映射到它的实体上；今天 codes/ 目录下有 184 张 card.yaml（本篇数的）。「Dedup」= 去重。有了判定程序，第 2 章那三处「没有边」会发生什么？

“The zoo” is the Error Correction Zoo, onto whose entities the QEC-Bank maps its own entries; today the codes/ directory holds 184 card.yaml files (counted for this guide). “Dedup” = deduplicate. With a decision procedure, what happens at the three “no edge” places of Chapter 2?

注意会翻的是哪个词：不是 d 的数值（那是另一道开放问题），而是关系边的 origin——从 curated（人说的）变成 derived / verified（机器算的）——以及本来空着的字段能否安全地继承。「安全」两个字有分量：码距在局部等价下不变（1.3 节说明了为什么），所以继承 d 是合法的；而阈值、译码器表现这类依赖具体电路的数字不能跟着边走：Surface Code 关系导读 4.2 节正好给了例子：同一块格子、同样边界上的 XZZX 与 CSS 表面码，码空间被交错比特上的 H_ad 一一映过去（2.3 节），码距相同；但同一种噪声打在换过基的比特上，「在检查眼里」变了样，所以阈值物理错误率低于它时，码做得越大，逻辑错误越少。要看噪声和译码器。X、Y、Z 三种错误一样常见的噪声（去极化噪声）在 H_ad 下不变（H_ad 只把 X、Z 对调，Y 仍是 Y），配上相应换过基的译码器，两个码面对的是同一道题；而只有 Z 错误的噪声下，Bonilla Ataides 等人（arXiv:2009.07851；检查结果不出错的 code-capacity 设定，近似最大似然的张量网络译码器，开边界）报告 XZZX 的阈值约 50%，CSS 表面码只有 10.8(1)%；BB 关系导读 4.4 节也讲过哪些数字不能跨轴照抄。

Note which word flips: not the value of d (that is another open problem) but the origin of relation edges, from curated (said by a person) to derived / verified (computed by a machine), and whether empty fields can be safely inherited. “Safely” carries weight: the distance is unchanged under local equivalence (1.3 explained why), so inheriting d is legitimate; whereas circuit-dependent numbers such as thresholds and decoder performance must not travel along the edge: §4.2 of the Surface Code relations guide gives exactly such an example: on the same lattice with the same boundaries, the code spaces of the XZZX and the CSS surface code are mapped onto each other by H_ad on alternating qubits (2.3), and the distance is the same; but the same noise landing on re-based qubits “looks different to the checks”, so the thresholdThe physical error rate below which making the code larger makes logical errors rarer. depends on the noise and the decoder. Noise in which X, Y and Z errors are equally likely (depolarizing noise) is unchanged by H_ad (it only swaps X and Z; Y stays Y), so with a decoder re-based the same way both codes face the same problem; under pure Z noise, Bonilla Ataides et al. (arXiv:2009.07851; code-capacity setting with error-free check outcomes, an approximate maximum-likelihood tensor-network decoder, open boundaries) report a threshold of about 50% for XZZX against 10.8(1)% for the CSS surface code; §4.4 of the BB relations guide likewise lists numbers that must not be copied across axes.

第二个理由里的三个词，在 QEC-Bank 卡片上都有出处。它们不是三个码，而是描述码的三种语言，本篇只能说清它们是什么类型的东西、QEC-Bank 怎么登记它们，不推导内容——这三种语言都远超高中范围。

The three words in the second reason all have a home on QEC-Bank cards. They are not three codes but three languages for describing codes; this guide can only say what kind of thing each is and how the QEC-Bank records it, without deriving content, since all three lie far beyond high-school level.

三段话今天都是 curated 的视图：一段英文描述、几个文献键，没有任何机器检查「这段话描述的和检查矩阵里存的是同一个码」。「unify」要的就是这台机器：把 quon 图、parton 表达式、Majorana 表达式各翻译回一份检查清单，再用局部等价判定它们是不是同一个码。翻译那一步是费米子编译器那道问题；判定这一步是本篇这道。两道题一起解，三段并排的话才变成一句被核对过的话。

All three are curated views today: an English description and a few bibkeys, with no machine checking “what this paragraph describes is the same code as the stored check matrix”. “Unify” asks for exactly that machine: translate the quon picture, the parton expression and the Majorana expression each back into a check list, then decide by local equivalence whether they are one code. The translation step is the fermionic-compiler problem; the decision step is this one. Only with both solved do three paragraphs side by side become one checked sentence.

合起来说三件。一，问「我手里这份检查清单，QEC-Bank 里有没有」：今天只能得到「字节一致 / 不一致」的回答，换过编号就查不到。二，问「这两张卡是不是同一个码」：只能看有没有人画过边，没画不代表不是（BB 关系导读用的说法是「尚未调研，不是负结论」）。三，把一张卡上的 verified / bounded 借给另一张：没有等价证明，借了就是抄。这三件事都不需要新的物理，只需要一台判定局部等价的机器——QEC-Bank 今天没有。

Three things in all. One, ask “is this check list in my hand already in the QEC-Bank?”: today the answer is only “bytes identical / not”, and a renumbered copy is invisible. Two, ask “are these two cards the same code?”: only whether someone drew an edge can be seen, and no edge does not mean no (the BB relations guide's phrase is “not yet surveyed, not a negative conclusion”). Three, lend one card's verified / bounded to another: without an equivalence proof, lending is copying. None of the three needs new physics, only a machine deciding local equivalence, and the QEC-Bank has none today.

statement 里有两个「或」着的目标。弱的：一台判定机——输入两份检查清单，输出「局部等价 / 不等价」，并且答「等价」时附上那件衣服（编号对应表、每个比特的改名、代表的换法），让任何人能一步步核对。强的：一枚典范指纹——输入一份清单，输出一串字符，满足 1.4 节的两条性质；有了它，判定机就是「比较两串字符」，而且 184 张卡片只需各算一次、两两比较。分数约分是强的那种；「两个分数交叉相乘看是否相等」是弱的那种。两种都算完整解决；只给出更多不变量（比如第 2 章末那个「共用比特」的问题）算进展，不算解决，因为不变量相同仍推不出等价。

The statement holds two targets joined by “or”. The weak one: a decision machine that takes two check lists and outputs “locally equivalent / not”, attaching, when it says “equivalent”, the outfit itself (the renumbering table, the renaming on each qubit, the change of representatives) so anyone can verify step by step. The strong one: a canonical fingerprint that takes one list and outputs a string with the two properties of 1.4; with it, the decision machine is “compare two strings”, and the 184 cards need one computation each and pairwise comparison. Reducing fractions is the strong kind; “cross-multiply two fractions and compare” is the weak kind. Either counts as a full solution; merely adding more invariants (such as the “shared bits” question at the end of Chapter 2) counts as progress, not as a solution, because equal invariants still do not imply equivalence.

最笨的判定机：把甲的所有衣服都穿一遍，看有没有一件和乙字节一致。衣服有多少件？操作 ① 换编号：n 个比特的排法有 n! 种（n 的阶乘，n × (n−1) × … × 1）。操作 ② 改名：每个比特 6 种，共 6ⁿ 种。两者相乘：

The dumbest decision machine: put every outfit on A and see whether one matches B byte for byte. How many outfits? Move ① renumbering: n qubits can be ordered in n! ways (n factorial, n × (n−1) × … × 1). Move ② renaming: 6 per qubit, 6ⁿ in all. Multiply:

记号：n! 读「n 的阶乘」；6ⁿ 读「6 的 n 次方」；≈ 读「约等于」。这几个数是本篇自己算的。操作 ③（换代表）还没算进去，它另有一大堆。

Notation: n! reads “n factorial”; 6ⁿ reads “6 to the n”; ≈ reads “approximately”. These numbers were computed for this guide. Move ③ (changing representatives) is not yet included and adds a large multitude of its own.

对比《大码的码距》1.4 节的 2¹⁸ = 262 144：码距那道题在 18 比特上一下午能穷举，这道题在 18 比特上就已经是 10²⁹，比宇宙年龄的秒数还多 12 个数量级。换句话说，「换衣服」的自由度比「放错误」的自由度大得多，穷举在玩具尺寸就已经失效。判定机必须绕开枚举，直接看穿衣服——这就回到了不变量。

Compare 2¹⁸ = 262 144 from §1.4 of “Distance for large codes”: the distance problem can be exhausted in an afternoon at 18 qubits, while this problem is already 10²⁹ at 18 qubits, twelve orders of magnitude more than the age of the universe in seconds. In other words, the freedom of “changing clothes” is far larger than the freedom of “placing errors”, and exhaustion fails already at toy size. A decision machine must bypass enumeration and see through the clothes directly, which brings us back to invariants.

Wanted 板给每道题两种难度。hard-engineering = 「知道怎么做，但要做很多」，比如把一个已有算法接进 QEC-Bank 的验证器；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”, such as wiring an existing algorithm into the QEC-Bank verifier; open-research = “nobody knows how”. This problem is rated open-research. Honestly, where the difficulty lies:

所以这不是「写更多代码」的问题。原则上问题是可判定的——4.2 节的穷举总会停下——缺的是一套算得快、又完备的不变量：「这一套不变量相同 ⇔ 局部等价」这句话，连同算它的方法。在它出现之前，每一样工具都只有一头可信：字节指纹说「相同」时可信（指纹相同 ⇒ 字节几乎必然一致，再逐字节比一遍就成了证明；字节一致 ⇒ 同一份清单），说「不同」时不可信（H₁、H₂ 字节不同却是同一个码）；不变量说「不同」时可信，说「相同」时不可信。本篇不假装知道那套完备的不变量长什么样；也没有查证研究文献里针对经典码（只有操作 ①、③）的判定算法已经走到哪一步。这里说的「缺」，是 QEC-Bank 的缺，以及 Wanted 板对量子情形的判断。

So this is not a “write more code” problem. In principle the question is decidable, the exhaustion of 4.2 always terminates; what is missing is a set of invariants that is fast to compute and complete: the sentence “this set of invariants agrees ⇔ locally equivalent”, together with a way to compute it. Until it exists, every tool is trustworthy at one end only: the byte fingerprint when it says “same” (equal fingerprints ⇒ almost certainly equal bytes, and a byte comparison turns that into a proof; identical bytes ⇒ the same list) but not when it says “different” (H₁ and H₂ differ in bytes yet are one code); invariants when they say “different” but not when they say “same”. This guide does not pretend to know what that complete set looks like, nor has it checked how far the research literature has come with deciding equivalence for classical codes (moves ① and ③ only). The “missing” here is what the QEC-Bank lacks, together with the board's judgement on the quantum case.

第一步，确认它们的四个不变量确实相同（表已给出；重量直方图请自己数一遍 8 个码字）。第二步，找一个换编号不变的量并算出不同的值：数「重量 2 的码字对中，共用比特的对数」。甲：000011 与 000101 共用第 6 位，000011 与 000110 共用第 5 位，000101 与 000110 共用第 4 位——3 对。乙：三个重量 2 码字互不相交——0 对。换编号只改名字不改「共用」，所以 3 ≠ 0 一票否决：甲不是乙的换编号版本。第三步（可选），验证甲、乙各自的三行确实生成表里的 8 个码字：把三行两两相加、三行全加，再加上全零串。

Step one, confirm the four invariants really agree (the table gives them; count the weight histogram yourself over the 8 codewords). Step two, find a quantity unchanged by renumbering and compute different values: count “pairs of weight-2 codewords that share a bit”. A: 000011 and 000101 share bit 6, 000011 and 000110 share bit 5, 000101 and 000110 share bit 4: 3 pairs. B: the three weight-2 codewords are pairwise disjoint: 0 pairs. Renumbering changes names, not sharing, so 3 ≠ 0 is a veto: A is not a renumbered B. Step three (optional), verify that the three rows of A and of B generate the 8 codewords in the table: add the rows pairwise, add all three, and include the all-zero string.

下面的 BB 实验台预设为 toric3：A = 1 + x、B = 1 + y、l = m = 3。它按 BB 的配方（BB 直觉教程 3.1 节）从两个多项式造出一张 18 比特的检查矩阵，读数里两块矩阵的秩各 8，k = 18 − 16 = 2（检查全是纯 X 或纯 Z，这个减法成立）。点一条检查，数它的 4 条腿：这就是环面码的星与面。构造器把比特分成「左层 9 个、右层 9 个」：对这组 A、B，左层就是横边，右层就是竖边；和 1.2 节沙盘相比，只是比特排列的先后次序不同，也就是只差操作 ①（换编号）。同一个码还可以由第三台机器造出：超图积 HGP(C₃, C₃)（qLDPC 教程 3.1 节）。三台机器、一个码：toric 卡片与超图积之间有一条人画的边和一个机器 derived 的视图（2.3 节；两台构造器恰好逐字节一致），而 BB 的 toric_L3 与它们之间没有任何边、任何比对。

The BB bench below is preset to toric3: A = 1 + x, B = 1 + y, l = m = 3. Following the BB recipe (BB intuition guide, §3.1) it builds an 18-qubit check matrix from the two polynomials; the readout shows both blocks with rank 8, k = 18 − 16 = 2 (every check is pure X or pure Z, so the subtraction holds). Click a check and count its 4 legs: these are the toric code's stars and plaquettes. The builder splits the qubits into “9 in the left layer, 9 in the right”; for this A and B the left layer is exactly the horizontal edges and the right layer the vertical edges, and compared with the sandbox of 1.2 only the order in which the qubits are listed differs, i.e. move ① (renumbering) alone. The same code is built by a third machine as well, the hypergraph product HGP(C₃, C₃) (qLDPC guide, §3.1). Three machines, one code: between the toric card and the hypergraph product there is a hand-drawn edge and a machine-derived view (2.3; the two constructors happen to agree byte for byte), while between BB's toric_L3 and either of them there is no edge and no comparison at all.

先用一条检查把配方从头走一遍，这样读数里的每个记号都有着落。每个比特有一个名字 L(i, j) 或 R(i, j)：L = 左层，R = 右层；(i, j) = 它所在的格点，i 向右数、j 向上数，都从 0 开始，按 l、m 取余（在环面上走出右边就回到左边）。多项式的每一项是一步平移：1 = 原地不动，x = 向右一格，y = 向上一格，x^ay^b = 向右 a 格、向上 b 格。配方只有两句：

First walk the recipe through for one check, so that every symbol in the readout has something to stand on. Each qubit has a name L(i, j) or R(i, j): L = left layer, R = right layer; (i, j) = its site, i counted to the right and j upwards, both from 0 and taken modulo l and m (on the torus, walking off the right edge brings you back on the left). Each term of a polynomial is one translation: 1 = stay, x = one cell right, y = one cell up, x^ay^b = a cells right and b cells up. The recipe is two sentences:

• 格点 (i, j) 上的 X 检查：A 的每一项从 (i, j) 出发向前走一步，落到左层的一个比特；B 的每一项同样向前走，落到右层的一个比特。
• 格点 (i, j) 上的 Z 检查：B 的每一项倒着走一步（x 变成向左、y 变成向下），落到左层；A 的每一项倒着走，落到右层。

• The X check at site (i, j): each term of A takes one step forward from (i, j) and lands on a left-layer qubit; each term of B steps forward the same way and lands on a right-layer qubit.
• The Z check at site (i, j): each term of B takes one step backwards (x becomes one cell left, y one cell down) and lands on the left layer; each term of A steps backwards onto the right layer.

对 toric3、格点 (0, 0)，四条腿是这样来的（3 取余：−1 就是 2）：

For toric3 at site (0, 0) the four legs come out like this (modulo 3, −1 is 2):

为什么 Z 检查要倒着走：这两条检查共用 L(0,0) 和 R(0,0) 两个比特，偶数个，所以对易（每个共用比特上 X 与 Z 反对易一次，两次抵消）；配方保证任何一条 X 检查和任何一条 Z 检查都共用偶数个比特，理由见 BB 直觉教程 3.2 节（一行证明：AB = BA，再用 1 + 1 = 0）。实验台打开时选中的就是 X 检查 (0, 0)，四个被碰到的比特旁标着它们的名字，读数里写着每条腿来自哪一项；点它左下方半格处的小方块，就看到 Z 检查 (0, 0)。（这张表由 notes/wanted-code-equivalence/check00.py 按构造器同样的规则复算。）

Why the Z check steps backwards: these two checks share the two qubits L(0,0) and R(0,0), an even number, so they commute (on each shared qubit X and Z anticommute once, and two such signs cancel); the recipe makes every X check share an even number of qubits with every Z check, for the reason given in the BB intuition guide, §3.2 (a one-line proof: AB = BA, then 1 + 1 = 0). When the bench opens, the selected check is the X check (0, 0); its four qubits are labelled with their names, and the readout says which term each leg comes from. Click the small square half a cell below and to the left of it to see the Z check (0, 0). (The table was recomputed by notes/wanted-code-equivalence/check00.py with the constructor's own rules.)

怎么用：输入框「A 的项」「B 的项」里，每一项写成两个用逗号隔开的整数 a,b，代表 x^ay^b；项与项之间用空格隔开。toric3 的 A = 1 + x 写成 0,0 1,0，B = 1 + y 写成 0,0 0,1。滑块改 l、m。

读数里的记号：x、y = 两个平移方向（向右、向上一格）；l、m = 环面在这两个方向的格数；A、B = 两个多项式。H_X = 全部 X 检查排成的 0/1 矩阵，每行一条检查、每列一个比特，前 l·m 列是左层、后 l·m 列是右层；H_X = [A | B] 说的是左半块按 A 的项填、右半块按 B 的项填。H_Z = [Bᵀ | Aᵀ] 同理，ᵀ = 转置（行列互换），在这里就是「倒着走」。H_XH_Zᵀ = 0 = 每条 X 检查与每条 Z 检查共用偶数个比特，即两两对易。rank = 一组检查里独立的条数。列号 = 比特在矩阵里的列：L(i, j) 是 i·m + j，R(i, j) 是 l·m + i·m + j（例如 R(0,1) 是 9 + 0 + 1 = 10）。d_X = 最轻的 X 型逻辑算符的重量；「见证」= 搜索找到的那条 X 逻辑算符本身。C₃ = 3 比特周期重复码。

How to use it: in the boxes “A terms” and “B terms” write each term as two integers separated by a comma, a,b, meaning x^ay^b, with a space between terms. toric3's A = 1 + x is 0,0 1,0 and B = 1 + y is 0,0 0,1. The sliders change l and m.

Symbols in the readout: x, y = the two translation directions (one cell right, one cell up); l, m = the torus size in those directions; A, B = the two polynomials. H_X = the 0/1 matrix of all X checks, one row per check and one column per qubit, the first l·m columns for the left layer and the last l·m for the right; H_X = [A | B] says the left half is filled from the terms of A and the right half from B. H_Z = [Bᵀ | Aᵀ] likewise, with ᵀ = transpose (rows and columns swapped), which here means “step backwards”. H_XH_Zᵀ = 0 = every X check shares an even number of qubits with every Z check, i.e. they all commute. rank = the number of independent checks in a list. Column number = the qubit's column in the matrix: L(i, j) is i·m + j, R(i, j) is l·m + i·m + j (R(0,1), for example, is 9 + 0 + 1 = 10). d_X = the weight of the lightest X-type logical operator; the “witness” = that X logical operator itself, as found by the search. C₃ = the periodic 3-bit repetition code.

两道相邻的开放问题。板上 subsystem-dressed-distance 的 related 字段列出了本篇（related: [code-equivalence, certified-lower-bounds]），它的 statement 里要的 “equivalence-safe subsystem presentations”，以及 why_it_matters 里的 “proof that gauge-equivalent presentations preserve the claimed quantity”，就是本篇的问题在「有不在乎比特的码」上的版本：《不在乎的比特，与穿了衣服的码距》。而对随时间变化的码，「衣服」变成了「测量的先后次序」：《两张测量时间表是不是同一回事》。本篇的 yaml 自己的 related 是空的（related: []），没有 working_repo。QEC-Bank 里的实物。BB 关系导读（2.3 节相切的那一点、3.3 节两张 gross 卡）、Surface Code 关系导读（1.2 节两条边的格式、4.2 节 XZZX 的换基）、qLDPC 教程 3.1 节（HGP 造出表面码与环面码）。

Two neighbouring open problems. The related field of the board item subsystem-dressed-distance lists this one (related: [code-equivalence, certified-lower-bounds]); the “equivalence-safe subsystem presentations” in its statement and the “proof that gauge-equivalent presentations preserve the claimed quantity” in its why_it_matters are this guide's problem for codes with don't-care qubits: “Don't-care qubits and the dressed distance”. For codes that change in time, the “clothes” become “the order of measurements”: “Are two measurement schedules the same thing?”. This item's own yaml has an empty related (related: []) and no working_repo. The real objects in the QEC-Bank. BB relations guide (§2.3 the point of tangency, §3.3 the two gross cards), Surface Code relations guide (§1.2 the format of its two edges, §4.2 the XZZX change of basis), qLDPC guide §3.1 (HGP building the surface and toric codes).

回放一遍。一个码不是它的检查清单，而是清单生成的全部检查；换编号、单比特改名、换一组代表，三种操作都不改变码，合称局部等价。QEC-Bank 今天有 184 张卡，判定「同一个码」的工具只有两样：checkmatrix_fingerprint——把矩阵字节按原顺序交给 SHA-256，三种换衣服都会让它改变，所以它只认字节一致的复制品；以及人手登记的 curated 边，写得细，但没人写就没有。环面码 [[18,2,3]] 以 toric_L3、HGP(C₃,C₃)、toric 三副面孔出现，只有 toric 与 HGP 之间有边（因为字节恰好一致）；gross 的同一张矩阵在两张卡上分别写 d = 12 bounded 与 d = ?，中间没有边。n、k、d、重量直方图这四样不变量能一票否决、不能一票通过：一对 6 比特经典码四样全同却不是换编号能变到的。合格的答案是一台判定机或一枚典范指纹；问题原则上可判定，但穷举衣服在 18 比特上已是 10²⁹，而 QEC-Bank 手里没有「算得快又完备的不变量」，Wanted 板把它标为 open-research。

Replay. A code is not its check list but everything the list generates; renumbering, renaming letters on single qubits and changing representatives leave the code unchanged and together are called local equivalence. The QEC-Bank holds 184 cards today and has two tools for “the same code”: checkmatrix_fingerprint, which feeds the matrix bytes in their original order to SHA-256 and changes under all three changes of clothes, so it recognises only byte-identical copies; and hand-registered curated edges, precise in their fine print but absent unless someone writes them. The toric code [[18,2,3]] appears with three faces, toric_L3, HGP(C₃,C₃) and toric, and only toric and HGP are joined by an edge (their bytes happen to agree); gross's one matrix reads d = 12 bounded on one card and d = ? on another, with no edge in between. The four invariants n, k, d and weight histogram can veto but never approve: a pair of 6-bit classical codes agrees on all four yet is not reachable by renumbering. A qualifying answer is a decision machine or a canonical fingerprint; the question is decidable in principle, but exhausting outfits is already 10²⁹ at 18 qubits, and the QEC-Bank has no “fast, complete invariants”; the board rates it open-research.