从 Toric Code
到 Surface Code From the Toric Code
to the Surface Code

一个量子比特的状态（《从 1+1 到 Toric Code》3.1 节）是一对配比数字（振幅），可正可负；测量得 0 或 1 的概率是各自振幅的平方；测量后状态跳到所得答案上（坍缩）。未知的量子状态既不能复印（不可克隆），也经不起直接阅读。

A qubit's state (“From 1+1 to the Toric Code”, §3.1) is a pair of blend-numbers (amplitudes), possibly negative; measuring yields 0 or 1 with probability each amplitude squared; afterwards the state jumps onto the answer (collapse). Unknown quantum states can be neither photocopied (no-cloning) nor read without damage.

噪声有两种基本手法（《从 1+1 到 Toric Code》3.3–3.5 节）：X（交换两个振幅——0/1 眼镜里的翻转）与 Z（给 1-成分变号——它在 0/1 眼镜里隐形，却是 +/− 眼镜里的翻转，其中 |±⟩ = (|0⟩±|1⟩)/√2）。同一比特上 X 与 Z 反对易：交换先后顺序，差一个整体 −1。在复习台上戴两副眼镜各看一遍：

Noise has two elementary moves (“From 1+1 to the Toric Code”, §3.3–3.5): X (swap the amplitudes — a flip in the 0/1 lens) and Z (re-sign the 1-part — invisible in the 0/1 lens, yet a genuine flip in the +/− lens, where |±⟩ = (|0⟩±|1⟩)/√2). On one qubit X and Z anticommute: swapping their order costs one overall −1. Watch through both lenses:

多比特检查如 Z₁Z₂ 只问「这两个比特一样吗」（+1/−1），绝不问「各是什么」——它不破坏合法的叠加。编码状态被要求对清单上的每条检查都「必然 +1」；清单的学名是稳定子（《从 1+1 到 Toric Code》4.4 节）。计数规则有三个前提：检查两两对易（同时测不会互相打扰）；它们独立（没有一条是其他几条的乘积）；任何几条相乘都不等于 −I（否则「全部通过」要求 |ψ⟩ = −|ψ⟩，没有态能做到，例如 XZZ、ZXZ、ZZX、XXX 两两对易，四条之积却是 −I）。本页的检查每条要么全是 X、要么全是 Z，第三条自动成立：同一个比特上 X·X = I、Z·Z = I，纯 X 检查相乘不会冒出负号，纯 Z 同理，而一个纯 X 串乘一个纯 Z 串要等于 ±I，两者必须各自就是 I。满足这三条时，n 个比特配 r 条检查，每加一条检查编码空间砍半，一共砍 r 次，剩下 k = n − r 个逻辑量子比特；k 数逻辑比特，和编码论的写法 [[n, k, d]] 一致（同一节的记号说明）。错误 E 触发检查 S 报警，当且仅当 E 与 S 反对易；判据是数格子：

Multi-qubit checks like Z₁Z₂ ask only “are these two equal?” (+1/−1), never “what are they?” — legal superpositions survive. Encoded states must answer “+1 surely” to every check on the list (formally, the stabilizers; “From 1+1 to the Toric Code”, §4.4). The counting rule has three conditions: the checks commute pairwise (measuring one does not disturb another); they are independent (none is a product of the others); and no product of them equals −I (otherwise “pass them all” demands |ψ⟩ = −|ψ⟩, which no state satisfies: XZZ, ZXZ, ZZX, XXX commute pairwise, yet the product of all four is −I). On this page every check is all-X or all-Z, and then the third condition holds by itself: on one qubit X·X = I and Z·Z = I, so a product of all-X checks never picks up a minus sign, likewise for all-Z, and an all-X string times an all-Z string can equal ±I only if each is I on its own. Under these three conditions, n qubits with r checks: each check halves the code space, r halvings in all, leaving k = n − r logical qubits; k counts logical qubits, as in the coding-theory label [[n, k, d]] (see the notation note in that same section). An error E trips a check S exactly when E and S anticommute; the test is cell-counting:

L×L 的绕回网格（环面；《从 1+1 到 Toric Code》5.1–5.3 节）：每条边一个量子比特（共 2L²）；每个顶点一条星形检查 A_v（4 条边上的 X），每块面一条面检查 B_p（4 条边上的 Z）。星与面永远共享 0 或 2 条边（角连两边），所以全体检查对易。两条「乘积=I」的恒等式让独立检查只有 2L²−2 条——环面恰好存 2 个逻辑量子比特。

An L×L wrap-around grid (a torus; “From 1+1 to the Toric Code”, §5.1–5.3): one qubit per edge (2L² total); at each vertex a star check A_v (X on its 4 edges), on each face a face check B_p (Z on its 4 edges). A star and a face always share 0 or 2 edges (corners touch two sides), so all checks commute. Two “product = I” identities leave 2L²−2 independent checks — the torus stores exactly 2 logical qubits.

错误连成链，警报只亮在链的端点（《从 1+1 到 Toric Code》5.4–5.8 节；链中间偶数次相撞，抵消）。闭合且可收缩的圈 = 若干检查的乘积 = 对编码信息什么也不做；缠绕环面一整圈的圈通过所有检查却改写逻辑信息——它就是逻辑算符 Z̄ / X̄，最短长度 L 即码距 d。纠错 = 给警报配对、连线修复；「错误 ⊕ 修复」（⊕：合并两批边、成对相消）可收缩则完胜、缠绕则败。到沙盘里活动一下手脚：

Errors form chains; alarms light only at endpoints (“From 1+1 to the Toric Code”, §5.4–5.8; interiors are struck an even number of times and cancel). A closed contractible loop = a product of checks = does nothing to the data; a loop winding the torus passes every check yet rewrites logical data — it is the logical operator Z̄ / X̄, of minimum length L, the distance d. Correcting = pairing alarms and joining them; “error ⊕ repair” (⊕: merge the two edge sets with pairwise cancellation) contractible = win, winding = loss. Stretch your legs in the sandbox:

先看清「绕回去」在硬件上意味着什么：最右一列的比特要和最左一列做同一条检查——两端相隔整块芯片的导线，要么飞跨芯片（工艺噩梦），要么把整个平面卷成圆筒再接成环（更是噩梦）。本页设想的是一种常见的超导芯片版图：比特固定在平面上，每个比特只和隔壁的比特直接耦合，排成只连邻居的方形阵列。这是这种版图的限制，不是物理定律：超导比特也可以借助一条共享的微波波导与较远的比特相互作用（例如 Zanner 等人 2022 年在 Nature Physics 上的实验，arXiv 2106.05623，四个比特经同一条波导耦合），离子阱和中性原子则可以搬运比特，只是搬得越远越慢、越容易出错。在这种近邻方阵上，每条检查最好只碰近邻，这就是剪开环面的动机。

First, what wrap-around means in hardware: qubits in the rightmost column must share checks with the leftmost — wiring that leaps across the whole chip (a fabrication nightmare), or a plane rolled into a tube and closed into a ring (worse). This page assumes a common superconducting layout: qubits fixed in a plane, each coupled directly only to its neighbours, forming a square array wired only to neighbours. That is a limit of this layout, not a law of physics: superconducting qubits can also interact with more distant ones through a shared microwave waveguide (for example the 2022 Nature Physics experiment of Zanner et al., arXiv 2106.05623, with four qubits coupled through one waveguide), and ion traps and neutral atoms can move qubits around, though the farther they move, the slower and more error-prone it gets. On a nearest-neighbour square array each check should touch only neighbours, and that is the reason to cut the torus open.

那就拿起剪刀。但《从 1+1 到 Toric Code》5.3 节的记账立刻警告我们，这一刀不便宜。环面的账本是：

So pick up the scissors. But the ledger of “From 1+1 to the Toric Code”, §5.3 warns at once: this cut is not free. On the torus,

那两条「白送的恒等式」（∏A_v = I，∏B_p = I）之所以成立，全靠「每条边恰好被两颗星、两块面分享」——这是绕回世界才有的完美均匀。剪开后边缘出现残缺检查，恒等式失效，k 会掉回 0？还是能抢救出 1 个逻辑比特？下面把整个手术分三步看完：

Those two “free identities” (∏A_v = I, ∏B_p = I) held because every edge is shared by exactly two stars and two faces — the perfect uniformity only a wrap-around world provides. After the cut, mutilated checks appear along the rim, the identities die — does k crash to 0, or can one logical qubit be rescued? Watch the whole surgery in three steps:

第 ③ 步不是随手收拾，而是本教程的主角登场。上下两侧让星缺一条腿（三腿星是合法检查）；左右两侧让面缺一条腿——并且额外保留悬在边缘的半截边（每条上仍住着一个量子比特）。这两种「收边方式」性质完全不同，是下一章的全部内容。

Step ③ is not casual tidying — it is this tutorial's protagonist entering. On the top/bottom sides the stars lose one leg (a three-leg star is a legal check); on the left/right the faces lose one leg — and the dangling half-edges are kept, each still housing a qubit. These two ways of hemming an edge behave utterly differently, and they are the whole of the next chapter.

看上一章第 ③ 步的成品。左右两侧参差地伸出半截边，像布料的毛边——叫它毛边界悬挂着半截边（每条半截边上仍有一个量子比特）的边界。这里的面检查缺一条腿（三腿 Z 检查）。通称「粗糙边界 rough boundary」。（术语：粗糙边界）：这里的面检查只剩三条腿，B_p = ZZZ。上下两侧剪得干净利落，没有悬边——叫它光边界没有悬挂边、被顶点收束的边界。这里的星形检查缺一条腿（三腿 X 检查）。通称「光滑边界 smooth boundary」。（术语：光滑边界）：这里的星检查只剩三条腿，A_v = XXX。

Inspect step ③'s result. The left and right sides sprout ragged half-edges, like fabric's frayed hem — call it the rough boundaryA boundary with dangling half-edges (each still carrying a qubit). Face checks here lose a leg (three-leg Z checks).: here the face checks keep only three legs, B_p = ZZZ. The top and bottom are cut clean, no danglers — the smooth boundaryA boundary hemmed by vertices, no dangling edges. Star checks here lose a leg (three-leg X checks).: here the star checks keep three legs, A_v = XXX.

先验收老规矩还在不在：任何星与任何面，共享边数仍然只能是 0 或 2（角连两边的几何论证只依赖局部形状，边界处照样成立——在下面的实验台上开「显示检查」自行核对）。所有检查依旧两两对易 ✓。

First re-inspect the old rule: any star and any face still share exactly 0 or 2 edges (the corner-touches-two-sides argument is purely local and survives at boundaries — verify on the bench below). All checks still commute pairwise ✓.

然后重新记账。设「距离参数」d既是版图的尺寸，也是码距：最短横跨串恰走 d 条边（第 3 章的补课 3.A 证明）。：版图有 d 行横边，每行 d 条（两端各一条悬边），顶点排成 d 行 d − 1 列（下面的蓝图是 d = 3，实验台可切换 d）。数出来的结果永远是：

Then redo the ledger. With the size parameter dBoth the layout size and the code distance: the shortest spanning string uses exactly d edges (proved in Catch-up 3.A).: the layout has d rows of horizontal edges, d per row (with a dangling one at each end), and its vertices form d rows and d − 1 columns (the blueprint below is d = 3; the bench lets you switch d). The counts always come out to:

数一数 d = 3 的蓝图：横边 3 行 × 3 条 = 9，竖边 2 行 × 2 条 = 4，n = 13 = 3² + 2²；星 = 3 行 × 2 列 = 6，面 = 2 行 × 3 列 = 6。点上下两排的顶点，会看到三条腿的星（光边界）；点最左、最右一列的方块，会看到三条腿的面（毛边界）。

Count the d = 3 blueprint: horizontal edges 3 rows × 3 = 9, vertical edges 2 rows × 2 = 4, n = 13 = 3² + 2²; stars = 3 rows × 2 columns = 6, faces = 2 rows × 3 columns = 6. Click a vertex in the top or bottom row to see a three-legged star (smooth boundary); click a square in the leftmost or rightmost column to see a three-legged face (rough boundary).

为什么恒等式没了？把全部星相乘：内部每条边仍被两颗星分享而抵消，但悬边只被一颗星碰到——乘积在每条悬边上都剩一个孤零零的 X，不等于 I。「白送的减 2」消失。这只说明「全部星的乘积」不是 I；别的挑法也不行，理由在下面的补课 2.A。于是独立检查 r = 2d(d − 1)：

Why did the identities die? Multiply all the stars: interior edges still cancel (two stars each), but a dangling edge is touched by only one star — the product leaves a lone X on every dangler, ≠ I. The free “−2” is gone. That only shows the product of all stars is not I; no other selection works either, for the reason in Catch-up 2.A below. So there are r = 2d(d − 1) independent checks:

回想警报的机理（《从 1+1 到 Toric Code》5.4 节）：Z-链的端点处，有一颗星被链奇数次撞到，于是报 −1。现在让一条 Z-链一路画到左侧的悬边上。悬边朝外的那一头，本该有下一颗星——但那里根本没有星（芯片到头了）。没有检查，就没有警报。链的这一端就这样无声地「死」在了毛边界上：

Recall the alarm mechanism (“From 1+1 to the Toric Code”, §5.4): at a Z-chain's endpoint some star is struck an odd number of times and reads −1. Now draw a Z-chain out onto a dangling edge at the left. Beyond the dangler's outer tip there ought to be a next star — but no star exists there (the chip has ended). No check, no alarm. That end of the chain quietly “dies” on the rough boundary:

分工是严格的。Z-链若把端点搭在上下（光）边界的边上，那里的三腿星照样看得见它——照样报警（去下面验证）。同理，X-链只能死在光边界；毛边界对它绝不留情。一种边界赦免一种链，恰好和「面在毛边界缺腿、星在光边界缺腿」一一对应。

The division of labour is strict. Rest a Z-chain's end on a top/bottom (smooth) edge and the three-leg star there still sees it — still alarms (verify below). Likewise X-chains may die only on the smooth boundary; the rough one shows them no mercy. Each boundary pardons one kind of chain — matching exactly “faces truncated at rough, stars truncated at smooth”.

把 3.1 推到极致：一条 Z-链两端都搭在毛边界上——从最左的悬边一路画到最右的悬边。零警报！它通过了全部检查。它是无害的「检查乘积」吗？不是：面检查无论怎样相乘，都造不出横穿整块芯片的串（下一个折叠盒用一次碰撞计数证明）。通过一切检查、又不是检查的乘积——按《从 1+1 到 Toric Code》5.6 节的定义，这是一条逻辑算符：

Push §3.1 to the limit: a Z-chain resting both ends on the rough boundary — drawn from a leftmost dangler clean across to a rightmost one. Zero alarms! It passes every check. Is it a harmless product of checks? No: however you multiply face checks, you can never manufacture a string crossing the whole chip (the fold-out below proves it with one collision count). Passing all checks yet not a product of them — by the definition of “From 1+1 to the Toric Code”, §5.6, a logical operator:

最短的横跨串要走 d 条边，所以码距是 d——和第 2 章账本里的 1 个逻辑比特配成一套。「最短恰好 d 条、没有更短的逻辑算符」的理由在下面的补课 3.A。

The shortest spanning string uses d edges, so the distance is d — completing the set with Chapter 2's single logical qubit. The reason why the shortest has exactly d edges, with no shorter logical operator, is in Catch-up 3.A below.

还有一处要小心：错误里「有一条横跨串」，不等于信息被改写。看蓝图最上面两行横边：串 ① = Z₁Z₂Z₃，串 ② = Z₄Z₅Z₆。每条单独拿出来都从左毛边界走到右毛边界，都是一个 Z̄。可两条合起来，正好是夹在它们中间那一排 3 块面检查的乘积：Z₁Z₄Z₁₀ · Z₂Z₅Z₁₀Z₁₁ · Z₃Z₆Z₁₁，10、11 号各出现两次、互相抵消（Z·Z = I），剩下的正是 Z₁…Z₆。所以两条平行的横跨串合起来对编码态什么也不做：Z̄ 做了两次，等于没做。真正的判据是奇偶。拿 X̄ 当测试线（中间一列，比特 2、5、8），数一条不报警的 Z 串和它交叉几次，也就是共享几个比特：奇数次 = 净做了一次 Z̄，逻辑错误；偶数次 = 检查的乘积，无害。串 ①、② 合起来交叉 2 次（比特 2 和 5）。理由很短：不报警的 Z 串都是「若干面检查」或「若干面检查乘一个 Z̄」，每块面和 X̄ 共享 0 或 2 个比特，Z̄ 和 X̄ 共享 1 个，所以交叉次数的奇偶正好告诉你里面有没有那个 Z̄。

One more point needs care: an error that “contains a spanning string” has not necessarily rewritten the data. Look at the top two rows of horizontal edges in the blueprint: string ① = Z₁Z₂Z₃, string ② = Z₄Z₅Z₆. Each on its own runs from the left rough boundary to the right one and is a Z̄. But together they are exactly the product of the row of 3 face checks between them: Z₁Z₄Z₁₀ · Z₂Z₅Z₁₀Z₁₁ · Z₃Z₆Z₁₁; qubits 10 and 11 appear twice and cancel (Z·Z = I), leaving exactly Z₁…Z₆. So two parallel spanning strings together do nothing to encoded states: Z̄ applied twice is no change at all. The real criterion is a parity. Use X̄ as a test line (the middle column, qubits 2, 5, 8) and count how often an alarm-free Z string crosses it, i.e. how many qubits they share: odd = one net Z̄, a logical error; even = a product of checks, harmless. Strings ① and ② together cross it twice (qubits 2 and 5). The reason is short: an alarm-free Z string is either a product of face checks or such a product times one Z̄; every face shares 0 or 2 qubits with X̄ and Z̄ shares 1, so the parity of the crossing count tells you whether that Z̄ is there.

回到第 2 章的蓝图，按「显示 Z̄」「显示 X̄」可以看到这一对串和它们唯一的共享比特。再在实验台里亲手画一条（也试试画不满全程、看警报怎么揭发你）：

Back in Chapter 2's blueprint, the “Show Z̄” and “Show X̄” buttons display this pair of strings and the single qubit they share. Now draw one by hand on the bench (and try stopping short, to see the alarms rat you out):

表面码存储器的一生就是同一支四拍舞：噪声悄悄放下几条链 → 测量全部检查、警报点亮链的端点 → 译码器读取全部警报、决定修复方案的（经典）算法。平面版可以把警报配给另一个警报，也可以配给最近的同类边界。把警报两两配对或配给边界 → 沿配对路径施加修复。修复后「错误⊕修复」不再触发任何警报，这时数它和 X̄ 的测试线交叉几次（3.2 节）：偶数次（只有小圈、贴边的弧，或成对的横跨串）——无害；奇数次——逻辑错误。看它自动运转：

A surface-code memory's life is one four-beat dance: noise quietly lays down chains → all checks are measured, alarms lighting the chains' endpoints → the decoderThe (classical) algorithm that reads all alarms and decides the repair. On the plane it may match an alarm to another alarm or to the nearest boundary of the right kind. pairs alarms with each other or with a boundary → repairs are applied along the pairing paths. After the repair, “error ⊕ repair” sets off no alarm; now count how often it crosses X̄'s test line (§3.2): an even number (only small loops, boundary-hugging arcs, or spanning strings in pairs) — harmless; an odd number — a logical error. Watch it run:

「测量 B_p」说来轻巧，可没有任何仪器能一口气「读四个量子比特的联合奇偶」。真实的做法是给每条检查配一个专职的帮手量子比特（术语：辅助比特不存储数据、专职收集一条检查的奇偶并被读出的量子比特。英文 ancilla。真实芯片上数据比特与辅助比特约各占一半。，ancilla）：让它挨个「碰」一遍那 4 个数据比特——每次接触都是一个两比特小操作，把一份奇偶信息叠进帮手——最后只测量帮手。数据比特从头到尾没被直接读过，四拍问询的净效果恰好就是我们从《从 1+1 到 Toric Code》一路用到这里的那句问话：「你们四个的联合奇偶是 +1 还是 −1？」

“Measure B_p” is easy to say, but no instrument reads “the joint parity of four qubits” in one gulp. The real recipe assigns each check its own dedicated helper qubit (term: the ancillaA qubit that stores no data; its job is to collect one check's parity and be read out. On real chips data and ancilla qubits are roughly half and half.): it “touches” the 4 data qubits one at a time — each touch a small two-qubit operation folding one parity's worth of information into the helper — and then only the helper is measured. The data qubits are never read directly, and the four-touch routine asks precisely the question “From 1+1 to the Toric Code” and this tutorial have leaned on: “is your joint parity +1 or −1?”

你看到的只有警报。点击两个警报即可自动沿最短路径连线修复；点选一个警报后按「连到最近边界」则把它推出边界。全部警报清零时立即判定：错误⊕修复和 X̄ 交叉奇数次就输，偶数次就赢（游戏正是按这个奇偶判的；即使合起来有两条平行的横跨串，它们也是一片面检查的乘积，照样算你赢）。规则回顾：Z-链只在左右（毛）边界免警报，所以只有推向左右才可能「无声」；游戏里的按钮已替你选择最近的合法边界。

You see only alarms. Click two alarms to auto-join them along a shortest repair path; select one and press “pair to nearest boundary” to push it out. The verdict lands the instant all alarms clear: if error ⊕ repair crosses X̄ an odd number of times you lose, an even number you win (the game judges exactly this parity; even if the combination contains two parallel spanning strings, they are a product of face checks and you still win). Rules recap: Z-chains are pardoned only at the left/right (rough) boundary, so only pushes toward left or right can be “silent”; the button already picks the nearest legal side for you.

几盘之后，你大概会自己摸到一条经验：近的配近的，靠边的推出去。但「近」要整体地看，而且「近」本身也还不是最终目标。这里有三个层次（图 5.1）。

① 贪心配对：每次先连当前最近的两个警报，连完再找下一对。它快，却会被骗：图 (a) 里四个警报在一条线上的 0、2、3、5 处，贪心先连最近的 B–C（长 1），剩下的 A–D 只好连成长 5，共 6；而 A–B 加 C–D 只要 2 + 2 = 4。② 最小总长度配对（学名最小重量完美匹配把所有警报（可以配给边界）一次性两两配好，使全部连线的总长度最小的算法；英文 minimum-weight perfect matching，简称 MWPM。「重量」指修复链碰到的比特数。）：把所有配法（包括配给边界）放在一起比较，挑总长度最小的一整套。每多一个错误，概率就多乘一个约 p 的小因子，所以 p 小时，它挑的就是「最可能发生的那一条错误链」。

③ 可我们其实不必猜中错误链本身。3.2 节说过，只要错误⊕修复和 X̄ 交叉偶数次就赢。所以和警报相符的所有错误链，按「和我的修复合起来交叉奇数次还是偶数次」分成两类；同一类里的链只差若干面检查，修哪一条效果都一样。最好的译码器（最大似然译码把每一类里所有错误链的概率加起来，选总概率最大的那一类，再从这一类里任取一条当修复。它的成功率在给定噪声模型下是最高的，但一般比配对难算得多。）把每一类里所有链的概率加起来，选总概率大的那一类。图 (b) 是 d = 3 蓝图上的一个例子：星 (2, 0)（腿 2、3、11）和星 (1, 1)（腿 4、5、10、12）报警。直接把两个警报连起来要 2 条边，有两种走法；各自推向最近的毛边界也要 2 条边，却只有一种走法，而且属于另一类。长度打平，最小总长度配对分不出高下；把所有链都算上，p 很小时「直接相连」这一类约是另一类的 2 倍可能。p = 5% 时核对脚本枚举了全部 2¹³ 种错误，精确比例是 64% 对 36%。

p 很小时，这三种译码器多数时候选的一样。4.1 节的动画和下一章的实验台用的是 ②，警报太多时退回 ①；本章游戏里配对由你自己来，它的「自动译码（示范）」按钮用的也是 ②。也试试拉高错误率滑杆：警报一多，「看起来近」的配法开始频繁酿成逻辑错误。这个「p 一大就救不回来」的体感，就是下一章的主角。

A few rounds in, you'll likely discover a rule of thumb yourself: pair near with near, push edge-huggers out. But “near” has to be judged for the whole set at once, and being near is not even the final goal. There are three levels (Figure 5.1).

① Greedy pairing: join the two closest alarms, then look for the next closest pair, and so on. It is fast but can be fooled: in panel (a) four alarms sit on a line at 0, 2, 3, 5; greedy first joins the closest pair B–C (length 1) and is left with A–D (length 5), 6 in all, whereas A–B plus C–D costs only 2 + 2 = 4. ② Minimum total length pairing (formally minimum-weight perfect matchingAn algorithm that pairs up all alarms at once (an alarm may be paired with a boundary) so that the total length of the joining paths is as small as possible; MWPM for short. “Weight” is the number of qubits a repair chain touches.): compare all pairings (including pairings to boundaries) together and pick the complete set with the smallest total length. Every extra error multiplies the probability by a small factor of about p, so for small p this picks “the single most likely error chain”.

③ But we never needed to guess the error chain itself. As §3.2 showed, we win whenever error ⊕ repair crosses X̄ an even number of times. So all error chains consistent with the alarms fall into two classes, according to whether they cross X̄ an odd or even number of times together with my repair; chains in the same class differ only by face checks, and repairing along any of them has the same effect. The best decoder (maximum-likelihood decodingAdd up the probabilities of all error chains in each class, choose the class with the largest total, and repair along any chain of that class. For a given noise model it has the highest success rate, but it is generally much harder to compute than matching.) adds up the probabilities of all chains in each class and picks the class with the larger total. Panel (b) is an example on the d = 3 blueprint: stars (2, 0) (legs 2, 3, 11) and (1, 1) (legs 4, 5, 10, 12) alarm. Joining the two alarms directly takes 2 edges and can be done in two ways; pushing each to its nearest rough boundary also takes 2 edges, but in only one way, and it is in the other class. The lengths tie, so minimum total length pairing cannot tell them apart; counting every chain, for small p the “join directly” class is about twice as likely as the other. At p = 5% the check script enumerated all 2¹³ error patterns: the exact split is 64% to 36%.

For small p the three decoders usually make the same choice. The animation in §4.1 and the next chapter's bench use ②, falling back to ① when there are too many alarms; in this chapter's game you do the pairing yourself, and its “Auto-decode (demo)” button also uses ②. Also try raising the error-rate slider: with many alarms, “looks close” pairings start producing logical errors more and more often. That felt sense of “past some p, it's unrescuable” is the next chapter's protagonist.

实验设定：每一轮里，每个量子比特独立地以概率 p 中一个 Z 错误；测量、译码、修复之后，检查「错误⊕修复」和 X̄ 交叉几次——奇数次即本轮失败。失败率随 d 怎么变？两股力量在掰手腕。力量一（保护）：要凑出横跨串，至少约 d/2 个错误得排成一线（码距 d 保证纠正 (d − 1)/2 个错误，见《从 1+1 到 Toric Code》4.6 节；译码器会把不到一半的部分修回来），概率带着 p^(d/2) 这个「面积级的小」；d 每加 2，就多乘一个 p。力量二（暴露）：芯片更大，可供失败的路线和起点也更多，数量随 d 增长。谁赢？取决于 p 的大小——两股力量恰好打平的那个 p，就叫阈值加大码距开始「有利可图」的临界物理错误率 p_th：p < p_th 时越大越好，p > p_th 时越大越糟。 p_th：

The setup: each round, every qubit independently suffers a Z error with probability p; after measure–decode–repair we count how often error ⊕ repair crosses X̄ — an odd count means the round failed. How does failure depend on d? Two forces arm-wrestle. Force one (protection): a spanning string needs roughly d/2 errors in a row (distance d guarantees correcting (d − 1)/2 errors, see §4.6 of “From 1+1 to the Toric Code”; the decoder repairs anything under half), so the probability carries p^(d/2), that “area-level smallness” — every +2 in d multiplies by another p. Force two (exposure): a bigger chip offers more failure routes and starting points, growing with d. Who wins? It depends on p — and the p where the two forces exactly tie is called the thresholdThe critical physical error rate p_th at which growing the distance starts paying off: below it bigger is better, above it bigger is worse. p_th:

读这条公式：p 远低于 p_th 时括号里远小于 1，指数 ⌈d/2⌉ 越大整体越小——d 每加 2，逻辑错误率乘一次同一个缩小因子，这就是指数压制。它是低噪声下的近似：推导时只数了最少的那几个错误，p 接近 p_th 时更多错误的组合不能再忽略，公式不再可靠，也就不能拿它外推到阈值以上。阈值以上的情况要另外看：数值模拟显示（下一节的实验台上你也能看到），那里码越大越糟。所以不同尺寸的曲线在低 p 端按大小排好，在高 p 端次序颠倒，中间必然相交，交在 p_th 附近——这就是我们要在实验里寻找的「交叉」签名。只用几个小尺寸时，曲线不一定严格交于一点，读出的交点是 p_th 的有限尺寸估计。

Reading it: for p well below p_th the bracket is far below 1, and a larger exponent ⌈d/2⌉ shrinks the whole thing — every +2 in d multiplies the logical error rate by the same reduction factor: exponential suppression. It is a low-noise approximation: it counts only the fewest errors that can cause failure, and as p approaches p_th combinations of more errors can no longer be neglected, so the formula stops being reliable and cannot be extrapolated above threshold. What happens above threshold has to be seen separately: numerical simulations show (and the bench in the next section lets you see) that there, bigger codes do worse. So curves of different sizes are ordered by size at low p and in reverse order at high p, and must cross in between, near p_th — the “crossing” signature our experiment will hunt for. With only a few small sizes the curves need not meet in exactly one point, and the crossing read off is a finite-size estimate of p_th.

下面的实验台会对 d = 3、5、7 三块表面码、十几个 p 值，各自跑成百上千轮「加噪→译码→判定」，实时画出失败率曲线。这不是预先存好的图——是你的浏览器现场做的蒙特卡洛实验（所以每次结果都带一点统计涨落）：

The bench below runs hundreds to thousands of noise→decode→verdict rounds for surface codes of d = 3, 5, 7 across a dozen p values, drawing the failure-rate curves live. Nothing is pre-baked — your browser is doing the Monte-Carlo experiment right now (hence a little statistical shimmer between runs):

左端读图：p 很小时，三条曲线按 d=7 < d=5 < d=3 排列——大码稳赢，而且每加大一号，失败率大约按同一比例再打一次折（6.1 的公式只管这一端）。右端：次序整个翻转。三条曲线中间的交叉带，是这个实验设定下阈值的有限尺寸估计：只有 d = 3、5、7 三个尺寸，外加蒙特卡洛的统计涨落，所以读出的是一段范围，不是一个精确的数。设定要说清楚：只有数据比特出 Z 错误、测量完美（文献称「码容量噪声」）；译码器在警报不超过 14 个时做精确的最小重量完美匹配（允许配到边界），警报更多时退为每次先配最近两个的贪心配对。p 较大时警报很多，贪心的比例上升，所以本页测出的交叉点会比下面文献里的数字偏低，通常落在百分之几到 10% 之间，每次运行略有涨落。

Read the left end: for small p the curves stack d=7 < d=5 < d=3 — big codes win, and each size step cuts failure by roughly the same factor (§6.1's formula covers only this end). At the right end the order fully inverts. The band where the three curves cross is a finite-size estimate of the threshold for this experimental setup: only three sizes, d = 3, 5, 7, plus Monte-Carlo scatter, so what you read off is a range, not a precise number. The setup must be stated: only data qubits suffer Z errors and measurements are perfect (the literature calls this “code-capacity noise”); the decoder performs exact minimum-weight perfect matching (boundaries allowed) when there are at most 14 alarms, and greedy closest-pair matching beyond. At larger p there are many alarms and more greedy rounds, so the crossing measured here sits below the literature figure below, typically somewhere between several percent and 10%, with some scatter from run to run.

这条曲线不再只属于纸面。截至本教程编写时：2023 年，Google 首次在真实芯片上演示 d=5 的表面码略优于 d=3（每轮纠错的逻辑错误率 2.914% 对 3.028%，arXiv 2207.06431；这两个数用张量网络译码器得到，那是一种近似的最大似然译码，见第 5 章的第 ③ 层；它们是 X、Z 两种基的平均，d = 3 的数又是芯片上四块 d = 3 子区的平均，每轮错误率从 25 轮数据拟合而来）——「加大真的更好」第一次在硬件上成立；2024 年底，其 Willow 芯片把演示推进到 d=7，每加大一号（d 加 2），逻辑错误率降为原来的 1/2.14（论文记作 Λ = 2.14 ± 0.02），d = 7 时每轮 0.143%（arXiv 2408.13687）。这两个数来自实验结束后离线运行的神经网络译码器，同样是 X、Z 两种基的平均；d = 3 和 d = 5 分别取 9 块和 4 块子区的平均，Λ 由 ln(逻辑错误率) 对 d 的直线拟合得到。同一篇论文里还有另一块 72 比特芯片上的 d = 5 实验，配合边测边译的实时译码器，得到 Λ = 2.0 ± 0.1。这些都是真实硬件的电路级噪声，和本页的玩具实验设定不同；同期多个平台（中性原子、离子阱、超导）都在各自路线上复现「低于阈值」的行为，也有团队探索比表面码更省比特的新型编码。数字仍在快速演进，但方向已经清楚：你在本章亲手测出的那种曲线，正在实验室里一条条变成现实。

The curve no longer lives only on paper. As of this tutorial's writing: in 2023 Google first demonstrated on real hardware that a d=5 surface code slightly beats d=3 (logical error per round of correction 2.914% versus 3.028%, arXiv 2207.06431; these come from a tensor-network decoder, an approximate maximum-likelihood decoder in the sense of level ③ of Chapter 5; they are averaged over the X and Z bases, the d = 3 figure is also averaged over four d = 3 sub-grids of the chip, and the per-round rate is fitted to data over 25 rounds) — “bigger is better” holding on a chip for the first time; in late 2024 their Willow chip pushed to d=7, with each size step (d up by 2) dividing the logical error rate by 2.14 (the paper's Λ = 2.14 ± 0.02), reaching 0.143% per round at d = 7 (arXiv 2408.13687). These two numbers come from a neural-network decoder run offline after the experiment, again averaged over the X and Z bases; the d = 3 and d = 5 figures are averages over 9 and 4 sub-grids, and Λ is a straight-line fit of ln(logical error rate) against d. The same paper also reports a d = 5 experiment on a separate 72-qubit chip with a real-time decoder that decodes while the experiment runs, giving Λ = 2.0 ± 0.1. All of these are circuit-level noise on real hardware, a different setting from this page's toy experiment; and platforms from neutral atoms to trapped ions to superconducting circuits have since reproduced below-threshold behaviour along their own routes, while other teams pursue newer codes thriftier in qubits than the surface code. The numbers keep moving fast, but the direction is set: the very curves you measured in this chapter are materializing, one by one, in laboratories.

从 1+1=2 到此处，你完成了一条完整的推理链：奇偶与负号 → 不偷看的检查 → 两种量子错误 → 对易的几何化 → 环面上的链与圈 → 剪开后的两种边界 → 横跨串与配对译码 → 阈值与指数压制。今天任何一篇表面码论文的核心图景——警报的星空、配对的连线、往下俯冲的曲线——你都已亲手操作过。

From 1+1=2 to here, you completed one unbroken chain of reasoning: parity and minus signs → checks that don't peek → two quantum errors → commuting made geometric → chains and loops on a torus → two boundaries after the cut → spanning strings and matching decoders → threshold and exponential suppression. The core imagery of any surface-code paper today — the starfield of alarms, the matching lines, the diving curves — you have now operated with your own hands.

三条值得继续走的路。路一：更省的版图。把我们的方格斜转 45° 再裁边，就得到「旋转表面码」——同样的码距只用 d² 个数据比特（d=5 时 25 个而非 41 个），是实验室里实际部署的版本；思想与本教程的版图完全相同，只是裁剪更精。路二：让逻辑比特做事。存住只是第一步，还得对逻辑比特做门操作：把两块码拼在一起再分开（「格点手术」lattice surgery）、以及为某些关键操作准备特制状态（「魔法态」magic states）——这是当前工程化的主战场。路三：更省的码。表面码的千倍开销并非宿命，qLDPC 等新码型用更巧的检查图谱换取更高的编码率，是近年最活跃的方向。三条路的入口文献都在下方。

Three roads worth walking on. Road one: thriftier layouts. Tilt our grid 45° and trim — the “rotated surface code”, achieving the same distance with only d² data qubits (25 instead of 41 at d=5); it is the version actually deployed in labs, identical in ideas, tighter in tailoring. Road two: making the logical qubit work. Storage is step one; logical gates come next — merging and splitting code patches (“lattice surgery”) and preparing special resource states for the stubborn operations (“magic states”): today's main engineering front. Road three: thriftier codes. The surface code's thousandfold overhead is not destiny — qLDPC and friends trade cleverer check-graphs for higher encoding rates, the liveliest research direction of recent years. Entry points to all three are below.