三个数字，
和每个数字背后的证据词 Three numbers,
and the evidence word behind each

量子纠错码的通用名片是[[n, k, d]]双方括号是量子码的记法（单方括号 [n,k,d] 留给经典码）：n 个物理量子比特，编码 k 个逻辑量子比特，码距 d。：n 个物理量子比特，一起保护 k 个逻辑量子比特（n、k 的记账规则见 Toric Code 直觉教程的「记账」一节）；d 是码距能通过全部检查、却改写逻辑信息的最轻算符（逻辑算符）的重量，即它触碰的量子比特数。，即一个不触发任何警报、却改写了逻辑信息的算符最少要碰几个比特（码距首次定义于 Toric Code 直觉教程「它的致命弱点」一节）。这样的算符叫逻辑算符；它碰到的比特数叫它的重量。在直觉教程里你已经数过这三个数：账本给出 k = 1，最短的横跨串给出 d。

The universal calling card of a quantum code is [[n, k, d]]Double brackets denote a quantum code (single brackets [n,k,d] are reserved for classical codes): n physical qubits encoding k logical qubits with distance d.: n physical qubits jointly protecting k logical qubits (the n, k bookkeeping rule is in the toric guide's “ledger” section), and d the distanceThe weight, i.e. the number of qubits touched, of the lightest operator that passes every check yet rewrites the logical information (a logical operator).: the smallest number of qubits that an operator must touch in order to trip no alarm and still rewrite the logical information (distance was first defined in its “fatal flaw” section). Such an operator is a logical operator; the number of qubits it touches is its weight. You have counted all three in the intuition guide: the ledger gave k = 1, and the shortest spanning string gave d.

本篇反复出现的 QEC-Bank（QEC-Bank）是本系列所属的量子纠错码数据库。它为每个码建一个条目；条目里有一段生成检查矩阵的程序（叫构造器），一份实例清单，清单上的每个数字都附一个说明来源的词；另有一个验证器程序，重新运行构造器、重新计算这些数字，与清单比对。第 3 章会细看这套记账。

The QEC-Bank (QEC-Bank) that keeps appearing on this page is the database of quantum error-correcting codes this series belongs to. Each code gets an entry; the entry holds a program that generates the check matrices (the constructor) and a list of instances in which every number carries a word saying where it comes from; a separate program, the verifier, reruns the constructor, recomputes those numbers and compares them with the list. Chapter 3 looks at this bookkeeping closely.

但「表面码是 [[?, 1, ?]]」的问号填不上：表面码不是一个码，而是一族码，芯片可以做成 3×3、5×5、7×7。要生成一个具体的码，得先告诉构造器一个数。那个数就是家族变量生成一族码中某一个成员所需的输入参数。表面码条目只有一个：L，取值 L ≥ 2 的整数（奇偶皆可）。 L。QEC-Bank 的参数页只登记了这一个变量，并标注「distance (odd or even, L ≥ 2)」：L 既是格子的边长，也（如第 2 章将证明的）恰好等于码距。给 L 一个具体值，构造器就吐出一个实例家族变量取定具体值后得到的那一个有限码对象，有确定的检查矩阵和确定的 [[n,k,d]]。QEC-Bank 用标签 L3、L4、L5 命名。——一个有限的、可以逐比特写出来的码对象。QEC-Bank 为表面码发布了三个实例，标签就叫 L3、L4、L5。

Yet the blanks in “the surface code is [[?, 1, ?]]” cannot be filled: the surface code is not one code but a family, and the chip can be 3×3, 5×5, 7×7. To produce a concrete code you must first hand the constructor a number. That number is the family variableThe input parameter that selects one member of a code family. The surface-code entry has exactly one: L, an integer with L ≥ 2 (odd or even). L. The QEC-Bank parameters page registers this single variable, annotated “distance (odd or even, L ≥ 2)”: L is the side length of the grid and, as Chapter 2 will prove, exactly the distance. Give L a concrete value and the constructor emits an instanceThe one finite code object obtained once the family variable is fixed: a definite check matrix and a definite [[n,k,d]]. The QEC-Bank labels them L3, L4, L5.: a finite code object whose every qubit and check can be written down. The QEC-Bank ships three surface-code instances, labelled L3, L4, L5.

必须说清一次：QEC-Bank 的构造器（程序文件 codes/surface/constructor.py）生成的是未旋转的平面表面码，即直觉教程里那块左右毛边、上下光边的版图，检查方块的边与芯片的边平行；QEC-Bank 内部给这个对象的编号是 atlas-entity:surface#subject。文献里同样叫「表面码」的还有好几种别的码：把版图斜着转 45° 裁出来、更省比特的旋转版（第 4.2 节画出它）；每条检查混用 X 和 Z 的 XZZX 版；在格子里引入错位（twist，错位处的检查混用 X 和 Z）的扭缺陷版；以及三维版。它们都不在本篇的参数和实例表里。第 4 章会拿旋转版做一次比较，但那是引用文献的数字，不是构造器算出来的。

This must be said once, plainly: the QEC-Bank constructor (the program file codes/surface/constructor.py) builds the unrotated planar surface code, the very patch with rough left/right and smooth top/bottom boundaries from the intuition guide, whose check squares are aligned with the edges of the chip; the QEC-Bank's internal identifier for this object is atlas-entity:surface#subject. The literature uses the name “surface code” for several other codes too: the rotated patch, cut out at 45° and cheaper in qubits (drawn in §4.2); the XZZX variant, whose every check mixes X and Z; twist-defect versions, which introduce a dislocation (a twist, where the checks mix X and Z) into the lattice; and three-dimensional versions. None of them is in this guide's parameter and instance tables. Chapter 4 will compare against the rotated patch once, but those are literature numbers, not constructor output.

构造器不是画图再数点。它从一个经典码出发：长度 L 的重复码。把 L 个比特排成一行，每两个相邻比特之间放一条检查「这两位相等吗」，一共 L − 1 条检查。于是链上比特和检查交替出现：比特 0、检查 0、比特 1、检查 1、……、比特 L−1，每条检查碰它左右两个比特。写成矩阵就是重复码校验矩阵 Hrep_parity(L)：一个 (L−1)×L 的 0/1 矩阵，行是检查、列是比特，每行是「相邻两位 1 1」。它描述经典重复码「相邻比特必须相等」的 L−1 条检查。：行是检查，列是比特，L = 3 时 H 的两行是 (1, 1, 0) 和 (0, 1, 1)。

The constructor does not draw a picture and count dots. It starts from a classical code: the repetition code of length L. Put L bits in a row and place a check “are these two equal?” between every pair of neighbours, L − 1 checks in all. Along the chain, bits and checks alternate: bit 0, check 0, bit 1, check 1, …, bit L−1, and each check touches the bit on its left and the bit on its right. As a matrix this is the repetition-code check matrix Hrep_parity(L): an (L−1)×L binary matrix, rows = checks, columns = bits, each row reading “adjacent pair 1 1”. It encodes the L−1 checks “neighbouring bits must agree” of the classical repetition code.: rows are checks, columns are bits; for L = 3 its two rows are (1, 1, 0) and (0, 1, 1).

构造器把两条这样的链「相乘」，这一步叫超图乘积HGP（hypergraph product，Tillich 与 Zémor 2009）：把两个经典码「相乘」得到一个 CSS 量子码的通用配方。两条链的成员两两配对，（比特, 比特）与（检查, 检查）成为量子比特，（检查, 比特）成为 X 检查，（比特, 检查）成为 Z 检查。（记作 HGP(rep_L, rep_L)）。它造出的是一个 CSS 码Calderbank–Shor–Steane 码：检查分成两族，一族每条只由 X 组成，另一族每条只由 Z 组成；没有一条检查混用 X 和 Z。：检查分成两族，一族每条只放 X（X 检查），另一族每条只放 Z（Z 检查），没有一条检查混用两种字母；名字取自 Calderbank、Shor、Steane 三人。先看它做了什么：链 A 横放在顶上，链 B 竖放在左边，铺出一张棋盘，棋盘的每个格子是一对（A 的一个成员, B 的一个成员）。成员只有「比特」和「检查」两种，所以格子只有四种：

The constructor “multiplies” two such chains; the operation is called the hypergraph productHGP (hypergraph product, Tillich and Zémor 2009): the general recipe that multiplies two classical codes into a CSS quantum code. Members of the two chains are paired up: (bit, bit) and (check, check) become qubits, (check, bit) becomes an X check, (bit, check) a Z check. (written HGP(rep_L, rep_L)). What it builds is a CSS codeCalderbank–Shor–Steane code: the checks come in two families, each check of one family made of X only, each check of the other made of Z only; no check mixes X and Z.: the checks come in two families, one whose checks contain only X (the X checks) and one whose checks contain only Z (the Z checks), and no check mixes the two letters; the name comes from Calderbank, Shor and Steane. First what it does: lay chain A across the top and chain B down the left side to span a board; each cell of the board is one pair (a member of A, a member of B). A member is either a bit or a check, so there are only four kinds of cell:

谁碰谁只有一条规则：一条检查碰它上下左右紧挨着的四个格子（贴着棋盘边缘的检查少一个邻居）。横着走一格，就是在链 A 上从一个检查走到它碰的比特；竖着走一格，就是在链 B 上走同样的一步。把棋盘画出来，你会认出直觉教程的版图：星的左右是横边、上下是竖边，所以星是 XXXX；最上、最下一行的星没有上或下的邻居，只剩三条腿，那就是光边界。面的上下是横边、左右是竖边；最左、最右一列的横边外侧没有检查格，就是毛边界的悬边。下面一步一步拼这张棋盘，点任意一格可以看它是哪一对、碰哪几个比特。

Who touches whom follows one rule: a check touches the four cells directly above, below, left and right of it (a check on the rim of the board has one neighbour fewer). One step across is a step along chain A from a check to a bit it touches; one step down is the same move along chain B. Draw the board and you recognise the intuition guide's patch: a star has horizontal edges on its left and right and vertical edges above and below, so a star is XXXX; stars in the top and bottom rows have no neighbour above or below and keep only three legs, which is the smooth boundary. A plaquette has horizontal edges above and below and vertical edges left and right; the horizontal edges in the leftmost and rightmost columns have no check cell beyond them, and these are the dangling edges of the rough boundary. Build the board step by step below; click any cell to see which pair it is and which qubits it touches.

这张棋盘把三件事一次数清。量子比特是两块之和，检查是另外两块之和，对任何 L 都成立：

The board settles the counting in one go. The qubits are the sum of two blocks and the checks the sum of the other two, for every L:

给读 QEC-Bank 源文件的人：构造器把（比特, 比特）比特 (a, b) 存在坐标 (2b, 2a)，把（检查, 检查）比特存在奇数坐标，并把两块分别叫「顶点比特」和「面比特」。那是另一种画法里的叫法（比特画在顶点和面心上），坐标则是这张棋盘把行列对调的样子；本页一律叫横边比特和竖边比特，免得和「星 = 顶点」混淆。

For readers of the QEC-Bank source: the constructor stores (bit, bit) qubit (a, b) at coordinate (2b, 2a) and the (check, check) qubits at odd coordinates, and calls the two blocks “vertex qubits” and “face qubits”. Those names come from another drawing (qubits on vertices and face centres), and the coordinates are this board with rows and columns swapped; this page says horizontal-edge and vertical-edge qubits throughout, so that nothing clashes with “star = vertex”.

X 检查和 Z 检查各有 L(L−1) 条，两族合计 2L(L−1)。CSS 码的两族检查各写成一个 0/1 矩阵：H_X 每行是一条 X 检查，H_Z 每行是一条 Z 检查，两者的每一列都是同一个比特，1 表示「这条检查碰这个比特」。要用「n − 独立检查数」记账（稳定子计数法），还得确认它们全部独立：没有哪一组检查乘起来等于 I，也就没有哪条检查是别的检查的乘积。线性代数里「独立的行有几条」叫秩rank：一个 0/1 矩阵里线性独立的行数（模 2）。rank = 行数，就是「没有一组行加起来（模 2）等于 0」，即没有一条检查是其他检查的乘积。，所以要证的是 rank(H_X) = rank(H_Z) = L(L−1)。直觉教程说明了全部星的乘积不是 I；这里需要更强的结论：任何一组（至少一颗）星乘起来都不是 I。论证只用每行最左边那条悬边。

There are L(L−1) X checks and L(L−1) Z checks, 2L(L−1) in all. Each family of a CSS code is written as one binary matrix: each row of H_X is an X check, each row of H_Z a Z check, every column of both is the same qubit, and a 1 means “this check touches this qubit”. To use the ledger “n minus independent checks” (the stabilizer count) we must also know that they are all independent: no group of checks multiplies to I, so no check is a product of others. In linear algebra the number of independent rows is the rankThe number of linearly independent rows of a binary matrix (mod 2). rank = number of rows means that no group of rows adds up (mod 2) to 0, i.e. no check is a product of the others., so the claim is rank(H_X) = rank(H_Z) = L(L−1). The intuition guide showed that the product of all stars is not I; here we need more: no group of stars (one or more) multiplies to I. The argument uses only the dangling edge at the left end of each row.

假设有一组星的乘积是 I。只看第 b 行的横边：碰得到它们的只有第 b 行的星，而第 c 颗星碰这一行的第 c 条和第 c+1 条横边（从 0 数起）。最左的悬边（第 0 条）只被第 0 颗星碰到，所以第 0 颗星不在组里，否则悬边上会剩一个 X。第 0 颗不在，第 1 条横边就只剩第 1 颗星能碰到，于是第 1 颗也不在；这样一颗一颗剥到行尾。每一行都剥完，组里一颗星也不剩，与「至少一颗」矛盾。所以 L(L−1) 颗星全部独立。面的论证一样，只是从每一列最上面那条横边往下剥：它只被正下方的那块面碰到。

Suppose some group of stars multiplies to I. Look only at the horizontal edges of row b: only stars of row b touch them, and star number c touches edges c and c+1 of the row (counting from 0). The leftmost, dangling edge (edge 0) is touched by star 0 alone, so star 0 is not in the group, or an X would be left on the dangler. With star 0 out, edge 1 can only be touched by star 1, so star 1 is out too; peel star after star to the end of the row. Once every row is peeled no star is left, contradicting “one or more”. So all L(L−1) stars are independent. The plaquettes work the same way, peeling downward from the top horizontal edge of each column, which is touched only by the plaquette directly below it.

下面这台账本对 d = 2、3、4、5 现场演示同一件事（这里的 d 就是 L）。看清一点：不论 L 多大，n 与检查数永远只差 1。

The ledger below performs the same computation live for d = 2, 3, 4, 5 (this widget's d is our L). Notice: whatever L is, n and the number of checks always differ by exactly 1.

码距是三个数里唯一需要两个方向论证的：上界要找到一个重量 L 的逻辑算符，下界要说明没有更轻的。

Distance is the only one of the three numbers that needs an argument in two directions: the upper bound needs one logical operator of weight L, the lower bound needs a reason why nothing lighter exists.

上界 d ≤ L。在棋盘上取一整行横边，全放 Z，记作 Z̄：它从左边的悬边走到右边的悬边，碰 L 个比特。一颗星若在这一行，就碰这一行里相邻的两条横边；不在这一行就一条也不碰。所以每颗星与 Z̄ 共享 0 或 2 个比特，按碰撞规则全部对易，Z̄ 不触发任何星。面是 Z 型检查，和 Z̄ 天然对易。同理，取一整列横边（每行一条，从上光边到下光边）全放 X，记作 X̄：一块面若在这一列，就碰这一列里上下相邻的两条横边，否则一条不碰，所以 X̄ 骗过全部面。Z̄ 和 X̄ 恰好在一个比特上相交，两者反对易。于是 Z̄ 不是检查的乘积：检查的乘积必须与 X̄ 对易，因为 X̄ 与每一条检查都对易。X̄ 同理。两个重量为 L 的逻辑算符就此到手，这正是直觉教程里横跨两条边界的串。

Upper bound d ≤ L. Take one whole row of horizontal edges on the board and put Z on all of them; call it Z̄. It runs from the dangling edge on the left to the dangling edge on the right and touches L qubits. A star in that row touches two neighbouring horizontal edges of the row; a star in any other row touches none. So every star shares 0 or 2 qubits with Z̄, commutes with it by the collision rule, and Z̄ trips no star. Plaquettes are Z-type and commute with Z̄ automatically. In the same way, take one whole column of horizontal edges (one per row, smooth edge at the top to smooth edge at the bottom) and put X on them; call it X̄. A plaquette in that column touches two vertically neighbouring horizontal edges of the column, any other plaquette none, so X̄ fools every plaquette. Z̄ and X̄ meet on exactly one qubit, so they anticommute. Hence Z̄ is not a product of checks: such a product must commute with X̄, because X̄ commutes with every single check. The same goes for X̄. Two logical operators of weight L are in hand, precisely the boundary-to-boundary spanning strings of the intuition guide.

下界 d ≥ L。要证明「没有更轻的」，候选太多，不能逐个排除。QEC-Bank 的证明改用互不相交的拷贝：Z̄ 可以放在 L 行里的任意一行，这 L 个拷贝两两不共享比特，却是同一个逻辑算符。原因是相邻两行之差恰好是夹在中间那一排面的乘积：每块面碰它上下两条横边，一排面乘起来，两行横边各剩一个 Z，中间的竖边每条被左右两块面各碰一次，成对抵消。乘上检查不改变逻辑内容。

Lower bound d ≥ L. Proving “nothing lighter exists” cannot proceed candidate by candidate; there are far too many. The QEC-Bank proof uses pairwise-disjoint copies instead: Z̄ can sit on any of the L rows, and these L copies share no qubit, yet they are the same logical operator. The reason is that two neighbouring rows differ by exactly the product of the row of plaquettes between them: each plaquette touches the horizontal edge above and the one below it, so the product of a row of plaquettes leaves a Z on each of the two rows of horizontal edges, while each vertical edge in between is touched once by the plaquette on its left and once by the one on its right and cancels. Multiplying by checks does not change the logical content.

现在取任意一个与 Z̄ 反对易的逻辑算符 P。它必须与每一个拷贝都反对易（补课 2.A 解释为什么乘上检查不改变这一点）。与一整行 Z 反对易，意味着 P 在这一行的横边上必须放了至少一个 X 或 Y。L 行两两不交，所以 P 至少碰 L 个比特：wt(P)算符 P 的重量（weight）：它作用的量子比特中，作用不是恒等 I 的那些的个数。 ≥ L。与 X̄ 反对易的 P 用 L 个互不相交的 X̄ 列同样处理。最后一步：只存 1 个逻辑比特时，每个不是检查乘积的逻辑算符都至少与 X̄、Z̄ 之一反对易（补课 2.A）。两边合起来，d = L。下面的棋盘从第 6 步开始，画出这两条串和 Z̄ 的 L 个拷贝。

Now take any logical operator P that anticommutes with Z̄. It must anticommute with every copy (Catch-up 2.A explains why multiplying by checks cannot change that). Anticommuting with a whole row of Z's means P places at least one X or Y on a horizontal edge of that row. The L rows are pairwise disjoint, so P touches at least L qubits: wt(P)The weight of an operator P: the number of qubits on which it acts as something other than the identity I. ≥ L. A P that anticommutes with X̄ is handled the same way by the L disjoint X̄ columns. The last step: with a single logical qubit, every logical operator that is not a product of checks anticommutes with at least one of X̄, Z̄ (Catch-up 2.A). Together, d = L. The board below starts at step 6 and draws the two strings and the L copies of Z̄.

下表逐字转录 QEC-Bank 的实例文件 codes/surface/instances.yaml（一份纯文本清单，每个实例一段，列出它的参数和每条声明）与 QEC-Bank 参数页。每个数字后的斜体词是 QEC-Bank 的证据词QEC-Bank 给每条声明标注来源类别的固定词汇：verified（机器独立重算并相符）、bounded（只有上下界，未穷举）、claimed（引自文献、未重算）等。（QEC-Bank 称 origin kind），说明这个数字是怎么来的：verified = 验证器独立重算、结果相符；bounded = 只记录了一个下界和一个上界；claimed = 引自文献、没有重算（本表没有用到）。dennis2002topological 这样的写法是 QEC-Bank 的文献键：第一作者姓、年份、标题首词，指向文末延伸阅读里的同名条目。

The table transcribes the QEC-Bank instance file codes/surface/instances.yaml (a plain-text list with one block per instance, giving its parameters and every claim) and the QEC-Bank parameters page word for word. The italic word after each number is the QEC-Bank evidence wordThe fixed vocabulary the QEC-Bank attaches to every claim's origin: verified (independently recomputed by machine and matching), bounded (only bounds, no exhaustive check), claimed (cited from literature, not recomputed), and others. (the QEC-Bank calls it the origin kind), saying where the number comes from: verified = the verifier recomputed it independently and it matched; bounded = only a lower and an upper bound are recorded; claimed = taken from the literature without recomputation (not used in this table). A string like dennis2002topological is a QEC-Bank citation key: first author's surname, year, first word of the title; it points to the entry of the same name under Further reading at the end.

三个实例的 css: true 也都是 verified。这一栏说的是：检查确实分成纯 X、纯 Z 两族（2.1 节的 CSS 码），而且两族彼此对易。验证器检查的是 H_XH_Z^T = 0（模 2）。H_Z^T 是 H_Z 的转置把矩阵的行和列对调：原来第 i 行第 j 列的元素搬到第 j 行第 i 列。（行列对调），所以乘积第 i 行第 j 列的元素 = X 检查 i 与 Z 检查 j 同时碰到的比特个数，模 2。它等于 0，就是每一对都共享偶数个比特、全部对易。例：2.2 节折叠「L = 2 手算」的表格里，上行的星与左列的面共享 h₀₀ 和 v，2 个，这个元素是 0。先看最小的那个。下面是 L3 的版图，画法和直觉教程一样：比特在边上（边中点的小圆点），星在顶点，面是方格。数一数，13 个数据比特、6 颗星、6 块面；点几条边制造错误，观察警报。这就是表格第一行所描述的那个有限对象。

All three instances also carry css: true as verified. The field says that the checks really do split into a pure-X and a pure-Z family (the CSS code of §2.1) and that the two families commute. The verifier tests H_XH_Z^T = 0 (mod 2). H_Z^T is the transposeSwap the rows and columns of a matrix: the entry in row i, column j moves to row j, column i. of H_Z (rows and columns swapped), so entry (i, j) of the product is the number of qubits that X check i and Z check j both touch, mod 2. It is 0 exactly when every pair shares an even number of qubits, i.e. all of them commute. Example: in the table of the §2.2 fold “L = 2 by hand”, the top-row star and the left plaquette share h₀₀ and v, two qubits, so that entry is 0. Start with the smallest. Below is the L3 patch, drawn as in the intuition guide: qubits on edges (the small dots at edge midpoints), stars at vertices, plaquettes as squares. Count 13 data qubits, 6 stars, 6 plaquettes; click a few edges to plant errors and watch the alarms. This is the finite object the first table row describes.

n 和 k 的 verified 直白：验证器重新运行构造器，数出矩阵宽度得 n，算两个秩得 k，与实例文件里的声明比对。d 的 verified 要多做一步：exact-css-enum（qeclib/distance.py 里的枚举程序）按重量 1、2、3……的顺序，逐一枚举每一种比特组合上的纯 X 型与纯 Z 型算符，检查它是否骗过全部检查、又不是检查的乘积；第一个这样的算符出现时的重量就是 d。这等于确认了所有更轻的算符要么触发某条检查、要么本身就是检查的乘积，同时出示了一个重量恰为 d 的逻辑算符。只看纯 X 与纯 Z 就够了：CSS 码里 X 检查只看算符的 Z 部分、Z 检查只看 X 部分，所以任何逻辑算符的 X 部分与 Z 部分各自仍骗过全部检查，且至少一个不是检查的乘积，而它们都不比原算符重。这与形式验证页的 Lean 小规模精确码距证书是两套不同的穷举：那份证书把 X、Y、Z 三种 Pauli 全部枚举，不借助 CSS 结构。L3 和 L4 的码距在实例文件里登记为精确值，验证器就对它们跑这个枚举，结果与声明相符，所以这两行的 d 是 verified。

The verified on n and k is straightforward: the verifier reruns the constructor, reads n off the matrix width, computes the two ranks for k, and compares with the claims in the instance file. The verified on d takes one more step: exact-css-enum (the enumeration routine in qeclib/distance.py) goes through weights 1, 2, 3, … in order and enumerates one by one the pure-X and pure-Z operators on every set of qubits of that size, testing whether the operator fools every check without being a product of checks; the weight at which the first such operator appears is d. This confirms that every lighter operator either trips some check or is itself a product of checks, and it exhibits a logical of weight exactly d. Pure X and pure Z suffice: in a CSS code the X checks see only an operator's Z part and the Z checks only its X part, so the X part and the Z part of any logical each still fool every check, at least one of them is not a product of checks, and neither is heavier than the original. This is a different exhaustive method from the Lean small exact-distance certificate of the formal-verification page: that certificate enumerates all three Paulis X, Y, Z without using the CSS structure. The instance file records the distances of L3 and L4 as exact values, so the verifier runs this enumeration on them; the results match, and those two rows carry verified for d.

L5 的码距在实例文件里没有登记成精确值，而是拆成一个下界和一个上界分别记账（下面的原文）。验证器只核对登记的内容，所以对 L5 不跑穷举枚举。这不是算不动：41 个比特上重量 ≤ 4 的纯 X 型、纯 Z 型算符合计约 23 万个（112,791 种比特组合，各试 X 与 Z 两次），我们在工作站上用同一个 exact-css-enum 对 L5 跑了一次，不到 1 秒就返回 d = 5（2026-09-24，脚本见本篇的核对记录）。L5 写成 bounded 是记账方式的选择，下面说清两半各靠什么。下界 d ≥ 5：来自第 2 章的定理，文献出处记为 dennis2002topological（Dennis、Kitaev、Landahl、Preskill，“Topological quantum memory”，2002）。这是推理，不是机器枚举；QEC-Bank 目前的验证器没有核对下界的程序，所以规定下界必须附一条文献出处。上界 d ≤ 5：验证器每次都重跑一次低重量搜索 rand-lowweight-v1（QEC-Bank 的随机低重量搜索，第 1 版）。它随机生成一个骗过另一类全部检查的算符，扔掉恰好是检查乘积的，再反复乘上检查、只要能让重量变小就乘，最后记下最轻的那个；X 型、Z 型各试 2000 次。种子（seed）0 固定了这串随机数，所以谁重跑都得到同一个结果。它找到一个重量 5 的逻辑算符，一个机器可复现的见证。两个 5 相等，所以我们「知道」d = 5；但只要下界不是机器穷举得到的，QEC-Bank 就把这条声明叫 bounded。原文写得很直接：「The word bounded is intentional」。

The instance file does not record L5's distance as an exact value; it splits it into a lower and an upper bound with separate bookkeeping (quoted below). The verifier checks only what is recorded, so for L5 it does not run the exhaustive enumeration. This is not a matter of cost: on 41 qubits the pure-X and pure-Z operators of weight ≤ 4 number about 230,000 (112,791 sets of qubits, each tried once as X and once as Z), and running the same exact-css-enum on L5 on our workstation returned d = 5 in under a second (2026-09-24; the script is in this page's check notes). Writing L5 as bounded is a bookkeeping choice, and here is what each half rests on. Lower bound d ≥ 5: from the Chapter 2 theorem, with literature provenance dennis2002topological (Dennis, Kitaev, Landahl, Preskill, “Topological quantum memory”, 2002). This is reasoning, not machine enumeration; the current QEC-Bank verifier has no routine that checks lower bounds, so its rules demand a literature reference for every lower bound. Upper bound d ≤ 5: on every run the verifier reruns the low-weight search rand-lowweight-v1 (the QEC-Bank random low-weight search, version 1). It draws a random operator that fools every check of the other type, throws it away if it happens to be a product of checks, then keeps multiplying by checks whenever that lowers the weight, and records the lightest result; 2000 tries each for X type and Z type. The seed 0 fixes the sequence of random numbers, so anyone who reruns it gets the same result. It finds a logical of weight 5, a machine-reproducible witness. The two fives agree, so we “know” d = 5; but whenever the lower bound was not obtained by machine enumeration, the QEC-Bank calls the claim bounded. The source says it outright: “The word bounded is intentional”.

这就是 L5 那个有限对象。41 个数据比特、20 颗星、20 块面。试着画一条从左侧悬边到右侧悬边的 Z 链：它需要恰好 5 步，零警报——你亲手复现了 rand-lowweight-v1 找到的那种重量 5 见证。

Here is the L5 finite object: 41 data qubits, 20 stars, 20 faces. Try drawing a Z-chain from a left dangler to a right one: it takes exactly 5 steps and raises zero alarms. You have just reproduced by hand the kind of weight-5 witness that rand-lowweight-v1 finds.

直觉教程打开过那个黑盒：测一条检查，要靠一个辅助比特依次接触四个数据比特再被读出。最常见的排法是每条检查配一个自己的帮手，所有检查同时测。这是一种排法，不是硬性要求：帮手也可以轮流用，测完一条再去测下一条，比特少了，一轮测量要多花几步时间（4.2 节有文献里的例子）。本章按「每条独立检查配一个帮手」计，未旋转版图的总数是数据比特 2d²−2d+1 加上检查数 2d(d−1) = 2d²−2d，也就是比数据比特少 1：

The intuition guide opened that box: measuring one check needs an ancilla that touches the four data qubits in turn and is then read out. The most common layout gives every check a helper of its own and measures all checks at once. That is a scheduling choice, not a requirement: helpers can also take turns, measuring one check and then the next, which saves qubits at the price of a few more steps per round (§4.2 has an example from the literature). This chapter counts one helper per independent check, so the unrotated patch totals its 2d²−2d+1 data qubits plus 2d(d−1) = 2d²−2d checks, one fewer than the data count:

QEC-Bank 的直觉短文和复现脚本 reproduce.py 都记录了一组对照数字，来源是文献而非构造器：旋转版图 [[d², 1, d]]（horsman2012surface，Horsman、Fowler、Devitt、Van Meter，“Surface code quantum computing by lattice surgery”，2012）。下图以 d = 3 说明它从哪里来。左边是第 2 章的棋盘，这次把横边比特和竖边比特都画成圆点，检查画成小方块，细线连着每条检查碰的比特。在棋盘上画一个菱形（斜 45° 的正方形），只留下菱形里的 9 个比特和碰得到它们的检查：里面的 4 条四腿检查，外加菱形四条边上各一条只剩两腿的检查（转正以后，上下两边的是 X 型，左右两边的是 Z 型）。四个角上的比特被裁掉了。把菱形转 45° 摆正，就是右边的旋转版：数据比特排成 3 × 3 的方阵。横着走一行、竖着走一列都要经过 3 个比特，所以码距仍是 3（我们用 exact-css-enum 对这 9 个比特、8 条检查算过：[[9, 1, 3]]）。

The QEC-Bank intuition essay and the reproduction script reproduce.py both record a set of comparison numbers whose source is the literature, not the constructor: the rotated patch [[d², 1, d]] (horsman2012surface: Horsman, Fowler, Devitt, Van Meter, “Surface code quantum computing by lattice surgery”, 2012). The figure shows where it comes from for d = 3. On the left is the board of Chapter 2, this time with both the horizontal-edge and the vertical-edge qubits drawn as dots, checks as small squares, and thin lines from each check to the qubits it touches. Draw a diamond (a square tilted by 45°) on the board and keep only the 9 qubits inside it and the checks that touch them: the 4 four-leg checks inside, plus one check on each of the diamond's four sides that keeps only two legs (once the patch is turned upright, the ones on the top and bottom are X type, those on the left and right Z type). The four corner qubits are cut away. Turn the diamond by 45° and set it upright: that is the rotated patch on the right, with its data qubits in a 3 × 3 array. A row and a column each pass through 3 qubits, so the distance is still 3 (we ran exact-css-enum on these 9 qubits and 8 checks: [[9, 1, 3]]).

一般的 d 也一样：旋转版有 d² 个数据比特、d² − 1 条检查，加上每条检查一个帮手，总数 2d² − 1。它和未旋转版用的是同一种四腿检查，只是边界沿斜线裁，省下的比特全在边界附近。reproduce.py 对 d = 3 和 d = 12 断言了下面这些数：

General d works the same way: the rotated patch has d² data qubits and d² − 1 checks, and with one helper per check the total is 2d² − 1. It uses the same four-leg checks as the unrotated patch; only the boundary is cut along a diagonal, and all the qubits saved sit near the boundary. reproduce.py asserts these values for d = 3 and d = 12:

帮手也可以少于检查数。Horsman 等人（§7.1）写到，d = 3 旋转版的 8 条检查可以用 8 个帮手测，也可以让中间 4 个帮手各用两次（仍然只让相邻比特互相作用），总数就从 17 降到 9 + 4 = 13；他们拿它和未旋转版的 25 比。代价是每一轮测量要分两批做，花的时间更长。所以文献里「d = 3 要多少个物理比特」可能写 17，也可能写 13，要看帮手怎么排。

There can also be fewer helpers than checks. Horsman et al. (§7.1) note that the 8 checks of the rotated d = 3 patch can be measured with 8 helpers, or with the 4 central helpers each used twice (still with only neighbouring qubits interacting), which brings the total from 17 down to 9 + 4 = 13; they compare that with the 25 of the unrotated patch. The price is that each measurement round is done in two batches and takes longer. So a paper may give 17 or 13 as “the physical qubits for d = 3”, depending on how the helpers are scheduled.

把三个数放在一起看：n 随 L² 增长，k 永远是 1，d = L。所以k/n → 0编码率趋于零：逻辑比特数除以物理比特数，随 L 增大无限变小。：L = 10 时 181 个数据比特只存 1 个逻辑比特。而 d = Θ(√n)「与 √n 同阶」：d 被 √n 的常数倍从上下两侧夹住。这里 d = L，n ≈ 2L²，故 d ≈ √(n/2)。：比特数翻 4 倍，码距只翻 2 倍。Bravyi、Poulin、Terhal 证明了一条把 k、d、n 绑在一起的定理（bravyi2010tradeoffs，“Tradeoffs for reliable quantum information storage in 2D systems”，2010）。它有两条前提：(1) 比特排在一张间距固定的二维正方格子上，每个格点一个比特，所以单位面积里的比特数有上限（没有这一条，就能把任意一个码塞进一小块面积，「局域」就没有意义了）；(2) 每条检查碰的比特都落在一个 w × w 的小方块里，w 是固定的，不随码变大而变大。在这两条前提下，任何稳定子码（论文对更一般的一类码也证明了）都满足 k·d² ≤ c·n，常数 c 只取决于 w 和每个格点上量子系统的大小，与 n 无关。表面码的格子间距固定、每条检查只碰相邻的比特，两条前提都满足。

这条不等式对表面码说了什么？把它改写成 k ≤ c·n/d²。表面码的 d = Θ(√n)，n/d² 被一个常数封顶（n ≈ 2L²，d = L，n/d² ≈ 2），所以 k 也被一个常数封顶，不能随 L 增长。定理不说这个常数是 1：k 恰好等于 1，是 2.2 节算的两个秩给出的，由这块版图的检查决定。把数代进去看离天花板多近：表面码的 k·d² = L²，L = 10 时是 100，而 n = 181，比值约 0.55；L 越大这个比值越接近 1/2，所以表面码离这条天花板只差一个常数因子。

那想多存几个逻辑比特怎么办？最简单的是在平面上多摆几块互不相连的补丁：m 块给出 [[m·n, m, L]]，k 涨到 m，d 不变。它完全符合定理：k·d² = m·L²，和总比特数 m·n 一起涨。定理挡住的是另一件事：编码率 k/n 不趋于零（k 与 n 成正比）的同时，让码距 d 无限增长。k 和 d 都慢慢长是允许的：摆 L 块码距为 L 的补丁，k = d = L，总比特数 n ≈ 2L³，k·d² = L³ ≈ n/2，没有违反定理，只是 k/n ≈ 1/(2L²) 仍然趋于零。要让 k/n 保持不变、d 又越来越大，在上面两条前提下做不到；若仍保留前提 (1) 的平面等密度排布，就只能放宽前提 (2)，允许检查碰到远处的比特。这正是 qLDPCquantum low-density parity-check：每条检查只碰少数几个比特、每个比特只被少数几条检查碰到的量子码；「少数」不随码变大而增长，但不要求这些比特在平面上彼此挨着。（量子低密度校验）码走的路：每条检查仍只碰几个比特，但不要求它们在平面上挨着。完整推导（包括「在平面上挨着」这个条件在哪一步用到）见 QEC-Bank 的 BPT 推导页。

Put the three numbers side by side: n grows like L², k is always 1, d = L. Hence k/n → 0The encoding rate, logical qubits divided by physical qubits, shrinks without limit as L grows.: at L = 10, 181 data qubits store a single logical qubit. And d = Θ(√n)“Of the same order as √n”: d is sandwiched between constant multiples of √n. Here d = L and n ≈ 2L², so d ≈ √(n/2).: four times the qubits buys only twice the distance. Bravyi, Poulin and Terhal proved a theorem that ties k, d and n together (bravyi2010tradeoffs, “Tradeoffs for reliable quantum information storage in 2D systems”, 2010). It has two hypotheses: (1) the qubits sit on a two-dimensional square lattice with fixed spacing, one qubit per site, so the number of qubits per unit area is bounded (without this, any code could be packed into a tiny area and “local” would mean nothing); (2) the qubits each check touches all fit inside a w × w block, with w fixed and not growing with the code. Under these two hypotheses every stabilizer code (the paper also covers a more general class) obeys k·d² ≤ c·n, where the constant c depends only on w and on the size of the quantum system at each site, not on n. The surface code has fixed spacing and each check touches only neighbouring qubits, so it meets both hypotheses.

What does the inequality say about the surface code? Rewrite it as k ≤ c·n/d². The surface code has d = Θ(√n), so n/d² is capped by a constant (n ≈ 2L², d = L, n/d² ≈ 2), and k is capped by a constant too: it cannot grow with L. The theorem does not say that constant is 1: k is exactly 1 because of the two ranks computed in §2.2, which is a property of this patch's checks. To see how close the surface code comes to the ceiling, plug in numbers: k·d² = L², which at L = 10 is 100 against n = 181, a ratio of about 0.55, and the ratio approaches 1/2 as L grows, so the surface code sits within a constant factor of the ceiling.

So how do you store more logical qubits? The simplest way is to lay several separate patches side by side in the plane: m patches give [[m·n, m, L]], raising k to m with d unchanged. That is fully consistent with the theorem: k·d² = m·L² grows along with the total qubit count m·n. What the theorem rules out is something else: keeping the encoding rate k/n away from zero (k proportional to n) while the distance d grows without bound. Letting k and d both grow slowly is allowed: lay out L patches of distance L and k = d = L with n ≈ 2L³ qubits, so k·d² = L³ ≈ n/2, within the theorem, although k/n ≈ 1/(2L²) still goes to zero. Keeping k/n fixed while d keeps growing is impossible under the two hypotheses; if the fixed-density planar layout of hypothesis (1) is kept, the only way is to relax hypothesis (2) and let checks reach distant qubits. That is the road taken by qLDPCquantum low-density parity-check: codes in which each check touches only a few qubits and each qubit is touched by only a few checks, “few” not growing with the code, but with no requirement that those qubits be neighbours in a plane. (quantum low-density parity-check) codes: each check still touches only a few qubits, but they need not be neighbours in the plane. The complete derivation, including the step where “neighbours in the plane” is used, is on the QEC-Bank BPT derivation page.

回放一遍：表面码是一族码，家族变量 L ≥ 2；构造器 HGP(rep_L, rep_L) 生成未旋转的平面版图，n = L²+(L−1)² 是两块比特之和，k = 1 来自两个秩都等于 L(L−1)，d = L 来自一行 Z、一列 X 两条串（上界）与 Z̄ 的 L 个不相交拷贝（下界）。QEC-Bank 发布 L3、L4、L5 三个实例；n、k、css 全部 verified；d 在 L3、L4 由穷举 verified；在 L5，实例文件把它登记成定理下界加随机搜索上界，所以是 bounded。算上帮手（每条检查一个），未旋转版图用 (2d−1)² 个比特存 1 个逻辑比特。这个 1 是两个秩算出来的精确值；二维局域性的天花板 k·d² = O(n) 则说明，只要 d 随 √n 增长，k 就只能停在一个常数。

Replay: the surface code is a family with variable L ≥ 2; the constructor HGP(rep_L, rep_L) builds the unrotated planar patch, n = L²+(L−1)² is the sum of two qubit blocks, k = 1 follows from both ranks equalling L(L−1), and d = L from a Z row and an X column (upper bound) plus L disjoint copies of Z̄ (lower bound). The QEC-Bank ships three instances, L3, L4, L5; n, k and css are verified throughout; d is verified by enumeration at L3 and L4; at L5 the instance file records it as a theorem lower bound plus a random-search upper bound, hence bounded. Helpers included (one per check), the unrotated patch spends (2d−1)² qubits on one logical qubit. That 1 is the exact value the two ranks give; the two-dimensional ceiling k·d² = O(n) says that as long as d grows like √n, k can only stay at a constant.