从配对游戏
到译码器 From the pairing game
to decoders

⑤ 里的字母：P_L = 一轮纠错后逻辑比特被改写的概率（逻辑失败率），p = 每个物理比特每轮出错的概率，p_th = 阈值（《Surface Code · 高中数学版》6.2 节），A = 与 d 无关的常数因子，d = 码距，也是贴片的尺寸参数（《从高考数学到 Toric Code》5.8 节）。②③ 里的词：毛边界是贴片上伸出半截边的那两条边（本页的图里是左右两侧），一条 Z 链走到那里可以「出界」而不点亮警报；光边界是另外两条边，X 链在那里出界。可收缩指一条闭合的链圈住的是一块面积，可以由面检查拼出来；贴边指链的两端落在同一条毛边界上；横跨指链从一条毛边界连到另一条。

The letters in ⑤: P_L = the probability that one correction round rewrites the logical qubit (logical failure rate), p = the per-qubit, per-round physical error probability, p_th = the threshold (“The Surface Code · High-School Edition”, §6.2), A = a constant prefactor independent of d, d = the code distance, also the patch size parameter (“From High-School Math to the Toric Code”, §5.8). The words in ② and ③: a rough boundary is one of the two sides of the patch from which half-edges stick out (left and right in this page’s pictures); a Z-chain may leave the patch there without lighting an alarm. A smooth boundary is one of the other two sides, where X-chains leave. Contractible means a closed chain encloses an area and can be built from face checks; hugging a boundary means both ends of the chain sit on the same rough boundary; spanning means the chain runs from one rough boundary to the other.

《Surface Code · 高中数学版》的译码游戏教了你一条黄金法则：近的配近的，靠边的推出去。它好用，但它是经验。本教程要把它变成定理，再指出它在哪里失效、机器又是怎样做得更好的。先到沙盘里活动一下手脚：画几条链，看警报只亮在端点，再看一条贴边的链如何只亮一个警报。

The decoding game of “The Surface Code · High-School Edition” taught you a golden rule: pair the near ones, push the edge ones out. It works, but it is folklore. This tutorial turns it into a theorem, then shows where it fails and how machines do better. Warm up in the sandbox first: draw a few chains, watch alarms light only at endpoints, then see how a chain hugging a boundary lights just one.

设真实错误是一批出错的比特 E（本章只看 Z 错误，X 错误的故事在另一副眼镜里完全对称）。我们看到的只有症状 s = ∂E。任何一个候选修复 C，只要 ∂C = s，施加后症状就清零。此时残留的是 E ⊕ C：一条不点亮任何警报的链——要么是闭合的圈，要么两端都落在毛边界上。《Surface Code · 高中数学版》第 3 章的二分法接管，但要数的是奇偶：数一数残留里有几段是从左毛边界一直连到右毛边界的（叫横跨的串）。偶数段（0、2、4…），残留是若干面检查的乘积，无事发生；奇数段，残留等于逻辑算符 Z̄ 乘上一些面检查，是一次逻辑错误。为什么两段会抵消？两条横跨的串之间夹着一条带子，把带子里所有面检查乘起来，内部的边各被相邻两个面碰到两次、消掉，剩下的正好是这两条串（贴着毛边界的面在边界那一侧是开口的，不贡献竖边）。见图 1.1 ②。对一块 k = 1 的贴片，Z 错误只有这两类。

Let the true error be a set E of failed qubits (this chapter follows Z errors; the X story is identical through the other lens). All we observe is the syndrome s = ∂E. Any candidate repair C with ∂C = s clears the syndrome, leaving the residual E ⊕ C: a chain that lights no alarm — either a closed loop or a path whose two ends both sit on rough boundaries. The dichotomy of “The Surface Code · High-School Edition”, Chapter 3 takes over, but what it counts is a parity: count the pieces of the residual that run all the way from the left rough boundary to the right one (spanning strings). An even number (0, 2, 4, …) means the residual is a product of plaquette checks and nothing happened; an odd number means the residual is the logical operator Z̄ times some plaquettes, a logical error. Why do two cancel? Two spanning strings enclose a strip between them; multiply all the plaquettes in that strip, and every inner edge is touched by two neighbouring plaquettes and drops out, leaving exactly the two strings (a plaquette at a rough boundary is open on that side and contributes no vertical edge there). See Fig. 1.1 ②. For a k = 1 patch, Z errors fall into exactly two classes.

实用的数法（本页所有实验台判输赢就是这么数的）：数残留里有几个比特落在左边界那一列半截边上。每段横跨的串在那里占一个，两端都在左边界的路占两个，闭合的圈一个也不占，所以这个数的奇偶就是横跨串数的奇偶：奇数即输。

A practical count (it is how every bench on this page decides the verdict): count the residual qubits that lie on the column of half-edges at the left boundary. Each spanning string occupies one of them, a path with both ends on the left boundary occupies two, a closed loop none; so the parity of this count is the parity of the number of spanning strings, and odd means failure.

这里的「类」要说清楚。两条链 C、C′ 叫同一类，意思是它们的差 C ⊕ C′ 可以由面检查拼出来（闭合的圈、两端落在同一条毛边界上的路、偶数条横跨的串，都属于这种）。面检查作用在编码态上什么都不改变（编码态是每条检查的 +1 本征态），所以同类的两条链作为修复效果完全一样。例：两个警报在同一行、相距 2 步。修复甲是连接它们的直线（2 个比特）；修复乙先向上一步、横走 2 步、再向下一步（4 个比特）。甲 ⊕ 乙 恰好是一个 1 × 2 小矩形的边框，由两个面检查拼成，所以甲乙同类。修复丙把左边的警报推向左毛边界、右边的警报推向右毛边界：甲 ⊕ 丙 从左边界连到右边界，是一条（奇数条）横跨的串，所以丙与甲不同类——若甲是对的，丙就造成逻辑错误。

“Class” needs a precise meaning. Two chains C and C′ are in the same class when their difference C ⊕ C′ can be built from face checks (closed loops, paths with both ends on the same rough boundary, and even numbers of spanning strings all qualify). A face check changes nothing on an encoded state (encoded states are +1 eigenstates of every check), so two chains of the same class act identically as repairs. Example: two alarms on one row, 2 steps apart. Repair A is the straight path between them (2 qubits); repair B steps up once, runs 2 steps across, and steps down (4 qubits). A ⊕ B is exactly the rim of a 1 × 2 rectangle, built from two face checks, so A and B are in one class. Repair C pushes the left alarm to the left rough boundary and the right alarm to the right one: A ⊕ C runs from the left boundary to the right, one (an odd number of) spanning string, so C is not in A’s class — if A is right, C causes a logical error.

于是所有满足 ∂C = s 的修复也分成两类：与 E 同类的（修复成功）和不同类的（修复失败）。译码器在两类之间选一类，然后在那一类里随便挑一条链施加——挑哪条无所谓。译码是二选一，不是大海捞针。

So all repairs with ∂C = s split into two classes as well: those in E's class (repair succeeds) and those in the other (repair fails). The decoder picks a class, then applies any chain from it — which one is irrelevant. Decoding is a binary choice, not a search for a needle.

既然是二选一，最好的策略就是：算出「真实错误属于第一类」和「属于第二类」的概率，押大的（下面的折叠块说明为什么没有更好的策略）。要算概率，先得说清错误怎么产生。本章和第 2 至 4 章都用最简单的码容量模型code-capacity noise：只有数据比特出错，每个比特独立地以概率 p 出错；症状测量本身完美无误。在这个模型下测得的阈值叫码容量阈值。：每个数据比特独立地以概率 p 出一个 Z 错误，而检查的读数完全可靠（测量出错的情形留到第 5 章）。于是一条具体的、长 ℓ 的链（ℓ = 链上的比特数）出现的概率是 p^ℓ(1−p)^n−ℓ，n 是贴片上数据比特的总数：ℓ 个比特错，其余 n−ℓ 个没错。一类的概率，就是把这一类里所有链的概率加起来。这样定义的译码器叫最大似然译码器maximum-likelihood decoder：给定症状，选总概率最大的那一类。它是任何译码器能达到的上限，代价是要对一类里所有链求和。，它是一切译码器的上限。

With a binary choice the best strategy is: compute the probability that the true error lies in class one versus class two, and bet on the larger (the fold below explains why nothing does better). To compute probabilities we must say how errors arise. This chapter and Chapters 2 to 4 use the simplest code-capacity modelCode-capacity noise: only data qubits fail, each independently with probability p; syndrome measurement itself is perfect. A threshold measured in this model is a code-capacity threshold.: each data qubit independently suffers a Z error with probability p, and check readouts are perfectly reliable (faulty measurements wait until Chapter 5). One specific chain of length ℓ (ℓ = the number of qubits on it) then occurs with probability p^ℓ(1−p)^n−ℓ, where n is the total number of data qubits on the patch: ℓ qubits failed, the other n−ℓ did not. The probability of a class is the sum over every chain in it. The decoder so defined is the maximum-likelihood decoderGiven the syndrome, pick the class with the largest total probability. It is the ceiling for any decoder; the price is a sum over every chain in a class., the ceiling for all decoders.

p^ℓ(1−p)^n−ℓ 里有一个与链无关的公因子 (1−p)ⁿ——所有候选链共享，比较大小时可以扔掉。剩下的是 (p/(1−p))^ℓ：链每长一条边，概率就乘一次 p/(1−p)。取自然对数，「乘」变成「加」：

Inside p^ℓ(1−p)^n−ℓ sits a chain-independent factor (1−p)ⁿ, shared by every candidate, so it can be dropped when comparing. What remains is (p/(1−p))^ℓ: each extra edge multiplies the probability by p/(1−p). Take the natural logarithm and multiplication becomes addition:

格点上的一条边就是一个数据比特，所以「链长一条边」就是「多错一个比特」。每条边分到同一个正的权重weight：给每条边分配的数 w₀ = ln((1−p)/p)，使得一条链的对数概率 = −(总权重)。权重越大的链越不可能。 w₀，一条链的对数概率就是 −w₀ × 长度。于是在所有满足 ∂C = s 的单条链里，最可能的就是最短的。《Surface Code · 高中数学版》译码游戏的黄金法则「近的配近的」，说的正是这件事的一半：它在找最短的链。另一半是「一类里有多少条链」，匹配不管它，第 3 章会算它什么时候要紧。拖动下面的 p，看这条直线：

An edge of the lattice is a data qubit, so “one more edge” means “one more failed qubit”. With every edge assigned the same positive weightThe number w₀ = ln((1−p)/p) assigned to each edge, so that a chain's log-probability = −(total weight). Heavier chains are rarer. w₀, a chain's log-probability is −w₀ × length. Among all single chains with ∂C = s, the most probable is the shortest. The surface-code tutorial's golden rule “pair the near ones” states half of this: it is hunting for the shortest chain. The other half is “how many chains a class contains”, which matching ignores; Chapter 3 works out when it matters. Drag p below and watch the straight line:

一条满足 ∂C = s 的链，就是若干段路径，每段连接两个警报（或连接一个警报与一段己方边界）。为什么？从任意一个警报出发，沿着链上的比特走：每经过一个不亮的检查，链在那里有偶数条边，进得去就出得来；所以只能停在另一个警报上，或者走出毛边界。把这段路径拿掉，剩下的链少了两个端点，再重复。拆到最后若还剩一些闭合的圈，它们不连任何警报，只会让链更重，最轻的链里不会有。把它反过来看：先决定谁和谁配对，再让每对之间走最短路——最短路的长度只取决于两个端点，可以预先算好。（两对的最短路若有重叠，重叠的比特错两次等于没错，⊕ 会把它们消掉，得到的链只会更轻；而这条更轻的链拆开来又是另一种配法，所以最轻的链一定是「某种配法 + 每对走最短路」。）于是问题只剩配对。画一张新图，叫症状图syndrome graph：顶点是全部警报（平面版再加一个「边界」虚拟顶点），任意两顶点之间连一条边，边的权重 = 两警报在格点上的最短距离乘 w₀。：顶点是警报，任意两点之间连一条边，权重是它们在格点上的最短距离（乘上 w₀，但同一个 p 下这是公因子，下面就用步数）。平面版再加一个虚拟顶点「边界」，每个警报到它的权重是到最近己方边界的步数。

A chain with ∂C = s is a bundle of paths, each joining two alarms (or one alarm to a boundary of its own kind). Why? Start at any alarm and walk along the chain’s qubits: at every unlit check the chain has an even number of edges, so whenever you get in you can get out; you can only stop at another alarm or leave through a rough boundary. Remove that path; the rest of the chain has two fewer endpoints; repeat. Any closed loops left over touch no alarm and only add weight, so the lightest chain has none. Flip the viewpoint: decide first who pairs with whom, then let each pair walk a shortest path — its length depends only on the two endpoints and can be precomputed. (If the shortest paths of two pairs overlap, a qubit flipped twice is not flipped at all, ⊕ cancels the overlap, and the chain only gets lighter; that lighter chain splits into another pairing, so the lightest chain is always “some pairing + a shortest path per pair”.) Only the pairing remains. Draw a new graph, the syndrome graphVertices are all alarms (plus one virtual “boundary” vertex on the plane); every two vertices are joined by an edge whose weight = their shortest lattice distance times w₀.: vertices are alarms, every pair joined by an edge weighted by their shortest lattice distance (times w₀, a common factor at fixed p, so we count steps below). The planar version adds a virtual “boundary” vertex, each alarm's weight to it being the steps to its nearest boundary of the right kind.

在症状图上，一种「每个警报恰好属于一对」的配法叫一个完美匹配perfect matching：图中一组边，使每个顶点恰好被其中一条边覆盖。「完美」指没有顶点被漏掉。。总权重最小的那一个，就是最小重量完美匹配minimum-weight perfect matching，简称 MWPM：所有完美匹配中总权重最小者。它对应「最可能的一条修复链」。（MWPM）——它给出所有单条修复链里最可能的一条，正是 1.3 节要找的东西。

On the syndrome graph, a pairing in which every alarm belongs to exactly one pair is a perfect matchingA set of edges covering every vertex exactly once. “Perfect” means no vertex is left out.. The one with the smallest total weight is the minimum-weight perfect matchingMWPM for short: the perfect matching of smallest total weight. It corresponds to the single most probable repair chain. (MWPM) — the most probable single repair chain, exactly what §1.3 asked for.

有多少种完美匹配？2m 个警报，第一个警报有 2m−1 个可能的搭档；定下来后剩 2m−2 个警报，再递归。所以配法总数是 (2m−1)(2m−3)⋯3·1，记作 (2m−1)!!（隔一个乘一个的「双阶乘」）。它长得很快：

How many perfect matchings? With 2m alarms, the first alarm has 2m−1 possible partners; once fixed, 2m−2 alarms remain and we recurse. The total is (2m−1)(2m−3)⋯3·1, written (2m−1)!! (the “double factorial”, skipping every other factor). It grows fast:

亲手比一比：下面的实验台给你一个随机症状，你像《Surface Code · 高中数学版》的译码游戏那样配对，但读数会同时算出你这种配法的总重量，以及所有配法里最轻的重量。多试几盘，你会发现「最轻」通常很容易凑到——但不总是；也会发现最轻的配法偶尔也会输给真实错误：它只是最可能，不是必然。

怎么读这张图（本页所有格点实验台都一样）：这是一块 d = 5 的平面贴片。格线的交点是星检查，它们测 X 型算符，所以报告 Z 错误，警报（红点）就亮在交点上；每条格线段中间的小灰点是数据比特，一条链就是一串相邻的数据比特。左右两侧伸出去的半截边通向两条毛边界（灰色长虚线，标「毛边界」），Z 链可以在那里终止而不点亮警报；上下两条是光边界，与 Z 链无关。「重量」就是步数：两个警报之间最短要走过几个数据比特，或一个警报走到最近的毛边界要几个。

How to read the picture (the same in every lattice bench on this page): this is a d = 5 planar patch. The crossings of the grid lines are star checks; they measure X-type operators and therefore report Z errors, so alarms (red dots) light up on crossings. The small grey dot in the middle of each grid segment is a data qubit, and a chain is a run of neighbouring data qubits. The half-edges sticking out on the left and right lead to the two rough boundaries (long grey dashes, labelled “rough boundary”), where a Z-chain may end without lighting an alarm; the top and bottom are smooth boundaries, irrelevant for Z-chains. “Weight” is a step count: how many data qubits the shortest route between two alarms crosses, or from one alarm to its nearest rough boundary.

Try it: the bench hands you a random syndrome and you pair as in the surface-code tutorial's decoding game, but the readout also computes your pairing's total weight alongside the lightest weight over all pairings. A few rounds in, you will find the lightest is usually easy to hit — but not always; and that even the lightest pairing occasionally loses to the true error: it is the most probable, not certain.

六亿种配法不能穷举，但 1965 年 Jack Edmonds 给出了一个算法，能在多项式时间内精确找出最小重量完美匹配：运行时间只随警报数按某个固定次方增长，而不是像双阶乘那样爆炸。按今天的写法，他的原始版本约需 V²E 步（V = 症状图的点数，E = 边数；每两点都连边时 E ≈ V²/2，所以约 V⁴），Gabow 后来把它改进到 V³。这个算法叫开花算法blossom algorithm（Edmonds 1965）：沿「增广路」逐步增加配对数，同时用每个点上的「对偶变量」保证每一步都只用最便宜的边；遇到奇数长度的圈就把它缩成一个点（「花」），之后再展开。。它由四个想法拼成，下面逐个讲，每个想法都对应下面回放里的一种步骤。

Six hundred million pairings cannot be enumerated, but in 1965 Jack Edmonds gave an algorithm that finds the minimum-weight perfect matching exactly in polynomial time: its running time grows like a fixed power of the number of alarms, not explosively like the double factorial. In today’s terms his original version needs about V²E steps (V = nodes of the syndrome graph, E = edges; with every pair joined, E ≈ V²/2, so about V⁴), later improved by Gabow to V³. It is the blossom algorithmEdmonds 1965: raise the number of pairs one augmenting path at a time, while “dual variables” on the nodes guarantee that only the cheapest edges are ever used; an odd cycle is shrunk to one node (a “blossom”) and expanded later.. It is built from four ideas; we take them one at a time, and each matches one kind of step in the player below.

想法一 · 增广路：一次多配一对。一个匹配是一组互不相交的配对（每个警报最多出现在一对里），还没配上的警报叫未配点。一条增广路augmenting path：从一个未配点出发、到另一个未配点结束的路径，路上的边交替地「不在匹配里、在匹配里、不在匹配里……」。把路上每条边的身份对调，配对数就加一。从一个未配点出发，交替地走「不在匹配里的边」和「在匹配里的边」，到另一个未配点结束。把路上每条边的身份对调——在的变不在、不在的变在——两端的未配点就都配上了，中间的点仍然各配一个，配对数加一。例：四个警报 A1、A2、A3、A4 排成一行，现在只有 A2–A3 配着。路 A1 – A2 = A3 – A4（「–」不在匹配里，「=」在）是一条增广路；对调之后得到 A1 = A2、A3 = A4，从 1 对变成 2 对。

Idea 1 · Augmenting paths: one more pair at a time. A matching is a set of disjoint pairs (each alarm in at most one), and an alarm not yet paired is unmatched. An augmenting pathA path from one unmatched node to another whose edges alternate “not in the matching, in the matching, not in …”. Swapping the status of every edge on it adds one pair. starts at an unmatched node, alternates between edges not in the matching and edges in it, and ends at another unmatched node. Swap the status of every edge on it — in becomes out, out becomes in — and both end nodes get partners while every interior node still has exactly one: one pair more. Example: four alarms A1, A2, A3, A4 in a row, with only A2–A3 paired. The path A1 – A2 = A3 – A4 (“–” not in the matching, “=” in it) is augmenting; after the swap we have A1 = A2 and A3 = A4, two pairs instead of one.

想法二 · 菱形是一张「下界证书」。光会增加配对数还不够，还得保证最后的配法最轻。Edmonds 的办法是给每个点 v 一个数 y_v，叫对偶变量dual variable，记作 y_v：算法给每个点分配的一个数，画成以该点为中心、半径 y_v 的菱形。规则是任意两点的菱形不重叠：y_u + y_v ≤ w(u, v)。没有花的时候，所有 y 的和就是任何配法总重量的下界（有花时的修正见 2.3 节想法四）。，画成以 v 为中心、半径 y_v 的菱形（格点上只能横竖走，离一个点不超过 r 步的区域正好是菱形）。唯一的规则：任意两个菱形不重叠，即对每两点 u、v 都有 y_u + y_v ≤ w(u, v)。两者之差 w − y_u − y_v 叫这条边的松弛slack：w − y_u − y_v，两个菱形之间还剩的空隙，始终 ≥ 0。等于 0（两个菱形相碰）的边叫紧边，算法只沿紧边配对。，就是两个菱形之间还剩的空隙；空隙为 0、两个菱形正好相碰的边叫紧边。这些数买到的是一张证书：任取一种完美匹配，它的每一对 (u, v) 都满足 w(u, v) ≥ y_u + y_v；把所有对加起来，每个点恰好出现一次，所以任何配法的总重量 ≥ 所有 y 之和。如果我们找到一种配法，它的每一对都是紧边，那么它的重量恰好等于 y 之和——已经碰到下界，不可能有更轻的配法，而这个结论不需要去试那六亿种。算法的全部工作，就是一边把菱形撑大（抬高下界），一边只沿紧边配对。（这一段的规则和下界只在还没有花的时候原样成立；花出现后，记账要加一项，见想法四和它后面的折叠块。）

Idea 2 · The diamonds are a lower-bound certificate. Adding pairs is not enough; the final pairing must also be the lightest. Edmonds’ device is a number y_v for every node v, its dual variableWritten y_v: a number the algorithm assigns to each node, drawn as a diamond of radius y_v centred on it. The rule is that no two diamonds overlap: y_u + y_v ≤ w(u, v). While there is no blossom, the sum of all y is then a lower bound on the weight of every pairing (the correction for blossoms is in Idea 4 of §2.3)., drawn as a diamond of radius y_v centred on v (on a lattice you move only horizontally and vertically, so the points within r steps of a node form exactly a diamond). The one rule: no two diamonds overlap, i.e. y_u + y_v ≤ w(u, v) for every two nodes. The difference w − y_u − y_v is the edge’s slackw − y_u − y_v: the gap left between two diamonds, always ≥ 0. An edge with slack 0 (the diamonds touch) is tight; the algorithm pairs only along tight edges., the gap left between the two diamonds; an edge with zero gap, where the diamonds just touch, is tight. What these numbers buy is a certificate. Take any perfect matching: each of its pairs (u, v) has w(u, v) ≥ y_u + y_v; add over all pairs, every node appearing exactly once, and every pairing weighs at least the sum of all y. If we find a pairing whose every pair is tight, its weight equals the sum of the y — it has hit the lower bound, no pairing can be lighter, and we know it without trying six hundred million of them. The algorithm’s whole job is to inflate the diamonds (raising the bound) while pairing only along tight edges. (The rule and the bound of this paragraph hold as stated only while there is no blossom; once blossoms appear the bookkeeping gains a term, see Idea 4 and the fold after it.)

想法三 · 外点长、内点缩，直到有两块相碰。每一轮开始，每个未配点做一棵树的根，标为外点outer node（回放里橙色）：树根，以及树里「与根隔偶数条边」的点。外点的菱形会长大。；已配上、此刻不在任何树里的点叫自由点（灰色）。所有外点的菱形一起长大同样的量 δ，δ 取到「下一件事发生」为止——也就是某个外点的菱形碰到别的菱形、某条边变紧。接下来看碰到的是谁：①碰到另一棵树的外点：从一个根经紧边走到另一个根，恰好是一条增广路，对调它（增广），配对数加一，所有标记清空，开始下一轮；②碰到一个自由点：把它挂进树里当内点inner node（回放里蓝色）：树里「与根隔奇数条边」的点，它在树里的孩子就是它的配对伙伴。外点长 δ 时内点缩 δ，这样连着它的两条紧边都保持紧。（蓝色），它的配对伙伴随之进树当外点（长树）——从根到这个伙伴的路又是一条交替路，伙伴就像一个新的根，可以继续往外找。内点为什么要缩？内点一边连着树里的外点父亲，一边连着外点伙伴，两条边都是紧的；外点长 δ、内点缩 δ，两条边两端的半径和都不变，照样紧，也不会和别人重叠。没有花的时候，每长一次，y 的总和净增 δ ×（外点数 − 内点数）；每棵树的外点恰好比内点多一个（根，加上每个内点下面的那个伙伴），所以净增 = δ × 树的棵数，下界稳步上升。

Idea 3 · Outer nodes grow, inner nodes shrink, until two touch. At the start of each stage every unmatched node becomes the root of a tree and is labelled outerOuter node (amber in the player): a tree root, and any node an even number of edges below the root. Outer diamonds grow.; a node already paired and in no tree at the moment is free (grey). All outer diamonds grow by the same amount δ, where δ is how far they can grow until the next event — some outer diamond touching another, some edge turning tight. What happens next depends on whom it touched: (1) an outer node of another tree: walking from one root through tight edges to the other root is exactly an augmenting path; swap it (augment), gaining one pair; all labels clear and a new stage begins; (2) a free node: hang it on the tree as an innerInner node (blue in the player): a node an odd number of edges below the root; its child in the tree is its matched partner. When outer nodes grow by δ inner nodes shrink by δ, so both tight edges at it stay tight. node (blue), and its partner follows into the tree as an outer node (grow the tree) — the path from the root to that partner is again alternating, so the partner acts like a new root and can keep searching. Why do inner nodes shrink? An inner node is joined by tight edges to its outer parent and to its outer partner; when the outer ones grow by δ and it shrinks by δ, the radius sums on both edges are unchanged, so both stay tight and nothing overlaps. With no blossoms around, each growth step raises the total of the y by δ × (outer − inner); every tree has exactly one more outer node than inner ones (the root, plus the partner below each inner node), so the gain is δ × (number of trees) and the bound climbs steadily.

把三个想法放在 3.1 节那个让贪心吃亏的例子上走一遍。四个警报排成一行，间距 3、2、3（没有边界）。图里一维的「菱形」就是以警报为中心、半径 y 的一段区间：

Run the three ideas on the example where greedy loses in §3.1: four alarms in a row, spaced 3, 2, 3 (no boundary). In one dimension a “diamond” is just an interval of radius y around the alarm:

注意第一轮它也先把 A2、A3 配在一起——和贪心一样。区别在第二轮：贪心配过的对永不拆开，而开花算法通过增广路把 A2–A3 拆掉、重组成两对更短的，而且菱形之和告诉它「6 已经是下界，可以停了」。

Note that in stage 1 it also pairs A2 with A3 first, just like greedy. The difference comes in stage 2: greedy never undoes a pair, whereas the blossom algorithm breaks A2–A3 through an augmenting path and regroups into two shorter pairs — and the diamond sum tells it that 6 is already the lower bound, so it may stop.

想法四 · 奇数圈缩成一朵花。还剩一种碰法没讲：③碰到的是同一棵树里的另一个外点。从这两个外点各自往上走到它们在树里的汇合点，再加上这条紧边，围成一个圈；两个外点到汇合点的边数都是偶数，加上这条边，圈的长度是奇数。奇数圈上的点没法两两配完——总有一个落单——于是沿它对调会卡住。Edmonds 的妙招是把整个圈缩成一个点，叫一朵花blossom：由奇数个点组成、被紧边连成一圈的一组点，被当作一个「超级点」处理。花作为整体继续生长，它有自己的对偶变量 z；当它是内点且 z 缩回 0 时要展开。，当作一个外点继续长；它有自己的对偶变量 z，记录整朵花一起长了多少。花里总有一个成员不在花内部配对（它还没配上，或者配给了花外的点），叫花的基点；其余成员在花内两两配好。增广路穿过一朵花时，花内部就地改配，让增广路经过的那个成员成为新的基点，花本身保留。花作为内点挂进一棵树时，树边从外点父亲连进花里的那个成员叫入口。内花会缩，缩到 z = 0 就不能再缩（z 不能为负，理由见下面的折叠块），这时要把它展开：从入口沿圈走到基点、走边数为偶数的那一边，这条路上的成员依次标成内、外、内……重新进树，其余成员变回自由点。记账上的一点修正：回放让花里每个成员的 y 都跟着花一起涨，所以 y 的总和会多算花的厚度，真正的下界是 Σy − Σ_B (|B| − 1) z_B/2（|B| 是花 B 的点数）；两端都在同一朵花里的边，松弛要写成 w − y_u − y_v + z_B。下面的折叠块先用一个三角形算出这两条式子从哪来，再加两个警报，看一朵内花缩到 z = 0 并展开。

Idea 4 · Odd cycles shrink into a blossom. One kind of touch is left: (3) the other diamond belongs to an outer node of the same tree. Walking up from both outer nodes to where their tree paths meet, plus the new tight edge, closes a cycle; each outer node is an even number of edges from the meeting point, so with the new edge the cycle has odd length. The nodes of an odd cycle cannot all be paired among themselves — one is always left over — so swapping along it gets stuck. Edmonds’ trick is to shrink the whole cycle to one node, a blossomAn odd set of nodes joined in a cycle by tight edges, handled as one “super-node”. The blossom keeps growing as a whole and has its own dual variable z; when it is inner and z shrinks back to 0 it must be expanded., and keep growing it as an outer node; it has its own dual variable z recording how much the blossom has grown as a whole. A blossom always has exactly one member that is not paired inside it (it is unmatched, or matched to a node outside); that member is the blossom’s base, and the other members are paired among themselves. When an augmenting path passes through a blossom, the blossom is re-paired in place so that the member the path passes through becomes the new base; the blossom itself stays. When a blossom hangs in a tree as an inner node, the member at which the tree edge from its outer parent arrives is its entry. An inner blossom shrinks, and once its z reaches 0 it may not shrink further (z cannot be negative; the fold below says why), so it is expanded: walk round the cycle from the entry to the base along the side with an even number of edges, label the members on that path inner, outer, inner, … back into the tree, and release the remaining members as free nodes. One correction to the bookkeeping: the player raises every member’s y together with its blossom, so the sum of the y over-counts the blossom’s thickness; the true lower bound is Σy − Σ_B (|B| − 1) z_B/2 (|B| = the number of nodes in blossom B), and an edge with both ends in the same blossom has slack w − y_u − y_v + z_B. The fold below first derives both formulas on a triangle, then adds two alarms to watch an inner blossom shrink to z = 0 and expand.

边界怎么办。平面贴片上警报还可以单独去毛边界。回放的做法是给每个警报 A_i 配一个自己的边界节点boundary node：为每个警报单独添加的虚拟点，画成边界线上的小空心方块。A_i 与它的边界节点之间的权重 = A_i 到最近毛边界的步数；边界节点彼此之间权重为 0。（边界线上的小空心方块），两者之间的权重 = A_i 到最近毛边界的步数；边界节点彼此之间的权重为 0。这样点数是 2m，一定是偶数；A_i 配给自己的边界节点就表示「把 A_i 推出边界」，用不上的边界节点两两免费配掉。例：三个警报，A1 去边界，A2 与 A3 互配，完整的完美匹配是 A2–A3、A1–A1 的边界节点、再加上另外两个边界节点互配（重量 0）。0 权重的边在 y = 0 时已经是紧的，所以回放一开始就把边界节点两两配好。边界节点之间的这些 0 权重边后来也可能围成奇数圈、缩成只含边界节点的花；回放不把这种花画出来，但它们的 z 照样算进下界，读数会注明这一部分。

What about the boundary? On a planar patch an alarm may also go to a rough boundary alone. The player gives each alarm A_i its own boundary nodeA virtual node added for each alarm, drawn as a small hollow square on the boundary line. The weight between A_i and its boundary node = A_i’s steps to the nearest rough boundary; boundary nodes are joined to each other at weight 0. (a small hollow square on the boundary line), at a weight equal to A_i’s steps to the nearest rough boundary, and joins the boundary nodes to each other at weight 0. The node count is then 2m, always even; pairing A_i with its own boundary node means “push A_i out through the boundary”, and unused boundary nodes pair off among themselves for free. Example: three alarms, A1 goes to the boundary and A2 pairs with A3; the full perfect matching is A2–A3, A1 with its boundary node, and the two other boundary nodes with each other (weight 0). Weight-0 edges are already tight at y = 0, so the player pairs the boundary nodes up at the very start. Later these weight-0 edges between boundary nodes may also close odd cycles and shrink into blossoms made only of boundary nodes; the player does not draw such blossoms, but their z still enters the lower bound, and the readout says how much of it they account for.

回放里每一种步骤都是上面的某个想法：「初始化」（所有 y = 0，边界节点先两两配好）；「新一轮」（未配点成为树根、标为外点）；「生长 δ」（想法三：外点长、内点缩，花的 z 相应增减）；「长树」「增广」（想法三的两种碰法）；「收缩成花」「展开」（想法四）。「贪心」一栏则每步只做一件事：在剩下的警报里找全局最近的一对（或最近的边界），连上、移除、再找，配过的永不拆开。回放结束时，开花算法给出的重量会与下面「诚实说明」里的精确枚举逐次核对。

Every kind of step in the player is one of the ideas above: “Initialise” (all y = 0, boundary nodes paired up first); “New stage” (unmatched nodes become roots, labelled outer); “Grow by δ” (Idea 3: outer grow, inner shrink, blossom z moving accordingly); “Grow the tree” and “Augment” (the two touches of Idea 3); “Shrink a blossom” and “Expand” (Idea 4). The “greedy” option does one thing per step: among the remaining alarms take the globally closest pair (or the closest boundary), connect it, remove it, repeat — and never undo a pair. At the end of each run the blossom weight is checked against the exact enumeration described in the honesty box below.

现代的译码器把这个算法做到了极致：Fowler 的并行版本让每个警报只看局部邻域；Higgott 的 PyMatching 成为开源标配；Higgott 与 Gidney 2023 年的 Sparse Blossom 直接在格点上做开花算法、不预先算两两距离，按其摘要，在 0.1% 电路级噪声（5.4 节）下译码 d = 17 的表面码时，单核每轮用时不到 1 微秒，与超导芯片产生症状的速度相当。4.1 节会说为什么「跟得上」本身就是一道硬指标。

Modern decoders push the algorithm to the limit: Fowler’s parallel version lets each alarm look only at its neighbourhood; Higgott’s PyMatching became the open-source standard; and Higgott and Gidney’s 2023 Sparse Blossom runs the blossom algorithm directly on the lattice without precomputing all pairwise distances — per its abstract, decoding a distance-17 surface code under 0.1% circuit-level noise (§5.4) takes under one microsecond per round on a single core, matching the rate at which superconducting chips produce syndrome data. §4.1 explains why keeping pace is itself a hard requirement.

回放里的记号：w = 边的权重（两个警报间的格点距离，或警报到自己边界节点的距离）；y_u、y_v = 两端点的对偶变量（内点的 y 可以缩到负数，菱形只能画出正的半径）；δ = 一次生长的步长，取「下一件事发生」所需的最小值；z_B = 花 B 的对偶变量，等于整朵花一起长的厚度的两倍（外花加 2δ、内花减 2δ），内花归零即展开。花里成员的 y 含着花的厚度，所以有花时下界是 Σy − Σ_B(|B|−1)z_B/2（「生长」一步的读数会算出它），两端在同一朵花里的边松弛是 w − y_u − y_v + Σ_B∋u,v z_B，求和遍及所有同时包住 u、v 的花（花可以一层套一层）。

Notation in the player: w = edge weight (lattice distance between two alarms, or from an alarm to its own boundary node); y_u, y_v = the dual variables at its ends (an inner node’s y may shrink below zero; a diamond can only show a positive radius); δ = one growth increment, the smallest amount until the next event; z_B = blossom B’s dual, twice the thickness the blossom has grown as a whole (+2δ for an outer blossom, −2δ for an inner one); an inner blossom is expanded when it reaches zero. A member’s y includes its blossom’s thickness, so with blossoms the lower bound is Σy − Σ_B(|B|−1)z_B/2 (the “grow” readout computes it), and an edge with both ends in one blossom has slack w − y_u − y_v + Σ_B∋u,v z_B, summed over every blossom that contains both u and v (blossoms can nest).

贪心算法一步一步怎么走，2.3 节的算法回放里选「贪心」就能逐步看到；这里看它输在哪。

To watch greedy run step by step, choose “greedy” in the algorithm player of §2.3; here we see where it loses.

最省事的译码器是贪心配对greedy pairing：反复找出当前距离最近的两个警报配成一对（平面上也可与边界比较），直到警报用完。每一步都最优，整体未必。：反复把当前最近的两个警报配对。它每一步都在做局部最优的事，但局部最优之和不是全局最优。最小的反例只需四个警报排成一线，间距依次为 3、2、3：贪心先配中间那对（重量 2），剩下两端只能互配（重量 8），总重量 10；而最优是两头各配一对，3 + 3 = 6。一般地，间距 a、b、c 且 b 最小时，贪心给 a + 2b + c，最优给 a + c，多付了 2b。

The laziest decoder is greedy pairingRepeatedly pair the two alarms currently closest (on the plane, also compare with the boundary) until none remain. Each step is optimal; the whole need not be.: repeatedly pair the two closest alarms. Every step is locally optimal, but a sum of local optima is not a global optimum. The smallest counterexample is four alarms on a line with gaps 3, 2, 3: greed pairs the middle two first (weight 2), leaving the ends to pair with each other (weight 8), total 10; the optimum pairs each end, 3 + 3 = 6. In general, with gaps a, b, c and b the smallest, greed pays a + 2b + c against the optimum a + c — an overpayment of 2b.

多付重量本身不致命——译码器的成败只看类。致命的是：贪心修复与最优修复之差，有时含奇数条横跨贴片的串（1.1 节的判据），两者就不同类。那时若真实错误就是那条最短链（这正是最可能的情形），贪心会把它「修」成一次逻辑错误。下面的实验台在 d = 5 的贴片上搜出了 8 个「贪心比最优更重」的症状（例子编号见读数）。每个例子里切到「两者之差」，红线就是两种修复之差：读数把它拆成几段，说出每段是闭合的圈、两端落在同一条毛边界上的路，还是横跨的串，再数左边界上的端点个数定输赢。这 8 个例子里，7 个的差是一段两端落在同一条毛边界上的路（贪心多走了路，但仍然同类），只有 1 个是一条横跨的串（真正的陷阱）。

Overpaying weight is not fatal by itself — only the class matters. What is fatal: the difference between the greedy and the optimal repair sometimes contains an odd number of strings spanning the patch (the criterion of §1.1), and then the two lie in different classes. If the true error is that shortest chain (the most probable case), greed “repairs” it into a logical error. The bench below searched a d = 5 patch for 8 syndromes on which greedy is heavier than the optimum (numbered in the readout). In each, switch to “their difference”: the red line is the difference of the two repairs. The readout splits it into pieces, says whether each is a closed loop, a path with both ends on the same rough boundary, or a spanning string, and counts the ends on the left boundary to give the verdict. Of the 8 examples, 7 differ by a single path with both ends on one rough boundary (greedy walked further but stays in the same class), and only 1 by a spanning string (a genuine trap).

代价在失败率上看得最清楚。6.3 节的实验台会让你亲自量：在本页的码容量模型（只有 Z 错误、测量完美）下，同样的 d = 5 贴片、p = 5% 时，贪心的整轮失败率约是最小重量匹配的两倍：我们用本页的代码（随机数种子 20260924）抽了 10⁶ 次，两种译码器看同一批错误，贪心失败 5.47%，匹配失败 2.77%（两者的 95% 置信区间都在 ±0.05 个百分点以内），比值 1.97（95% 置信区间 1.95 至 2.00）。6.3 节的实验台只取 4%、6% 这样的格点，每点只抽几百次，读数会有零点几到一两个百分点的涨落。当然，贪心的优点是简单到可以硬件化——这个矛盾把我们引向下一章的并查集译码器。

The price is easiest to see in the failure rate. The bench of §6.3 lets you measure it yourself: in this page’s code-capacity model (Z errors only, perfect measurement), on the same d = 5 patch at p = 5%, greed’s round-failure rate is about twice minimum-weight matching’s: we ran this page’s code (random seed 20260924) for 10⁶ rounds, both decoders seeing the same errors, and got 5.47% failures for greedy and 2.77% for matching (both 95% confidence intervals within ±0.05 percentage points), a ratio of 1.97 (95% confidence interval 1.95 to 2.00). The §6.3 bench uses grid points such as 4% and 6% and samples only a few hundred rounds per point, so its readings scatter by a few tenths of a point up to one or two points. Greed's virtue, of course, is simplicity that can be cast in hardware — a tension that leads to the union-find decoder of the next chapter.

现在轮到最优匹配自己的软肋。1.2 节说真正的最优是押类的总概率，而匹配只押一条链。两者何时不同？当某一类里有许多条同样短的链时——它们单条都不占优，加起来却占优。这叫路径退化path degeneracy：同一对端点之间存在多条长度相同的最短链。最大似然译码把它们的概率全部计入；匹配只计一条。。有多少条？两个警报横向相距 a 步、纵向 b 步，一条最短链就是 a 个「横」和 b 个「竖」排成的一列，排法数是 C(a+b, a)。到实验台上点两个检查数一数：

Now the optimal matching's own soft spot. §1.2 said true optimality bets on a class's total probability, while matching bets on one chain. When do they differ? When a class contains many equally short chains — none dominant alone, dominant together. This is path degeneracySeveral shortest chains of equal length between the same endpoints. Maximum-likelihood decoding counts all their probabilities; matching counts one.. How many? Two alarms a steps apart horizontally and b vertically: a shortest chain is one arrangement of a “across” moves and b “up” moves, and there are C(a+b, a) arrangements. Click two checks on the bench and count:

现在做一道会翻盘的题。设某个症状下，甲类里最短的链长 5 且只有一条；乙类里最短的链长 6，但有 20 条（a = b = 3）。匹配选甲（5 < 6）。最大似然比的是总概率。这里做一个近似：只比两类各自的最短链。（更长的链单条更不可能，每多一步就再乘一次 p/(1−p)，但它们的条数随长度增长得很快，合起来的贡献不一定小；要得到准确的答案，得把整类所有链的概率加起来，那正是最大似然译码器做的事。）在这个近似下：甲 ∝ e^−5w₀，乙 ∝ 20·e^−6w₀。乙胜出当且仅当 20·e^−w₀ > 1，即 p/(1−p) > 1/20，即 p > 1/21 ≈ 4.8%。也就是说，按最短链估算，错误率一过约 4.8%，「多一步但有 20 条」的类就比「少一步但只有 1 条」的类更可能，匹配就押错了。4.8% 是这个近似下的交界点，不是精确值；它说明的是方向：错误率越高，条数越要紧。

Now a problem that flips the verdict. Suppose that under some syndrome class A's shortest chain has length 5 and is unique, while class B's shortest chains have length 6 but there are 20 of them (a = b = 3). Matching picks A (5 < 6). Maximum likelihood compares totals. Here we make an approximation: compare only each class’s shortest chains. (A longer chain is individually less likely, each extra step multiplying by another p/(1−p), but the number of such chains grows quickly with length, so together they need not contribute little; the exact answer needs the sum over every chain of each class, which is precisely what a maximum-likelihood decoder does.) In this approximation: A ∝ e^−5w₀, B ∝ 20·e^−6w₀. B wins iff 20·e^−w₀ > 1, i.e. p/(1−p) > 1/20, i.e. p > 1/21 ≈ 4.8%. So by the shortest-chain estimate, once the error rate passes about 4.8% the class that is “one step longer but twenty-fold” becomes likelier than the “one step shorter but unique” class, and matching bets wrong. The 4.8% is the crossover of this approximation, not an exact value; what it shows is the direction: the higher the error rate, the more the count matters.

真实芯片大约每一微秒就产出一轮症状（例如 Google 2024 年的 Willow 芯片，一轮 1.1 微秒）。译码器若跟不上，未处理的症状会越积越多，而《格点手术 · 高中数学版》要讲的逻辑门必须等译码结果才能决定下一步——积压意味着整台机器越跑越慢，直到失控。所以译码器有两个指标：阈值（多准）和吞吐（多快），两者要同时达标。开花算法准，但在大贴片和长时间窗上很重。Delfosse 与 Nickerson 在 2017 年给出的并查集译码器union-find decoder（Delfosse–Nickerson 2017）：先让奇数簇生长合并（用「并查集」数据结构记录谁和谁同簇），再在每个簇里沿生成树剥皮得到修复。运行时间近似线性。把精度让出一点，换来几乎线性的运行时间。

A real chip emits one round of syndrome roughly every microsecond (Google’s 2024 Willow chip, for instance, runs one round per 1.1 µs). If the decoder cannot keep up, unprocessed syndromes pile up — and the logical gates of “Lattice Surgery · High-School Edition” must wait for decoding results before choosing their next step, so a backlog means the whole machine slows down until it runs away. A decoder therefore has two scores: threshold (how accurate) and throughput (how fast), and both must pass. Blossom is accurate but heavy on large patches over long time windows. Delfosse and Nickerson's 2017 union-find decoderFirst grow and merge odd clusters (tracking who shares a cluster with the “union-find” data structure), then peel a spanning tree inside each cluster to read off the repair. Almost-linear running time. gives up a little accuracy for almost-linear time.

先说什么是簇：格点上连成一片的一组检查，加上它们之间的边（边就是数据比特）。规则只有三句。起点：每个警报自成一个簇（只有一个检查、没有边）。生长：含奇数个警报的簇向外长一层——把与簇相邻的所有边、以及这些边另一端的检查都收进来；含偶数个警报的簇、以及已经碰到毛边界的簇，停下。停下的簇里一定能找到一组边，恰好消掉簇内所有警报（簇是连成一片的，偶数个警报可以在簇内两两连起来；碰到边界的簇则可以把落单的那个推出边界），怎么找见 4.3 节。合并：两个簇一旦共享一条边就合成一个簇，警报数相加。奇数加奇数是偶数，所以合并常常一下子让两个簇同时停下。「谁和谁同簇」这件账，交给一种叫并查集union-find（disjoint-set）：一种数据结构，用「每个元素记住自己的上级」表示分组。find(x) 沿上级找到根，就知道 x 属于哪一组；union(a, b) 把一组的根挂到另一组的根下。「按大小合并」加「路径压缩」两项优化让两种操作平均接近常数时间。的数据结构：它只回答两个问题——「x 属于哪个簇」和「把这两个簇并成一个」，每个都几乎一步完成。 这里写的是最简单的均匀生长版：每一轮所有奇数簇一起长。Delfosse 与 Nickerson 的论文第 5 节还给了一个加权生长版：每次只让边界最小（簇边上待收的边最少）的那个奇数簇长；他们报告，这一改动把环面码的阈值从 9.2% 提到 9.9%（码容量），从 2.4% 提到 2.6%（现象学噪声）。本页的实验台用的是均匀生长版，而且每次收整条边（论文里是每次长半条边），是更粗的简化。

First, a cluster: a connected group of checks on the lattice together with the edges between them (edges being data qubits). Three sentences of rules. Start: every alarm is its own cluster (one check, no edges). Grow: a cluster holding an odd number of alarms grows one layer — it absorbs every edge adjacent to it and the checks at the far ends of those edges; clusters with an even count, or already touching a rough boundary, stop. A stopped cluster always contains a set of edges that cancels exactly its alarms (the cluster is connected, so an even number of alarms can be joined in pairs inside it; a boundary cluster can push the odd one out through the boundary); §4.3 shows how to find it. Merge: two clusters sharing an edge fuse into one, alarm counts adding. Odd plus odd is even, so a merge often stops two clusters at once. The bookkeeping of “who shares a cluster with whom” is handled by the union-findA disjoint-set structure in which every element remembers a parent. find(x) follows parents to the root, revealing x's group; union(a, b) hangs one root under the other. The two optimisations “union by size” and “path compression” make both operations nearly constant time on average. data structure: it answers just two requests — “which cluster is x in?” and “merge these two clusters” — each in almost one step. What is written here is the simplest, uniform-growth version: in each round all odd clusters grow together. Section 5 of Delfosse and Nickerson’s paper adds a weighted-growth version that always grows only the odd cluster with the smallest boundary (the fewest edges waiting at its rim); they report that this change raises the toric-code threshold from 9.2% to 9.9% (code capacity) and from 2.4% to 2.6% (phenomenological noise). The benches on this page run the uniform version and add whole edges at a time (the paper grows half an edge at a time), a coarser simplification still.

生长结束后，每个簇里的警报数都是偶数（或者簇碰到了边界）。现在要在簇内找一批边，使它们的端点恰好是簇内的警报——但不必是最短的，簇本身已经不大。先借两个图论词。树是一组没有圈的、连成一片的边；簇的一棵生成树是用簇里的边把簇里所有检查连起来、又不含任何圈的那样一组边（每丢掉一条会闭合成圈的边，就离生成树近一步）。在树里选定一个根，每个点就有一个唯一的父节点（往根方向的下一个点）；只连着一条树边、又不是根的点叫叶子。做法叫剥皮peeling：在簇内取一棵生成树（触边的簇以边界为根）。反复取一片叶子：若叶子是警报，则把连接它的那条边计入修复并把父节点的警报状态翻转；然后删去叶子。树剥完，修复就得到了。：在簇内取一棵生成树（若簇碰到边界，就以边界为根），然后反复处理叶子。叶子若是警报，把连它的边计入修复，并把「警报」传给它的父节点（父节点原来是警报就变不是，原来不是就变是）；叶子若不是警报，什么也不做。删掉叶子，继续。树剥完，每条计入的边都恰好消掉了两端的警报状态，簇内症状清零。回放把「此刻还需要消掉的警报标记」叫缺陷：开始时缺陷就是警报，剥皮会把它从叶子一步步搬向根。

小例子：一个簇是一条直线 S1 – S2 – S3（两条边），S1、S3 亮着警报，以 S3 为根。叶子 S1 有缺陷：保留边 S1–S2，缺陷搬到 S2。此时 S2 成了叶子、带着缺陷：保留边 S2–S3，S3 的缺陷被翻掉（亮变不亮）。剩下根 S3，没有缺陷。修复 = 两条边，正是连接两个警报的那条链。

Once growth ends, every cluster holds an even number of alarms (or touches a boundary). We now need a set of edges inside the cluster whose endpoints are exactly the cluster's alarms — not necessarily the shortest, the cluster is small already. Two words from graph theory first. A tree is a connected set of edges with no cycle; a spanning tree of a cluster is a set of the cluster’s edges that connects all its checks without closing any cycle (dropping each edge that would close a cycle brings you one step closer to one). Choose a root in the tree; then every other node has a unique parent (the next node toward the root), and a non-root node touching only one tree edge is a leaf. The method is peelingTake a spanning tree inside the cluster (rooted at the boundary if the cluster touches one). Repeatedly take a leaf: if it is an alarm, add its edge to the repair and flip the parent's alarm status; then delete the leaf. When the tree is gone, the repair is complete.: take a spanning tree inside the cluster (rooted at the boundary if the cluster touches one) and process leaves repeatedly. If a leaf is an alarm, add its edge to the repair and pass the alarm to its parent (a parent that was an alarm stops being one, and vice versa); if the leaf is not an alarm, do nothing. Delete the leaf, continue. When the tree is gone, every chosen edge has cancelled the alarm status at both ends and the cluster's syndrome is clear. The player calls “an alarm mark still to be cancelled” a defect: at the start the defects are the alarms, and peeling carries them from the leaves toward the root.

A small example: a cluster is the straight line S1 – S2 – S3 (two edges) with alarms at S1 and S3, rooted at S3. Leaf S1 carries a defect: keep edge S1–S2 and move the defect to S2. Now S2 is a leaf carrying a defect: keep edge S2–S3, which flips S3’s defect off (lit becomes unlit). Only the root S3 remains, defect-free. Repair = two edges, exactly the chain joining the two alarms.

为什么一定能清零？因为每处理一片叶子，「簇内警报数为偶」这一性质保持不变（要么不动，要么同时翻转叶子与父节点），最后只剩根：若根不是边界，偶数个缺陷里只剩它一个点，它的缺陷数只能是 0；若根是边界，落单的那个缺陷被它吸收，意思是修复链从那里出界。实验台里每一步都在格点上标出「叶 S…」和「父 S…」。逐步看：

Why must it clear? Because processing a leaf preserves the property “the cluster's alarm count is even” (either nothing changes, or leaf and parent flip together), so when only the root remains: if it is not the boundary, an even defect count on a single node can only be 0; if it is the boundary, the leftover defect is absorbed there, meaning the repair chain leaves the patch at that point. The bench labels each step’s “leaf S…” and “parent S…” on the lattice. Step through it:

《Surface Code · 高中数学版》第 4 章说，一条检查的读数是由辅助比特收集、再单独读出的。若辅助比特在收集途中被翻、或读出仪读反了，这一轮的这条检查就报出一个错误的 ±1——数据比特其实好好的。单看一轮，真警报与假警报无法区分。但假警报有个弱点：它只持续一轮。下一轮重测，读数又回到正确值。相反，一个真实的数据错误会让该检查的读数从出错那一轮起持续翻转。于是改用探测器detector：同一条检查相邻两轮读数的异或，D(i,t) = s(i,t) ⊕ s(i,t−1)。读数不变时为 0，只有「变了」才亮。报警：D(i,t) = s(i,t) ⊕ s(i,t−1)，同一条检查相邻两轮读数不同才亮。这里 s(i,t) 是第 i 条检查在第 t 轮的读数，写成一位二进制数：读到 +1 记 0，读到 −1 记 1；⊕ 是一位数的异或，0 ⊕ 0 = 1 ⊕ 1 = 0，0 ⊕ 1 = 1 ⊕ 0 = 1；开始前没有错误，所以约定 s(i,0) = 0。

手算一遍。某条检查五轮的读数是 0, 0, 1, 1, 1（第 3 轮起一个数据错误让它一直报 −1）：探测器 D = 0, 0, 1, 0, 0，只在变化的那一轮亮一次。另一条检查的读数是 0, 0, 1, 0, 0（第 3 轮读反了一次）：D = 0, 0, 1, 1, 0，第 3、4 两轮各亮一次——一次读错留下的是时间上相邻的一对。

“The Surface Code · High-School Edition”, Chapter 4 explained that a check's value is collected by an ancilla and read out separately. If the ancilla is flipped midway or the readout misfires, that check reports a wrong ±1 this round — while the data qubits are fine. Within a single round, real and false alarms are indistinguishable. But a false alarm has a weakness: it lasts one round. Re-measure and the value returns to normal. A genuine data error, by contrast, flips that check's value persistently from the round it happens. So we raise alarms with detectorsThe XOR of the same check's readouts in consecutive rounds, D(i,t) = s(i,t) ⊕ s(i,t−1). Zero while the value stays put; lit only on change. instead: D(i,t) = s(i,t) ⊕ s(i,t−1), lit only when a check's value differs between consecutive rounds. Here s(i,t) is check i’s readout in round t written as one bit: +1 is recorded as 0 and −1 as 1; ⊕ is the XOR of bits, 0 ⊕ 0 = 1 ⊕ 1 = 0 and 0 ⊕ 1 = 1 ⊕ 0 = 1; there are no errors before the start, so by convention s(i,0) = 0.

Work one by hand. A check reads 0, 0, 1, 1, 1 over five rounds (from round 3 a data error keeps it at −1): its detectors are D = 0, 0, 1, 0, 0, lit once, in the round of the change. Another check reads 0, 0, 1, 0, 0 (misread once in round 3): D = 0, 0, 1, 1, 0, lit in rounds 3 and 4 — a single misreading leaves a pair adjacent in time.

为了把图画清楚，这一节用最简单的码——一维重复码（L 个比特排成一行，相邻两个比特之间一条 Z_iZ_i+1 检查）——然后把时间画成第二个维度：每一行是一轮测量，最上面一行是最终的完美读出（实验结束时直接测量数据比特，可以精确算出最后一轮的症状）。规则如上：数据错误在它发生的那一轮点亮左右两条检查的探测器（贴边的只亮一条）；测量错误点亮同一条检查这一轮与下一轮的探测器。两种事件都留下一对，只是方向不同。到实验台上点几个错误，看探测器的花样：

To keep the picture clean, this section uses the simplest code — a one-dimensional repetition code (L bits in a row, a Z_iZ_i+1 check between neighbours) — and draws time as the second dimension: each row is one measurement round, and the top row is the final perfect readout (at the end of the experiment the data bits are measured directly, which pins down the last syndrome exactly). Rules as above: a data error lights the detectors of its two neighbouring checks in the round it occurs (one at an edge); a measurement error lights the same check in this round and the next. Both events leave a pair, just in different directions. Toggle a few errors on the bench and watch the pattern:

现在按「译码」。译码器做的仍是2.2 节的事：把亮起的探测器两两配对（或配到左右边界），只是距离现在有两种分量——横向一步和纵向一步。配对完成后，把每条配对路径的横向部分翻转成数据比特的修复（纵向部分对应的是测量错误，不需要修数据）。残留 = 最终真实错误 ⊕ 修复，在一条线上只有两种可能：空集（成功），或整条线全翻（逻辑错误 X̄）。

Now press “Decode”. The decoder still does what §2.2 did: pair the lit detectors (or send them to the left/right boundary), except that distance now has two components — a horizontal step and a vertical one. Once paired, the horizontal part of each pairing path becomes a repair on the data bits (the vertical part corresponds to measurement errors, which need no data repair). Residual = final true error ⊕ repair; on a line it can only be empty (success) or the whole line (logical error X̄).

若数据错误率为 p、测量错误率为 q，1.3 节的对数权重各算一份：横向每步 w_S = ln((1−p)/p)，纵向每步 w_T = ln((1−q)/q)。p = q 时两者相等，时空图是各向同性的；否则译码器会偏爱便宜的方向。实验台上切换「等权 / 按概率加权」可以看到配法随之改变。对表面码，同样的构造把二维格点变成三维时空块（长 × 宽 × 轮数），探测器事件在三维里配对——算法不变。

With data error rate p and measurement error rate q, §1.3's log weights come in two flavours: w_S = ln((1−p)/p) per horizontal step and w_T = ln((1−q)/q) per vertical step. At p = q they coincide and the spacetime graph is isotropic; otherwise the decoder favours the cheaper direction. Switching “unit / probability weights” on the bench changes the pairing accordingly. For the surface code the same construction turns the 2D lattice into a 3D spacetime block (length × width × rounds), and detector events are paired in three dimensions — same algorithm.

代价体现在阈值上。表面码用完美测量、匹配译码时阈值约 10.3%；加入与数据错误同样大的测量错误（p = q，这种模型叫现象学噪声phenomenological noise：每轮每个数据比特以概率 p 出错、每条检查的读数以概率 q 读反，不细究测量电路内部。它是「完美测量」与「电路级噪声」之间的中间模型。），阈值掉到约 2.9%（两个数都是匹配译码，Wang–Harrington–Preskill 2003；同一模型下 Delfosse–Nickerson 2017 报告并查集译码器的加权生长版为 2.6%、均匀生长版为 2.4%）。掉的原因不是译码器变笨，而是每一轮多了一整层可以出错的地方，而失败模式（在时空里横跨的串）也多了一个可以延伸的方向。

The price shows in the threshold. With perfect measurement and a matching decoder the surface code's threshold is about 10.3%; add measurement errors as likely as data errors (p = q, a model called phenomenological noiseEach round, every data qubit fails with probability p and every check readout flips with probability q, without modelling the measurement circuit's internals. The middle model between perfect measurement and circuit-level noise.) and it drops to about 2.9% (both numbers for matching, Wang–Harrington–Preskill 2003; for the same model Delfosse–Nickerson 2017 report 2.6% for the weighted-growth union-find decoder and 2.4% for the uniform-growth version). Not because the decoder got dumber, but because each round adds a whole layer of places to fail, and the failure mode — a string spanning spacetime — gains a direction to extend in.

现象学模型仍然是简化。真实的一轮测量由制备、四个 CNOT、读出组成，每一步都可能出错；一个辅助比特在第二个 CNOT 之后出错，会通过后两个 CNOT 传到两个数据比特上——《Surface Code · 高中数学版》第 4 章提过的 hook error（「钩子错误」：辅助比特上的一个故障，经过还没做完的 CNOT，变成数据比特上的两个错误）。在电路级噪声下，一个故障点亮的探测器不再总是「相邻的一对」：钩子错误留下的一对隔得更远；而一个同时带 X 与 Z 分量的故障，例如数据比特上的一个 Y 错误（Y = X·Z，只差一个相位），会同时点亮两族检查，一共四个探测器（图 5.1）。现代译码器先用模拟把每一种基本故障点亮哪些探测器、发生的概率多大列成一张表，叫探测器错误模型（detector error model）。可匹配图的一条边只能连两个探测器（或一个探测器与边界），所以只点亮一两个探测器的故障可以直接变成一条边，点亮三四个的故障就得先分解：拆成几块，每块只点亮一两个探测器，各当一条边。图 5.1 的 Y 错误拆成「Z 部分：点亮星 S1、S2」与「X 部分：点亮面 P1、P2」两条边，分别放进两族检查各自的匹配图。代价是丢掉关联：这两条边本来总是一起出现（一次故障），分开匹配时却被当成两次独立的故障，同时出现要付两份权重，这种组合的可能性就被低估了。以 PyMatching 为例，它的文档写明：从探测器错误模型建图时，点亮一两个探测器的故障成为边，点亮更多探测器、又没有给出分解的故障直接被忽略。尾声提到的 belief-matching 就是把这份关联找回来的一种办法。电路级噪声circuit-level noise：把一轮症状提取电路里的每个门、每次制备与读出都当作独立的出错位置。阈值数字依赖于具体电路与每步的错误定义，文献值约 0.5%–1%。下的阈值约 0.5%–1%（具体值取决于电路和「一步出错」的定义；例如 Fowler 等 2012 在他们的八步电路、每步错误率 p、匹配译码下得到 0.57%），这才是硬件团队真正对照的数字——第 6 章的账本会说清这些数字各自的前提。

The phenomenological model is still a simplification. A real round consists of preparation, four CNOTs and a readout, each of which can fail; an ancilla error after the second CNOT propagates through the remaining two onto two data qubits — the hook error mentioned in “The Surface Code · High-School Edition”, Chapter 4 (one fault on the ancilla which, through the CNOTs still to come, becomes two errors on data qubits). Under circuit-level noise a single fault no longer always lights “a neighbouring pair” of detectors: a hook error leaves a pair further apart, and a fault with both an X and a Z component, such as a Y error on a data qubit (Y = X·Z up to a phase), lights both families of checks, four detectors in all (Fig. 5.1). Modern decoders first tabulate, by simulation, which detectors each elementary fault lights and how likely it is: the detector error model. But an edge of a matching graph joins only two detectors (or one detector and the boundary), so a fault lighting one or two detectors becomes an edge directly, while a fault lighting three or four must first be decomposed: split into pieces that each light one or two detectors, each piece becoming an edge. The Y error of Fig. 5.1 splits into “the Z part, lighting stars S1 and S2” and “the X part, lighting plaquettes P1 and P2”, two edges placed in the matching graphs of the two check families. The price is lost correlation: the two edges always occur together (one fault), yet matched separately they count as two independent faults, their joint occurrence is charged two weights, and the combination is judged less likely than it is. PyMatching, for example, documents that when it builds a graph from a detector error model, faults lighting one or two detectors become edges, and faults lighting more that come without a suggested decomposition are ignored. Belief-matching, mentioned in the epilogue, is one way to recover that correlation. Under circuit-level noiseEvery gate, preparation and readout in one syndrome-extraction round is an independent fault location. The threshold depends on the specific circuit and on how a step's error is defined; literature values are about 0.5%–1%. the threshold is about 0.5%–1% (the exact value depends on the circuit and on how “one step fails” is defined; Fowler et al. 2012, for instance, find 0.57% for their eight-step circuit, per-step error rate p and matching) — the number hardware teams actually compare against; Chapter 6's ledger spells out the premises behind each figure.

一个阈值数字离开了它的模型就没有意义。至少要写清五件事：① 数据错误信道——只有 Z 错误？X 与 Z 独立？退极化？② 症状模型——完美测量、现象学（第 5 章）、还是电路级？③ 电路约定——若是电路级，一轮有几步、每步的错误怎么定义？④ 译码器——最大似然、匹配、并查集，以及是否利用了退化与相关性？⑤ 归一化——p 是每个位置、每步、每轮还是每周期的概率？缺任何一项，数字就只能留在文献综述里，不能写进读者面前的正文。

A threshold number is meaningless away from its model. Five things must be stated at minimum: ① the data error channel — Z errors only? independent X and Z? depolarising? ② the syndrome model — perfect, phenomenological (Ch. 5), or circuit-level? ③ the circuit convention — if circuit-level, how many steps per round and how is a step's error defined? ④ the decoder — maximum likelihood, matching, union-find, and whether it exploits degeneracy or correlations? ⑤ the normalisation — is p per location, per step, per round or per cycle? Missing any one, the number belongs in a literature survey, not in text put before a reader.

读这本账的方法：同一行内比较才有意义，跨行比较必先换算。10.9% 与 10.3% 的差是译码器（3.2 节）；10.3% 与 2.9% 的差是症状模型（第 5 章）；2.9% 与 0.57% 的差是把「一轮」拆成了八个可以出错的步骤，还要注意后者的 p 是每步的概率。《Surface Code · 高中数学版》引用的「约 10.3%」与「电路级 0.5%–1%」，就是这本账里的第二行和第五行。

How to read the ledger: comparisons within a row are meaningful; across rows they need conversion first. 10.9% versus 10.3% is the decoder (§3.2); 10.3% versus 2.9% is the syndrome model (Ch. 5); 2.9% versus 0.57% comes from splitting “one round” into eight fault-prone steps — and note the latter's p is per step. The “about 10.3%” and “circuit-level 0.5%–1%” quoted in “The Surface Code · High-School Edition” are rows two and five of this ledger.

下面的实验台对 d = 3、5、7 的表面码，用三种译码器各跑同一组「加噪 → 译码 → 判定」实验：贪心（3.1）、最小重量匹配（第 2 章，≤ 16 个警报时精确）、并查集（第 4 章）。三族曲线形状相同，交叉点不同——这就是「译码器决定数字」的实物。它们都在本页的「完美测量、只有 Z 错误」模型下，所以只能与账本第一到第三行比，而且只能粗看。p 只取 2%、4%……16% 八个点，间隔 2 个百分点；读数报的是 d = 3 与 d = 7 两条曲线第一次换位（d = 7 的失败率开始高于 d = 3）的那一格区间，外加一个在这一格里线性插值得到的估计。这个区间是观测到的，不是误差棒：每点只抽 300 或 1000 次，失败率本身就带着统计误差（在失败率 15% 至 30% 一带，300 次时约 ±4 到 ±5 个百分点，1000 次时约 ±2 到 ±3 个百分点，95% 置信），足以让换位的格子前后挪一格，读数会把这两点上的误差一并列出；d = 3 与 d = 7 这样小的尺寸，交叉点本身还会随尺寸漂移（有限尺寸效应），文献里的阈值是用更大的 d 外推出来的；最后，d = 7 在高错误率下警报常常超过 16 个，「最小重量匹配」这时退回贪心，会把它的交叉点往下拉。

The bench below runs the same noise → decode → verdict experiment on d = 3, 5, 7 surface codes with three decoders: greedy (§3.1), minimum-weight matching (Ch. 2, exact up to 16 alarms), and union-find (Ch. 4). Three families of curves, same shape, different crossings — “the decoder sets the number” made tangible. All three live in this page's “perfect measurement, Z errors only” model, so they compare only with rows one to three of the ledger, and only roughly. p takes just eight values, 2%, 4%, …, 16%, spaced 2 percentage points apart; the readout reports the grid interval in which the d = 3 and d = 7 curves first swap order (d = 7 starts failing more often than d = 3), plus an estimate by linear interpolation within that interval. The interval is what was observed, not an error bar: each point draws only 300 or 1000 samples, so each failure rate carries its own sampling error (for failure rates around 15% to 30%, about ±4 to ±5 percentage points at 300 samples and ±2 to ±3 at 1000, at 95% confidence), enough to move the swap by a grid cell, and the readout lists that error at the two points; at sizes as small as d = 3 and d = 7 the crossing itself also drifts with size (a finite-size effect), and the literature thresholds are extrapolated from much larger d; finally, at high error rates d = 7 often has more than 16 alarms, where “minimum-weight matching” falls back to greedy and drags its crossing down.

《Surface Code · 高中数学版》6.2 节的压制律 P_L ≈ A(p/p_th)^⌈d/2⌉ 暗示：d 每加 2，逻辑错误率就除以 p_th/p。实验上直接测量这个倍数，记作 Λ = P_L(d)/P_L(d+2)。Willow 芯片用离线神经网络译码器测得 Λ ≈ 2.14（换成实时译码器是 2.0 ± 0.1）：d 从 3 到 5、5 到 7，逻辑错误率各缩小约一半。同一份数据换个译码器，Λ 就变——这本身就说明 Λ 是整台机器加上它的译码器拟合出来的数，包含了非均匀的噪声、相关错误、译码器的精度与实时性；它不等于任何一行账本上的 p_th 除以芯片的 p。把 Λ = 2.14 反推成「p_th/p = 2.14」，是这本账最常见的误读。

The suppression law of “The Surface Code · High-School Edition”, §6.2 P_L ≈ A(p/p_th)^⌈d/2⌉ suggests that each +2 in d divides the logical error rate by p_th/p. Experiments measure that factor directly and call it Λ = P_L(d)/P_L(d+2). The Willow chip measured Λ ≈ 2.14 with an offline neural-network decoder (2.0 ± 0.1 with its real-time decoder): from d = 3 to 5 and 5 to 7, the logical error rate roughly halved each time. The same data give a different Λ under a different decoder — which by itself shows that Λ is a fit to the whole machine together with its decoder — heterogeneous noise, correlated errors, the decoder's accuracy and its real-time constraints; it equals no ledger row's p_th divided by the chip's p. Reading Λ = 2.14 back as “p_th/p = 2.14” is this ledger's most common misreading.

复盘整条推理链：译码是在两个类之间二选一（第 1 章）→ 对数把「最可能」变成「最短」，问题化为症状图上的最小重量完美匹配，配法数是双阶乘，而 Edmonds 的开花算法多项式时间可解（第 2 章）→ 贪心输给 3-2-3 陷阱，匹配输给 C(a+b, a) 条退化的链，这就是 10.9% 与 10.3% 之差（第 3 章）→ 并查集译码器用奇偶与合并换取几乎线性的速度（第 4 章）→ 探测器让测量错误变成时间方向的一对端点，同一个匹配问题多一维（第 5 章）→ 一本五项限定的账把所有阈值数字各归各位（第 6 章）。你现在读一篇译码器论文的摘要，应该能立刻找到它站在账本的哪一行。

Replaying the chain: decoding is a binary choice between two classes (Ch. 1) → logarithms turn “most probable” into “shortest”, the problem becomes a minimum-weight perfect matching on the syndrome graph, pairings number a double factorial, and Edmonds' blossom algorithm solves it in polynomial time (Ch. 2) → greed loses to the 3-2-3 trap and matching to C(a+b, a) degenerate chains, which is the gap between 10.9% and 10.3% (Ch. 3) → the union-find decoder trades parity and merging for almost-linear speed (Ch. 4) → detectors turn measurement errors into endpoint pairs along time, the same matching one dimension up (Ch. 5) → a five-qualifier ledger files every threshold number (Ch. 6). Reading a decoder paper's abstract now, you should be able to locate its ledger row at once.

三条继续走的路。其一，相关性：一个 Y 错误（同时是 X 错误和 Z 错误）同时触发 X 与 Z 两族检查，分开译码会丢掉这份线索。belief-matching 先用「置信传播」（让每个警报和它相邻的比特来回交换「这里出错的可能性有多大」的估计，几轮之后得到每个比特的出错概率）算出这些关联，再据此调整匹配的权重；Higgott 等（arXiv 2022）报告，在他们的电路级噪声模型下它的阈值约 0.94%，同一模型下普通最小重量匹配约 0.82%。其二，实时性：把匹配或并查集做进 FPGA（可以现场改写电路的芯片）与专用芯片，让译码稳定地跟上症状的节拍——Google 2024 年的实验已在 d = 5 上做到实时译码，平均延迟 63 微秒。其三，新码。qLDPC 码（量子低密度奇偶校验码）的定义有两半：每条检查只碰少数几个比特，每个比特也只被少数几条检查碰到，而且这两个数都不随码变大而增长。按这个定义，表面码本身就是 qLDPC 码（每条检查最多碰 4 个比特，每个比特最多在 4 条检查里）。人们说「新的 qLDPC 码」时，指的通常是表面码以外、检查不再局限于平面近邻的码，例如《BB 码》里的双变量自行车码：那里每个数据比特在 3 条 X 型检查里，一个 Z 错误就点亮 3 个警报。这样的码的症状图不再是「每个错误恰好点亮两个警报」的匹配结构，需要新工具，例如置信传播加有序统计译码（BP-OSD：置信传播给不出一致答案时，按出错概率从大到小挑出最可疑的一组比特，直接解一个线性方程组）。入口文献见下。

Three roads onward. One, correlations: a Y error (an X and a Z error at once) triggers both the X and the Z check families, and decoding them separately throws that clue away. Belief-matching first runs “belief propagation” (alarms and their neighbouring qubits repeatedly exchange estimates of “how likely is an error here”, yielding after a few rounds an error probability for each qubit) to capture such correlations, then reweights the matching accordingly; Higgott et al. (arXiv 2022) report a threshold of about 0.94% for it under their circuit-level noise model, against about 0.82% for standard minimum-weight matching in the same model. Two, real time: matching or union-find cast into FPGAs (chips whose circuitry can be rewired in the field) and dedicated chips, so that decoding reliably keeps pace with the syndrome — Google’s 2024 experiment already decoded in real time at d = 5 with an average latency of 63 µs. Three, new codes. A qLDPC code (quantum low-density parity-check code) is defined by two halves: every check touches only a few qubits, every qubit is touched by only a few checks, and neither number grows as the code gets larger. By this definition the surface code is itself a qLDPC code (each check touches at most 4 qubits, each qubit sits in at most 4 checks). When people speak of “new qLDPC codes” they usually mean codes beyond the surface code whose checks are no longer confined to planar neighbours, such as the bivariate bicycle codes of the BB tutorial: there every data qubit sits in 3 X-type checks, so a single Z error lights 3 alarms. The syndrome graphs of such codes lose the “every error lights exactly two alarms” matching structure and need new tools such as belief propagation with ordered-statistics decoding (BP-OSD: when belief propagation gives no consistent answer, pick the most suspicious set of qubits in order of error probability and solve a linear system for them directly). Entry points below.