从高考数学
推导出 Toric Code From high-school math
to the Toric Code

默认你已具备（高三平均水平即可，不需要竞赛背景）：

Assumed (average final-year level, no olympiad background needed):

教程现场建造（超出大纲，但每件都只需十分钟）：2×2 矩阵与矩阵乘法（第 1 章）、张量积（第 4 章）、本征值与本征态、投影测量（第 3–4 章）。承诺不变：凡超出高中大纲的概念，绝不在未定义时使用。

Built on site (beyond the syllabus, ten minutes each): 2×2 matrices and matrix multiplication (Ch. 1), tensor products (Ch. 4), eigenvalues/eigenstates and projective measurement (Ch. 3–4). The standing promise: nothing beyond the syllabus is ever used before it is defined.

页面用法：带 试一试 标签的面板是真实运行的模拟器，不是插图；蓝边盒子存放关键结论；橙边盒子交代简化与完整版的差距；可展开的「为什么？」盒子装选读证明——这一版里，多数证明就在那里，建议都打开。正文里引用前文结论的橙色虚线（如「按 4.3 的投影算符」），点一下会原地弹出该定义的小卡片，免去来回翻页；希腊字母与新符号（ψ、λ、⊗ 这类浅灰点线）点一下则会告诉你它怎么读、什么意思，页尾附完整符号读音表。右上角可切换中/EN。若中途觉得节奏太快，同一套内容备有零基础版：《从 1+1 到 Toric Code》（零基础版）→

Using the page: panels tagged Try it are live simulators, not pictures; blue-edged boxes hold key conclusions; amber boxes disclose simplifications; fold-out “why?” boxes carry the optional proofs — in this edition most proofs live there, and opening them is recommended. Amber dashed citations of earlier results (like “by §4.3's projectors”) pop up a small card restating that definition in place — one click, no scrolling back; Greek letters and novel symbols (ψ, λ, ⊗ — faint grey dotted) click to reveal how they are read and what they mean, with a full pronunciation table at the end. The 中/EN switch sits top-right. If the pace ever feels steep, the same material exists in a no-prerequisites edition: “From 1+1 to the Toric Code” (no-prerequisites edition) →

你熟悉平面向量 v = (x, y)。现在我们需要描述对向量的操作——把一个向量变成另一个向量的规则。最有用的一类操作是「线性」的：新坐标是旧坐标的固定组合。这样的操作只需 4 个数就能完全记录，把它们排成 2×2 的方阵，称为矩阵，并规定它作用在（竖着写的）向量上的方式：

You know plane vectors v = (x, y). We now need to describe operations on vectors — rules turning one vector into another. The most useful ones are “linear”: each new coordinate is a fixed mix of the old ones. Four numbers record such a rule completely; arrange them in a 2×2 array, call it a matrix, and define how it acts on a (column-written) vector:

立刻认识两位主角。交换矩阵 S 与变号矩阵 D：

Meet the two protagonists at once: the swap matrix S and the re-sign matrix D:

连续做两个操作呢？「先 B 后 A」把 v 变成 A(B·v)。存在唯一的矩阵把这两步并成一步，记作 AB，叫矩阵乘法：AB 的第 i 行第 j 列元素 = A 的第 i 行与 B 的第 j 列对应相乘再相加（和上面「行点乘向量」同一动作，逐列做一遍）。「什么都不做」也有矩阵：单位矩阵 I（对角线 1，其余 0），满足 I·v = v，且 S² = D² = I（交换两次、变号两次都回到原样）。

Two operations in a row? “B then A” sends v to A(B·v). A unique matrix does both in one step; write it AB and call the recipe matrix multiplication: entry (i, j) of AB = row i of A dotted with column j of B (the same row-dot move as above, done column by column). “Do nothing” has a matrix too: the identity I (ones on the diagonal), with I·v = v and S² = D² = I (swapping twice or re-signing twice restores everything).

现在做一道全教程最重要的计算题。请亲手算 SD 与 DS（把 D 的每一列喂给 S 的每一行；再反过来）：

Now the most important exercise in this tutorial. Compute SD and DS by hand (feed D's columns to S's rows; then the reverse):

回炉三件事：z = a + bi（i² = −1）；模 |z| = √(a²+b²)；共轭 z̄ = a − bi，且 z·z̄ = |z|²。量子力学的「配比数字」（振幅）一般是复数，概率永远等于模的平方 |z|²——本教程的公式将一律写成 |·|² 以保持通用，但主线的所有例子里振幅都是实数（此时 |a|² 就是 a²），你不会在任何一步真的被复数拦住。

Three re-polished facts: z = a + bi (i² = −1); modulus |z| = √(a²+b²); conjugate z̄ = a − bi with z·z̄ = |z|². Quantum “blend numbers” (amplitudes) are complex in general, and probability is always the modulus squared |z|² — our formulas will be written with |·|² for full generality, though in every worked example of the main path the amplitudes are real (where |a|² is just a²), so no step will ever actually strand you in ℂ.

要用的只有三件：独立事件的概率相乘；「n 次独立试验中恰好 k 次命中」的二项分布公式；以及「频率随试验次数趋稳于概率」的大数直觉——最后这条抽象，亲手抛一抛最踏实：

Only three items get used: probabilities of independent events multiply; the binomial formula for “exactly k hits in n independent trials”; and the law-of-large-numbers intuition that frequencies settle toward probabilities — best re-earned by flipping for yourself:

平凡，但请高看它一眼：后文所有「检查是否报警」的判定，最终都会归结为数一个整数的奇偶。

Trivial — yet give it a second look: every “does this check alarm?” verdict ahead reduces, in the end, to the parity of one integer.

一个比特取 0 或 1。存储与传输不完美：设每个比特独立地以概率 p 被翻转（0↔1）。先感受 p 的威力：

A bit is 0 or 1. Storage and transmission are imperfect: let each bit be independently flipped (0↔1) with probability p. Feel what p does:

最老的对策：发 0 记作 000、发 1 记作 111（编码：1 个「逻辑比特」写进 3 个「物理比特」），接收后多数表决。至少 2 个比特同时翻转才会译错，用 1.3 的二项分布立刻写出失败概率：

The oldest countermeasure: send 0 as 000, 1 as 111 (encoding: one “logical bit” written into three “physical bits”), then decode by majority vote. It fails only when ≥2 bits flip, so §1.3's binomial delivers the failure probability at once:

什么时候划算？解不等式 3p² − 2p³ < p：除以 p（p>0），得 2p² − 3p + 1 > 0，因式分解 (2p−1)(p−1) > 0，而 p < 1 使第二个因子为负，故需 2p−1 < 0，即 p < 1/2。结论：只要信道「好过抛硬币」，重复就有利可图，且 p 越小、p_L ≈ 3p² 的压缩越悬殊——p = 1% 时失败率降到约 0.03%。这种「错误率从 p 降到 ~p² 量级」的交易是一切纠错码的心脏。模拟对照理论：

When does it pay? Solve 3p² − 2p³ < p: divide by p (p>0) to get 2p² − 3p + 1 > 0, factor as (2p−1)(p−1) > 0; since p < 1 makes the second factor negative, we need 2p − 1 < 0, i.e. p < 1/2. Whenever the channel beats a coin flip, repetition pays — and the smaller p, the more lopsided the p_L ≈ 3p² compression: at p = 1% the failure rate drops to ≈0.03%. This “p down to ~p²” trade is the heart of all error correction. Simulation vs theory:

多数表决有个隐藏动作——它读出了全部三个比特。经典世界无所谓；但第 3 章会证明，量子信息一被读取就受损。所以现在改练一种永不读内容的检修法：只测两个奇偶量 s₁ = b₁⊕b₂、s₂ = b₂⊕b₃（⊕ 表示模 2 加法：相同得 0，不同得 1）。读数 (s₁, s₂) 称为症状，四种取值恰好区分「无错 / 翻了 b₁ / 翻了 b₂ / 翻了 b₃」，而对内容 000 还是 111 一无所知：

Majority voting hides a step — it reads all three bits. Harmless classically; but Chapter 3 will prove that reading damages quantum information. So we now train a repair method that never reads content: measure only the two parities s₁ = b₁⊕b₂, s₂ = b₂⊕b₃ (⊕ is addition mod 2: equal gives 0, different gives 1). The reading (s₁, s₂) is called the syndrome; its four values exactly separate “no error / b₁ flipped / b₂ / b₃”, while revealing nothing about whether 000 or 111 is stored:

一个量子比特遵循量子力学的两状态系统（原子的两个能级、超导电路……）。英文 qubit。的两个「纯读数」记作 |0⟩ 与 |1⟩（读 ket 0 / ket 1——就是给基向量起的名字），并规定它们是二维空间的标准基：

A qubitAny two-state system obeying quantum mechanics (two atomic levels, a superconducting circuit…).'s two “pure readings” are written |0⟩ and |1⟩ (read “ket 0 / ket 1” — names for basis vectors), declared to be the standard basis of a two-dimensional space:

先认三个记号：状态惯例命名为 ψ（希腊字母，读「普西」）；ℂ 是双线体大写 C，读「复数集」，ℂ² 即两个复数组成的向量全体；∈ 读「属于」。公设一（状态）：系统的状态是一个长度为 1 的向量（分量叫振幅状态向量的分量，一般为复数；测得对应结果的概率 = 振幅的模方。，可以为负、甚至为复数）。公设三（测量）：在 0/1 基上测量，得 0 的概率是 |a|²、得 1 的概率是 |b|²（模方规则，因此要求长度 1：|a|²+|b|²=1 就是概率归一）；测量后状态坍缩为所得的那个基向量，原振幅信息即刻消失。在实振幅的切片上亲手体会（拖动箭头就是在改 a、b）：

Three notations first: states are customarily named ψ (Greek, read “psy”); ℂ, the double-struck C, reads “the complex numbers”, so ℂ² is the set of two-complex-entry vectors; ∈ reads “belongs to”. Postulate one (states): the system's state is a length-1 vector (components called amplitudesThe state vector's components, complex in general; the probability of an outcome is the amplitude's modulus squared., possibly negative or complex). Postulate three (measurement): measuring in the 0/1 basis gives 0 with probability |a|² and 1 with |b|² (the modulus-squared rule — whence length 1: |a|²+|b|²=1 is exactly normalization); afterwards the state collapses onto the basis vector obtained, the old amplitudes gone. Explore the real-amplitude slice by hand (dragging the arrow edits a and b):

公设二（操作）：一个孤立系统（不与外界交换任何东西）在不被测量时，状态的变化是「线性保长度」的，即由矩阵实现。第 1 章的两位主角现在亮明身份——交换矩阵 S 与变号矩阵 D 正是量子比特最基本的两种「拨动」，行话记作 X 与 Z；连同含 i 的第三位成员，合称泡利矩阵：

Postulate two (operations): while an isolated system (one that exchanges nothing with its surroundings) is not being measured, its state changes in a “linear and length-preserving” way, i.e. by a matrix. Chapter 1's protagonists now show their badges — the swap matrix S and re-sign matrix D are precisely the qubit's two elementary nudges, written X and Z; together with a third member containing i they form the Pauli matrices:

X 交换振幅（量子版比特翻转）：X(a,b)ᵀ=(b,a)ᵀ；Z 给 |1⟩-分量变号：Z(a,b)ᵀ=(a,−b)ᵀ。噪声施加 X 称为 X 错误，施加 Z 称为 Z 错误——注意 Z 完全不改动 |a|²、|b|²，在 0/1 测量里彻底隐形。它究竟动了什么？回答这个问题需要一个新词。

X swaps amplitudes (the quantum bit-flip): X(a,b)ᵀ=(b,a)ᵀ; Z re-signs the |1⟩ component: Z(a,b)ᵀ=(a,−b)ᵀ. Noise applying X is an X error; applying Z, a Z error — and note Z leaves |a|², |b|² untouched, utterly invisible to 0/1 measurement. What, then, did it change? Answering needs one new word.

本教程的噪声模型（一个选择，不是公设的推论）。真实的比特并不孤立：它会和周围环境交换能量，所以公设二管不到它挨的噪声。例：处在 |1⟩ 的比特会自发落回 |0⟩，把能量交给环境（称为振幅阻尼amplitude damping：比特自发从 |1⟩ 落回 |0⟩、把能量交给环境的噪声。没有人测量它，但它也不是一个保长度的矩阵。）。看最极端的情形：|0⟩ 不动，|1⟩ 必然变成 |0⟩。若这是一个矩阵 M，那么 M(1,0)ᵀ = (1,0)ᵀ、M(0,1)ᵀ = (1,0)ᵀ，按线性 M(1/√2, 1/√2)ᵀ = (2/√2, 0)ᵀ = (√2, 0)ᵀ，平方和是 2 而不是 1：长度没有保住，所以它不是公设二说的那种操作。本教程（以及本系列）选定一种简化的模型：噪声偶尔对某个比特施加一个 X 或 Z，其余时候不打扰它。这样错误就只有 X 错误、Z 错误两种（以及二者同时发生），后面的全部机制都在这个模型里讲。

This tutorial's noise model (a choice, not a consequence of the postulates). Real qubits are not isolated: they exchange energy with their surroundings, so Postulate two does not cover the noise they suffer. Example: a qubit in |1⟩ can fall back to |0⟩ on its own, handing its energy to the environment (called amplitude dampingNoise in which a qubit falls from |1⟩ back to |0⟩ on its own, giving its energy to the environment. Nobody measures it, yet it is not a length-preserving matrix either.). Take the extreme case: |0⟩ stays put and |1⟩ always becomes |0⟩. If this were a matrix M, then M(1,0)ᵀ = (1,0)ᵀ and M(0,1)ᵀ = (1,0)ᵀ, so by linearity M(1/√2, 1/√2)ᵀ = (2/√2, 0)ᵀ = (√2, 0)ᵀ, whose squares add to 2, not 1: length is not preserved, so this is not an operation of the kind Postulate two describes. This tutorial (and this series) chooses a simplified model: now and then noise applies an X or a Z to some qubit, and otherwise leaves it alone. Errors then come in just two kinds, X errors and Z errors (and both at once), and every mechanism from here on is explained within this model.

对矩阵 M，若非零向量 v 满足 M·v = λ·v（M 不改变 v 的方向，只整体乘上常数 λ），（λ 是希腊字母，读「拉姆达」，惯用来当这个倍数的名字），就称 v 是 M 的本征态Mv = λv 中的 v（eigenvector/eigenstate）；λ 叫本征值（eigenvalue）。高中未学，此处即学即用。、λ 是对应的本征值。Z 的本征态一眼可见就是 |0⟩ 与 |1⟩；要说 X 的本征态，得先给两个新向量起名字：

For a matrix M, a nonzero vector v with M·v = λ·v (M keeps v's direction, only scaling it by λ) (λ — Greek, read “LAM-da” — is the customary name for that factor) is called an eigenstateThe v in Mv = λv; λ is its eigenvalue. Not in the syllabus — taught here, used immediately. of M with eigenvalue λ. Z's eigenstates are visibly |0⟩ and |1⟩; to name X's we first need two new vectors:

读 ket plus / ket minus。它们是3.1 节意义下合法的状态：长度都是 1（(1/√2)² + (1/√2)² = 1），在 0/1 基上测量各以 1/2 的概率得 0 或 1——两者的读数概率完全相同，唯一的差别是两个振幅之间的相对符号。在 0/1 基上测量看不见这个符号，但它是真实的——本节末尾会用另一种测量把它测出来。现在逐一验证四个例子（每个都是一次矩阵乘向量的口算）：

Read “ket plus” and “ket minus”. Both are legitimate states in the sense of §3.1: length 1 ((1/√2)² + (1/√2)² = 1), and a 0/1 measurement gives 0 or 1 with probability 1/2 each — identical readout probabilities, the only difference being the relative sign between the two amplitudes. A 0/1 measurement cannot see that sign, but it is real — by the end of this section a different measurement will detect it. Now verify four examples (each a one-line matrix-times-vector mental calculation):

于是 Z 的本征态是 |0⟩、|1⟩（本征值 +1、−1），X 的本征态是 |±⟩（同样 ±1）。测量的推广：物理上「测量算符 O」意为提问「你处于 O 的哪个本征值？」——答案只会是本征值之一，概率由状态在各本征态上的分量模方给出，测后坍缩到对应本征态。「在 0/1 基测量」就是「测 Z」；同理「测 X」问的是 ±。把 |ψ⟩=(a,b)ᵀ 分解到 |±⟩ 上，用向量点乘即可求分量（实数情形；复数时点乘需带共轭，见折叠盒）：

So Z's eigenstates are |0⟩, |1⟩ (eigenvalues +1, −1) and X's are |±⟩ (again ±1). Measurement, generalized: physically, “measuring an operator O” asks “which eigenvalue of O are you at?” — the answer is always an eigenvalue, with probability the modulus-squared of the state's component along each eigenstate, followed by collapse onto it. “Measuring in the 0/1 basis” is exactly “measuring Z”; likewise “measuring X” asks ±. Decomposing |ψ⟩=(a,b)ᵀ along |±⟩ takes one dot product each (real case; the complex case conjugates one factor — see the fold):

现在回答 3.2 的悬案：Z 交换 |+⟩ 与 |−⟩（口算：Z(1,1)ᵀ/√2 = (1,−1)ᵀ/√2 ✓）。所以 Z 错误是 ± 基里的翻转——0/1 眼镜里隐形，± 眼镜里现形；X 错误恰好相反。一个量子比特有两副眼镜、两种翻转，两副眼镜必须同时设防。左右对照：

Now the §3.2 mystery resolves: Z swaps |+⟩ and |−⟩ (mental math: Z(1,1)ᵀ/√2 = (1,−1)ᵀ/√2 ✓). So a Z error is a flip in the ± basis — invisible through the 0/1 lens, glaring through the ± lens; X errors are the mirror image. One qubit, two lenses, two flips — and both lenses need guarding. Compare side by side:

你在 1.1 已经亲手算过 SD = −DS。换上真名就是：

You already computed SD = −DS in §1.1. Under their true names:

术语：AB = BA 称 A、B 对易commute：AB = BA，先后顺序无关。；AB = −BA 称反对易anticommute：AB = −BA，交换顺序付出整体 −1。同一比特上的 X 与 Z 反对易。。作用在不同比特上的操作互不干涉、必定对易。这一对词是全教程的中枢神经：往后每次判断「检查报不报警」，都是在判断「对易还是反对易」。分步动画复习一遍：

Terminology: AB = BA means A and B commuteAB = BA: order irrelevant.; AB = −BA means they anticommuteAB = −BA: swapping order costs a global −1. X and Z on one qubit anticommute.. Operations on different qubits never interfere and always commute. This word-pair is this tutorial's central nervous system: every future “will this check alarm?” is an is-it-commuting question. Replay stepwise:

把第 2 章的重复码平移过来，立刻撞上两堵墙。墙一：编码第一步「把状态复印三份」被不可克隆定理禁止——不存在能把任意未知态 |ψ⟩ 复制成两份的操作。证明只有三行，但用到「两个系统合起来怎么写」，即下一章的张量积；届时在折叠盒里兑现。墙二：多数表决要读取比特，而公设三说读取即坍缩。出路在 2.3 早已排练：奇偶检查从不读内容。下一章就把它量子化。

Port Chapter 2's repetition code over and hit two walls at once. Wall one: the first step, “photocopy the state in triplicate”, is banned by the no-cloning theorem — no operation copies an arbitrary unknown |ψ⟩. The proof is three lines but needs “how two systems combine”, i.e. next chapter's tensor product; it will be honoured there in a fold. Wall two: majority voting reads bits, and postulate three says reading collapses. The way out was rehearsed in §2.3: parity checks never read content. Next chapter quantizes them.

两个量子比特合起来有四个基本读数，基向量记作 |00⟩、|01⟩、|10⟩、|11⟩（第一位是 1 号比特），一般状态是四维单位向量 |ψ⟩ = a₀₀|00⟩ + a₀₁|01⟩ + a₁₀|10⟩ + a₁₁|11⟩。若两个比特各自独立处于 (a₁, b₁)ᵀ 与 (a₂, b₂)ᵀ，合并态的振幅就是逐对相乘（这个合并操作记作 ⊗，读「张量积」）：

Two qubits jointly have four basic readings, with basis kets |00⟩, |01⟩, |10⟩, |11⟩ (first slot = qubit 1); a general state is a four-dimensional unit vector |ψ⟩ = a₀₀|00⟩ + a₀₁|01⟩ + a₁₀|10⟩ + a₁₁|11⟩. If the two qubits are independently in (a₁, b₁)ᵀ and (a₂, b₂)ᵀ, the joint amplitudes are the pairwise products (an operation written ⊗, read “tensor product”):

关键在反面：不是所有四维态都能这样拆开。试拆 贝尔态(|00⟩+|11⟩)/√2：最著名的纠缠态。单看任何一个比特都是纯随机，合看却完全相关。 (|00⟩+|11⟩)/√2 = (1/√2, 0, 0, 1/√2)ᵀ：需要 a₁b₂ = 0，于是 a₁ = 0（与 a₁a₂ = 1/√2 矛盾）或 b₂ = 0（与 b₁b₂ = 1/√2 矛盾）——三行反证，无解。拆不开的状态称为纠缠态。贝尔态是最彻底的一种：单看任何一个比特，测 0/1 各得一半，这个比特自己什么也不透露；合看两个，结果永远相同。信息全在关联里。但「拆不开」本身并不保证这一点。例：√0.8|00⟩ + √0.2|11⟩ 用同样的三行反证也拆不开，可单测第一个比特，就以 0.8 的概率得 0、0.2 的概率得 1，状态的一部分信息露在单个比特上。纠错需要的是更强的性质：要保护的信息在单个比特（以及少数几个比特）上完全看不出来，像贝尔态那样。这才是我们要用来藏匿逻辑比特的口袋，第 5 章的环面码就把逻辑比特藏在这种遍布全局的关联里。操作也升级到寄存器上：X₁ 表示「对 1 号比特做 X、对 2 号什么都不做」，即 X⊗I——作用规则是翻转基标签的第一位；Z₂ 给第二位为 1 的分量变号，依此类推。

The reverse direction is the point: not every four-dimensional state factors this way. Try the Bell state(|00⟩+|11⟩)/√2: the most famous entangled state. Each qubit alone is pure noise; together, perfect correlation. (|00⟩+|11⟩)/√2 = (1/√2, 0, 0, 1/√2)ᵀ: we'd need a₁b₂ = 0, so a₁ = 0 (contradicting a₁a₂ = 1/√2) or b₂ = 0 (contradicting b₁b₂ = 1/√2) — a three-line contradiction, no solution. Unfactorable states are entangled. The Bell state is the most thorough kind: look at either qubit alone and a 0/1 measurement gives each outcome half the time, so that qubit reveals nothing by itself; look at both and the results always agree. All the information sits in the correlation. Being unfactorable does not guarantee this, though. Example: √0.8|00⟩ + √0.2|11⟩ is unfactorable by the same three-line contradiction, yet measuring the first qubit alone gives 0 with probability 0.8 and 1 with probability 0.2, so part of the state's information shows on a single qubit. Error correction needs the stronger property: the protected information cannot be seen at all on a single qubit (or on a few qubits), as in the Bell state. That is the pocket where we will hide logical qubits; the toric code of Chapter 5 hides them in correlations of exactly this spread-out kind. Operations upgrade to registers too: X₁ means “X on qubit 1, nothing on qubit 2”, i.e. X⊗I — flip the first slot of each basis label; Z₂ re-signs components whose second slot is 1; and so on.

形如 X₁Z₃（= X⊗I⊗Z）的多比特操作叫泡利串每个比特一格、格中为 I/X/Z（完整版还有 Y）的多比特算符，如 X·I·Z。：每比特一格，格里是 I、X 或 Z。两串相乘时能否交换顺序？逐格搬运即可。不同格互不干涉：按 4.1 的规则，X₁ 只翻转基标签的第 1 位，Z₂ 只按第 2 位决定是否变号，谁也不改对方看的那一位，所以对任何基向量，先 X₁ 后 Z₂ 与先 Z₂ 后 X₁ 结果相同。例：|01⟩ 先 X₁ 得 |11⟩、再 Z₂ 得 −|11⟩；先 Z₂ 得 −|01⟩、再 X₁ 得 −|11⟩。同一格里只有「X 遇 Z」按 3.4 节付出一个 −1。例如 X₁X₂·Z₁Z₂ = (X₁Z₁)(X₂Z₂) = (−Z₁X₁)(−Z₂X₂) = +Z₁Z₂·X₁X₂：两格各付一个 −1，合起来对易。于是：

Multi-qubit operations like X₁Z₃ (= X⊗I⊗Z) are called Pauli stringsOne cell per qubit, each I/X/Z (plus Y in the full story), e.g. X·I·Z.. When two strings multiply, may we swap their order? Carry them past each other cell by cell. Different cells never interfere: by §4.1's rules, X₁ only flips label slot 1 and Z₂ only decides its sign by slot 2, so neither changes the slot the other reads, and on every basis vector X₁-then-Z₂ equals Z₂-then-X₁. Example: |01⟩ becomes |11⟩ under X₁ and then −|11⟩ under Z₂; Z₂ first gives −|01⟩, then X₁ gives −|11⟩. Within one cell, only “X meets Z” costs a −1 by §3.4. For instance X₁X₂·Z₁Z₂ = (X₁Z₁)(X₂Z₂) = (−Z₁X₁)(−Z₂X₂) = +Z₁Z₂·X₁X₂: each of the two cells costs a −1, and together they commute. Hence:

任何泡利串 S 都满足 S² = I（每格自乘：X²=Z²=I²=I）。于是它的本征值 λ 满足 λ² = 1（由 Sv=λv 得 v = S²v = λ²v），只能是 ±1——每条检查都是一道「±1 问答题」。测量的机器由一对投影算符实现：

Every Pauli string S obeys S² = I (cell-wise: X²=Z²=I²=I). Its eigenvalues therefore satisfy λ² = 1 (from Sv=λv, v = S²v = λ²v), so they can only be ±1 — each check is a ±1 quiz. The measuring machine is a pair of projectors:

测量规则（公设三的完整版）：测 S 得 ±1 的概率是 p± = |P±ψ|²（分量的长度平方），测后状态是 P±ψ 重新拉伸回单位长度。两个成分互相垂直（P₊P₋=0），勾股定理保证 p₊+p₋ = |ψ|² = 1。两道例题把它算透：

The measurement rule (postulate three, full version): measuring S returns ±1 with probability p± = |P±ψ|² (the component's squared length); the post-state is P±ψ rescaled to unit length. The two components are perpendicular (P₊P₋=0), so Pythagoras gives p₊+p₋ = |ψ|² = 1. Two worked examples settle it:

现在批量提问。一份清单上的检查必须两两对易——否则无法同时都「必然 +1」：若 ST = −TS 而 Sψ = ψ、Tψ = ψ，则 ψ = STψ = −TSψ = −ψ，只能 ψ = 0，不是合法状态。互相对易、要求全部「必然 +1」的泡利串清单称为稳定子stabilizer：一组两两对易的泡利串检查；编码态被要求是它们全体的 +1 本征态。，通过全部检查的状态构成编码空间。它有多大？

先说清哪些检查算数。一条检查若等于清单上另外几条的乘积，就不独立：它的读数总能由那几条的读数乘出来，测它不提供新信息。例：三个比特上的 Z₁Z₂、Z₂Z₃、Z₁Z₃，因 Z₂² = I，(Z₁Z₂)(Z₂Z₃) = Z₁Z₃，第三条不独立；八个基向量里通过前两条的只有 |000⟩、|111⟩，它们也自动通过第三条。记 r = 独立检查的条数（上例 r = 2，而不是 3）。判断独立时不计正负号：若 T 等于另外几条的乘积再乘 −1，T 同样不独立，它的读数也被那几条的读数定死，只是等于它们乘积的相反数。这种情形更糟：那几条都读 +1 时，T 必然读 −1，再要求 T 也读 +1 就自相矛盾；换个说法，这几条连同 T 乘起来等于 −I，而 −I 作用在任何状态上都给出 −ψ，没有状态能对它「必然 +1」。所以清单还得满足一条：没有哪几条检查乘起来等于 −I。两两对易的检查也可能违反它（下面第二个折叠盒给出一份这样的清单）；本页用到的检查每条只含 X 或只含 Z，自动满足（同一个折叠盒里有理由）。满足时，每条独立检查把空间维数砍掉一半（下面第一个折叠盒证明），于是：

Now ask in bulk. Checks on one list must pairwise commute — else they cannot all be “+1 surely”: if ST = −TS with Sψ = ψ and Tψ = ψ, then ψ = STψ = −TSψ = −ψ, forcing ψ = 0, which is not a legal state. A list of mutually commuting Pauli strings, all required to read “+1 surely”, is called the stabilizerA set of pairwise-commuting Pauli-string checks; encoded states are common +1 eigenstates of all of them., and the states passing every check form the code space. How big is it?

First, which checks count. A check that equals the product of some other checks on the list is not independent: its reading can always be multiplied together from theirs, so measuring it brings no new information. Example: on three qubits take Z₁Z₂, Z₂Z₃, Z₁Z₃; since Z₂² = I, (Z₁Z₂)(Z₂Z₃) = Z₁Z₃, so the third is not independent; of the eight basis vectors only |000⟩ and |111⟩ pass the first two, and they pass the third automatically. Write r = the number of independent checks (r = 2 above, not 3). Independence ignores signs: if T equals a product of some other checks times −1, T is not independent either, since its reading is again fixed by theirs, only as the negative of their product. That case is worse: when those checks all read +1, T must read −1, so demanding +1 from T as well is a contradiction; put differently, those checks together with T multiply to −I, and −I turns every state into −ψ, so no state can answer “+1 surely” to it. Hence the list must satisfy one more condition: no selection of checks multiplies to −I. Pairwise-commuting checks can still violate it (the second fold-out below gives such a list); the checks on this page each contain only X’s or only Z’s and satisfy it automatically (the same fold-out says why). When it holds, each independent check cuts the dimension in half (proved in the first fold-out below), so:

记号说明：k 数的是逻辑量子比特（2^k 维的空间恰好装下 k 个量子比特，4.1），r 数的是独立检查。这与编码论的通用写法 [[n, k, d]] 一致（d 在 4.5 出场），本系列后面各篇都这样用。

A note on notation: k counts logical qubits (a 2^k-dimensional space holds exactly k qubits, §4.1) and r counts independent checks. This matches the standard coding-theory label [[n, k, d]] (d appears in §4.5), and every later tutorial in this series uses it the same way.

还差一个角色：逻辑算符——与全部检查对易（不触发警报）、又不能写成检查乘积（不是「白干」）的泡利串。它不把状态带出编码空间（与每条检查对易，理由同折叠盒），却在编码空间内部真的改写了状态：改写的正是逻辑比特。「真的改写」要靠一个反对易的搭档来证明，4.5 和 5.6 各给一例。

One cast member remains: logical operators — Pauli strings commuting with every check (no alarms) yet not products of checks (not “doing nothing”). They never carry a state out of the code space (they commute with every check, for the reason in the fold-out), yet they really do change states inside it: what they change is the logical qubit. “Really do change” is proved with an anticommuting partner; §4.5 and §5.6 give one example each.

取 n = 3、清单 {Z₁Z₂, Z₂Z₃}（对易：Z 遇 Z 无碰撞）。同时「必然 +1」要求相邻位标签相同，八个基向量只剩 |000⟩ 与 |111⟩：编码空间 = {α|000⟩ + β|111⟩}，恰好 2³⁻² = 2 维（n = 3、r = 2），存 k = 1 个逻辑比特 ✓。这不违反 4.1 的不可克隆定理：编码只是用两次「受控翻转」（CNOT：第 1 位是 1 时翻转目标位）把第 1 位的标签抄到第 2、3 位，α|000⟩ + β|100⟩ → α|000⟩ + β|110⟩ → α|000⟩ + β|111⟩；配比数字 α、β 只出现一次。真正的三份副本 |ψ⟩⊗|ψ⟩⊗|ψ⟩ 会有 α³|000⟩ + α²β|001⟩ + … 共 8 项。逻辑算符（字母头上一横读「bar」，标记「逻辑版」）可取 X̄ = X₁X₂X₃（与每条检查碰撞 2 次，对易 ✓；交换 |000⟩↔|111⟩，即逻辑翻转）与 Z̄ = Z₁（零碰撞 ✓；给 |111⟩ 变号）。X̄ 与 Z̄ 在 1 号格碰撞 1 次——反对易 ✓，一对合格的逻辑 X/Z。Z̄ 真的改写了编码态：Z̄(α|000⟩ + β|111⟩) = α|000⟩ − β|111⟩。

Take n = 3 with checklist {Z₁Z₂, Z₂Z₃} (commuting: Z meets Z, no collisions). Demanding both “+1 surely” forces neighbouring label slots equal, leaving only |000⟩ and |111⟩ of the eight basis kets: code space = {α|000⟩ + β|111⟩}, dimension 2³⁻² = 2 (n = 3, r = 2) — k = 1 logical qubit ✓. This does not violate §4.1's no-cloning theorem: encoding just uses two “controlled flips” (CNOT: flip the target slot if slot 1 is 1) to copy the label of slot 1 onto slots 2 and 3, α|000⟩ + β|100⟩ → α|000⟩ + β|110⟩ → α|000⟩ + β|111⟩; the mixing numbers α, β still appear only once. Three genuine copies |ψ⟩⊗|ψ⟩⊗|ψ⟩ would have 8 terms, α³|000⟩ + α²β|001⟩ + …. As logical operators (the overbar reads “bar” and marks the logical edition) take X̄ = X₁X₂X₃ (two collisions with each check: commutes ✓; swaps |000⟩↔|111⟩ — the logical flip) and Z̄ = Z₁ (zero collisions ✓; re-signs |111⟩). X̄ and Z̄ collide once, in cell 1 — anticommute ✓: a proper logical X/Z pair. Z̄ really does change encoded states: Z̄(α|000⟩ + β|111⟩) = α|000⟩ − β|111⟩.

侦错机制一句话：编码态满足 Sψ = ψ；错误 E 落下后状态为 Eψ；若 E 与 S 反对易，则 S(Eψ) = −E(Sψ) = −Eψ——检查 S 必然读出 −1。警报=反对易，隐身=对易。X₂ 与两条检查各撞一次 → 症状 (−1, −1)，唯一指认 2 号比特，再补一个 X₂ 即痊愈。但 Z₂ 与两条检查都零碰撞——毫无警报；而 Z₂ 在编码空间上与 Z̄ 作用完全相同（都只给 |111⟩ 变号）——一次无声的逻辑错误。在实验台上把两种命运都走一遍：

Error detection in one sentence: encoded states satisfy Sψ = ψ; after an error E the state is Eψ; if E anticommutes with S, then S(Eψ) = −E(Sψ) = −Eψ — check S reads −1 with certainty. Alarm = anticommute; invisibility = commute. X₂ collides once with each check → syndrome (−1, −1), uniquely naming qubit 2; one more X₂ heals it. But Z₂ has zero collisions with both checks — no alarm at all; and on the code space Z₂ acts identically to Z̄ (each re-signs |111⟩ only) — a silent logical error. Walk both fates on the bench:

泡利串的重量是它不为 I 的格数：X₁X₂X₃ 重 3，Z₁ 重 1。对 X 错误，最轻的逻辑算符是 X₁X₂X₃，d_X = 3；对 Z 错误，一个 Z₁ 就够，d_Z = 1。码距 d 的码保证纠正任意 (d − 1)/2 个错误（取整数部分）：少于一半时，离原码字比离另一个码字近，按「离谁近」修复不会修错。编码论把三项指标并排写成 [[n, k, d]]，d 取各类错误中最小的一个：三比特码是 [[3, 1, 1]]。

The weight of a Pauli string is its number of non-I cells: X₁X₂X₃ has weight 3, Z₁ weight 1. Against X errors the lightest logical operator is X₁X₂X₃, so d_X = 3; against Z errors a single Z₁ suffices, d_Z = 1. A code of distance d is guaranteed to correct any (d − 1)/2 errors (whole-number part): with fewer than half, the state is closer to the original code word than to any other, so “repair towards the nearest” never goes wrong. Coding theory writes the three numbers side by side as [[n, k, d]], with d the smallest over all kinds of error: the 3-qubit code is [[3, 1, 1]].

把清单换成 {X₁X₂, X₂X₃} 只是镜像：捉得住 Z、放得过 X。设计任务书就此写定：需要一族 Z-型检查与一族 X-型检查共存；任意 X-串检查与任意 Z-串检查的碰撞数必须恒为偶数（碰撞定理）；两种码距对称且可任意加大；每条检查只碰少数几个近邻比特。1997 年，Kitaev 的回答是把这一切交给几何：画在网格上，让「偶数」成为定理而非巧合。

Swapping in {X₁X₂, X₂X₃} merely mirrors the failure: catches Z, misses X. The design brief is now fixed: a Z-type family and an X-type family must coexist; every X-string check must meet every Z-string check in an even number of cells (collision theorem); both distances symmetric and freely growable; each check touching only a few neighbours. Kitaev's 1997 answer hands it all to geometry: draw it on a grid, and make “even” a theorem instead of a coincidence.

取方格网。三种部件各派其职：边上住量子比特；每个顶点 v 配一条 X-型检查（星形检查），每块面 p 配一条 Z-型检查（面检查）：

Take a square grid and assign its three parts: qubits live on edges; each vertex v carries an X-type check (the star), each face p a Z-type check (the plaquette):

定理（对易性）：任意 A_v 与任意 B_p 对易。证明即碰撞定理加一条几何观察：碰撞只能发生在共享边上，而一个顶点与一个方形面，要么不相干（0 条共享边），要么顶点是该面的一个角——而每个角恰好连着面的两条边（一横一竖）。共享数 ∈ {0, 2}，恒为偶数。∎ 不必信文字，亲手清点：

Theorem (commutation): every A_v commutes with every B_p. Proof: the collision theorem plus one geometric observation — collisions occur only on shared edges, and a vertex either ignores a square face (0 shared edges) or sits at one of its corners, where it touches exactly two of the face's sides (one horizontal, one vertical). The overlap is always 0 or 2 — even. ∎ Don't take prose's word; tally it:

普通网格有边缘，边缘顶点凑不满 4 条边，规则破碎。最干净的修补是取周期边界：右边出去左边回来、上边出去下边回来。这样的曲面就是环面左右一对边粘合、上下一对边粘合得到的闭曲面；甜甜圈的表面。torus。——甜甜圈的表面，toric code 因此得名。此时每个顶点严格 4 条边、每个面严格 4 条边，无一例外。到绕回世界里走两步：

An ordinary grid has a rim; rim vertices can't muster 4 edges and the rules crumble. The cleanest patch is periodic boundary conditions: exit right, re-enter left; exit top, re-enter bottom. The resulting surface is the torusThe closed surface from gluing left↔right and top↔bottom; a donut's skin. — a donut's skin, whence the name. Now every vertex has exactly 4 edges and every face exactly 4 sides, no exceptions. Take a stroll in the wrap-around world:

画在纸上时，环面通常被摊平成 L × L 的方格图，并约定右边缘与左边缘是同一条线、下边缘与上边缘是同一条线。下面是 L = 3 的完整蓝图：18 个比特全部编号（1–9 在横边，10–18 在竖边），最右一列与最下一行的边用虚线再画一遍，编号与它们真正所在的左列、上行相同。点顶点看星形检查 A_v 碰哪 4 个比特，点方块看面检查 B_p；角上的顶点会把腿伸到图的对侧，但共享比特数照样是 0 或 2。

On paper the torus is usually drawn flattened into an L × L grid, with the agreement that the right rim equals the left rim and the bottom rim equals the top rim. Below is the complete blueprint for L = 3: all 18 qubits numbered (1–9 on horizontal edges, 10–18 on vertical ones), with the edges of the rightmost column and bottom row drawn again, dashed, carrying the numbers of the left column and top row where they really live. Click a vertex to see which 4 qubits its star A_v touches, a square for its face check B_p; a corner vertex reaches to the opposite side, yet the number of shared qubits is still 0 or 2.

L×L 环面：横边 L² + 竖边 L² = 2L² 个比特；星、面各 L² 条。若全部独立，4.4 的公式 k = n − r 给 k = 2L² − 2L² = 0——但独立性恰恰不成立。每条边连两个顶点，于是把全部星相乘时每个比特吃到两个 X，而 X² = I：

The L×L torus: L² horizontal + L² vertical = 2L² qubits; L² stars and L² plaquettes. If all were independent, §4.4's k = n − r would give k = 2L² − 2L² = 0 — but independence is precisely what fails. Every edge meets two vertices, so multiplying all stars feeds every qubit two X's, and X² = I:

「恰为」的另一半，即除这两条外再无其他依赖，由下面的补课 5.A 直接数出来；它只用到「每条边连两个顶点、挨两个面」和网格连成一片。看动画数账，并看「全体星相乘」如何逐边抵消：

The other half of “exactly”, that there is no further dependency, is counted directly in Catch-up 5.A below; it uses only “every edge joins two vertices and borders two faces” and the fact that the grid is in one piece. Watch the ledger, and the all-stars product cancel edge by edge:

设一批边挨了 Z 错误，把这些边涂蓝：它们连成链。哪些星报警？由 4.5 的判决（警报 ⇔ 反对易）加碰撞定理：A_v 与链的碰撞数 = 链中碰到 v 的边数。链内部的顶点被两条链边穿过——偶数，安静；只有链的端点被奇数条链边碰到——报警。X 错误的链画在对偶方向（连接相邻面心），报警的是端点处的面：边 e 上的 X 与挨着 e 的两个面检查各碰撞一次，所以从一个面心跨过出错的边走到隔壁面心，恰好沿着 X 链走。一整条链无论多长，只点亮两处：

Say a batch of edges takes Z errors; paint them blue — they form chains. Which stars alarm? By §4.5's verdict (alarm ⇔ anticommute) plus the collision theorem: A_v's collision count with the chain = the number of chain edges touching v. Interior vertices are crossed by two chain edges — even, silent; only the chain's endpoints are touched by an odd number — alarm. X-error chains run in the dual direction (joining adjacent face centres), alarming the faces at their ends: an X on edge e collides once with each of the two face checks beside e, so stepping from a face centre across an erring edge into the next face centre follows the X chain exactly. A chain of any length lights exactly two spots:

闭合圈没有端点，症状为空。但「没警报」不代表「没动过」——除非那个操作根本等于「白干」。对可收缩的圈（围出一块区域 R 的圈），确有此事：把 R 内所有面检查相乘，内部共享边上 Z·Z = I 逐对抵消，只幸存区域的外圈：

A closed loop has no endpoints, hence an empty syndrome. But “no alarm” isn't “nothing done” — unless the operation literally equals “doing nothing”. For contractible loops (those enclosing a region R), it does: multiply all face checks inside R; on interior shared edges Z·Z = I cancels pairwise, and only the region's rim survives:

环面上另有一种闭合圈：横贯一整行、从右边绕回左边接上自己。它不围任何区域——像箍在甜甜圈上的橡皮筋，收缩不掉。上面实验台的第二个示范画的正是它。它通过全部检查（圈上每个顶点恰好占两条圈边，与每颗星碰撞 0 或 2 次），却写不成面检查的乘积，而且真的改写编码态（这两点的理由见下面的补课 5.B）——按 4.4 的定义，这是一条逻辑算符。环面有两个独立绕向，给出 Z̄₁（水平 Z-圈）与 Z̄₂（竖直 Z-圈）；对偶方向同理给出 X̄₁、X̄₂。配对验收用碰撞定理：竖直的 X̄-圈与水平的 Z̄-圈在环面上恰好交叉一次——奇数，反对易 ✓；平行的两圈交叉 0 次——对易 ✓。于是 {X̄₁,Z̄₁} 与 {X̄₂,Z̄₂} 构成两对标准逻辑比特算符——与 5.3 的 k = 2 严丝合缝。

The torus hosts a second kind of closed loop: straight across a row, wrapping from the right edge back to the left. It encloses no region — a rubber band around the donut, impossible to shrink. The second demo above draws exactly this. It passes every check (each vertex on the loop owns exactly two loop edges, so it collides 0 or 2 times with every star), yet it cannot be written as a product of plaquettes and it really changes encoded states (the reasons for both are in Catch-up 5.B below) — by §4.4's definition, a logical operator. Two independent winding directions give Z̄₁ (horizontal Z-loop) and Z̄₂ (vertical); the dual directions give X̄₁, X̄₂. Certify the pairing by the collision theorem: a vertical X̄-loop crosses a horizontal Z̄-loop exactly once on a torus — odd, anticommute ✓; parallel loops cross 0 times — commute ✓. So {X̄₁,Z̄₁} and {X̄₂,Z̄₂} are two standard logical pairs — dovetailing with §5.3's k = 2.

四条圈画在同一个 4 × 4 环面上如下（比特编号规则同 5.2 的蓝图）。切换组合，看每一对共享几个比特：

Here are the four loops on one 4 × 4 torus (qubits numbered as in the blueprint of §5.2). Switch between the combinations and see how many qubits each pair shares:

运行时我们看不见链，只看得见端点（症状）。译码器decoder：读取全部症状、推断修复操作的经典算法。常用最小重量完美匹配（MWPM：在所有两两配对方式中挑修复链总长度最短的一种）或 Union-Find（让每个警报周围的簇逐步长大、相遇就合并的快速近似算法）。的策略：把报警点两两配对、沿路径施加 Z 补链。真实链 ⊕ 修复链（⊕：合并两组边、成对相消，因为 Z·Z = I）没有端点，是一条或几条闭合圈。剩下的问题只有一个：这些圈合起来是不是面检查的乘积（5.5 节：是，就什么都没发生；5.6 节：不是，就是逻辑算符）？判据是数缠绕数一条绕环面一周的测试路径跨过残留边的次数。竖直、水平各数一次；只有奇偶有意义。：沿 X̄₁ 那条竖直的路（穿过一列方块中心，绕环面一周）走一遍，数它跨过几条残留的 Z 边；再沿 X̄₂ 那条水平的路数一次。只看奇偶：

At runtime we see no chains, only endpoints (the syndrome). The decoderThe classical algorithm reading all syndromes and inferring repairs. Standard choices: minimum-weight perfect matching (MWPM: among all ways of pairing the alarms, pick the one with shortest total repair length) or Union-Find (a fast approximate method that grows a cluster around each alarm and merges clusters when they meet).'s strategy: pair up the alarms and apply Z along connecting paths. True chain ⊕ repair chain (⊕: merge edge sets with pairwise cancellation, since Z·Z = I) has no endpoints: it is one or more closed loops. Only one question remains: are these loops, taken together, a product of face checks (§5.5: if so, nothing happened; §5.6: if not, they form a logical operator)? The test is to count winding numbersHow many times a test path going once around the torus crosses the leftover edges. Count once vertically and once horizontally; only even or odd matters.: walk the vertical path of X̄₁ (through the centres of one column of squares, once around the torus) and count how many leftover Z edges it crosses; then count again along the horizontal path of X̄₂. Only even or odd matters:

为什么数奇偶，而不是看「有没有缠绕圈」？下面的实验台画了三种残留，都在 4 × 4 环面上，比特编号同 5.2 的蓝图。一条水平缠绕圈就是 Z̄₁：竖直测试路径跨过它 1 次，奇数，逻辑错误。两条平行的水平缠绕圈，每一条单独都是 Z̄₁，合起来却夹出一条带子（图中着色的 8 块面）。按 5.5 的公式把带子里的 8 条面检查乘起来：带子内部的每条边都挨着带子里的两块面（左右两端绕回相接，那里的竖边也一样），Z·Z 抵消；只剩带子的上下两条边框，正好是这两条圈。所以两条圈合起来是面检查的乘积，对编码态什么都不做；换个说法，Z̄₁ 做了两次，Z̄₁·Z̄₁ = I。竖直测试路径跨过它们 2 次，偶数。一条水平、一条竖直：两个方向各跨 1 次，残留是 Z̄₁Z̄₂，两个逻辑比特都被改写。

Why count even or odd, instead of asking “is there a winding loop”? The bench below draws three leftovers, all on a 4 × 4 torus with qubits numbered as in §5.2's blueprint. One horizontal winding loop is Z̄₁: the vertical test path crosses it once, odd, a logical error. Two parallel horizontal winding loops: each one alone is Z̄₁, but together they enclose a strip (the 8 shaded squares). Multiply the 8 face checks of the strip with §5.5's formula: every edge inside the strip borders two squares of the strip (the two ends wrap around and meet, and the vertical edges there behave the same way), so Z·Z cancels; only the strip's top and bottom rims remain, and they are exactly the two loops. So the two loops together are a product of face checks and do nothing to encoded states; put differently, Z̄₁ was applied twice, and Z̄₁·Z̄₁ = I. The vertical test path crosses them twice, even. One horizontal and one vertical: each direction is crossed once, the leftover is Z̄₁Z̄₂, and both logical qubits are rewritten.

判据的两半各有来历。奇数 ⇒ 逻辑错误：补课 5.B ① 的走路论证说明，任何一批面检查的乘积 Z(∂R) 都被绕环面一周的路跨过偶数次，所以跨奇数次的残留不是面检查的乘积；它与这条路上的 X̄ 共享奇数个比特，按碰撞定理反对易，于是补课 5.B ② 的论证原样适用：它改写了编码态。偶数 ⇒ 无害：两个方向都跨偶数次的闭合圈一定是面检查的乘积。这一半的一般证明要用拓扑学里的同调论，超出本页（5.6 节末尾的折叠盒给出它的名字）；两条平行圈是它最简单的例子。X 错误的残留同理，只是测试路径换成沿边走的 Z̄₁、Z̄₂。

Each half of the test has its own reason. Odd ⇒ logical error: the walking argument of Catch-up 5.B ① shows that any product of face checks Z(∂R) is crossed an even number of times by a path going once around the torus, so a leftover crossed an odd number of times is not a product of face checks; it shares an odd number of qubits with the X̄ on that path, so by the collision theorem they anticommute, and the argument of Catch-up 5.B ② applies word for word: it changes encoded states. Even ⇒ harmless: closed loops crossed an even number of times in both directions are always a product of face checks. The general proof of this half uses homology from topology and is beyond this page (the fold-out at the end of §5.6 gives its name); the two parallel loops are its simplest example. Leftovers of X errors work the same way, with the along-edge loops Z̄₁ and Z̄₂ as the test paths.

所以修复不必猜中原链：只要合成的圈两个方向的缠绕数都是偶数就全胜，最常见的情形是它们根本不绕，只是可收缩的小圈。这正是「错误只定义到同调类」的实战含义。下面实验台的「自动译码」在警报不超过 14 个时逐一比较所有配对方式、取总长度最短的一种（即 MWPM），更多时退为每次先配最近两个的贪心配对。每回合结束时，游戏按上面的判据判胜负，并在读数里写出竖直、水平两条测试路径各跨过残留（蓝 ⊕ 绿）几次。上场当一回译码器：

So the repair need not guess the original chain: it wins as long as the combined loops have even winding numbers in both directions, and most often they do not wind at all and are small contractible loops. That is the practical meaning of “errors defined only up to homology class”. The bench's “auto-decode” compares every pairing and takes the shortest (that is, MWPM) when there are at most 14 alarms, and falls back to greedy closest-pair matching beyond that. At the end of each round the game judges by the test above and writes in the readout how many times the vertical and the horizontal test path cross the leftover (blue ⊕ green). Take the decoder's chair:

最轻的逻辑算符是最短的缠绕圈：水平缠绕的圈每经过一列至少用一条横边，所以至少 L 条边，直线圈恰好 L 条。故码距 d = L，环面码是 [[2L², 2, L]]（L = 3 时 [[18, 2, 3]]），且对 X、Z 完全对称——任务书四项全部交付（两族检查 ✓ 对易定理 ✓ 对称可增长的 d ✓ 四近邻局部性 ✓）。按 4.5 的规则它保证纠正任意 (L − 1)/2 个错误；要压垮最短配对译码器，约 L/2 个错误恰好排在一条缠绕线上就够（修复会补齐另一半）。这个事件的概率随 L 怎样衰减？多小的 p 才「越大越好」？定量答案是量子计算最著名的曲线之一——阈值，我们留作《Surface Code · 高中数学版》第 6 章的压轴，在那里你会先用排列组合与等比数列亲手证出一个下界，再用蒙特卡洛模拟当场测出那一页简化译码器的阈值估计。

The lightest logical operator is the shortest winding loop: a horizontally winding loop uses at least one horizontal edge per column, so at least L edges, and the straight loop has exactly L. Hence d = L, the toric code is [[2L², 2, L]] ([[18, 2, 3]] for L = 3), fully symmetric in X and Z — all four items of the brief delivered (two families ✓ commutation theorem ✓ symmetric growable d ✓ four-neighbour locality ✓). By §4.5's rule it is guaranteed to correct any (L − 1)/2 errors; to defeat a shortest-pairing decoder, about L/2 errors lined up on one winding line suffice (the repair completes the other half). How fast does that probability shrink with L? Below what p does bigger become better? The quantitative answer is one of quantum computing's most famous curves — the threshold — saved as the finale of “The Surface Code · High-School Edition”, Chapter 6, where you will first prove a lower bound by counting and geometric series, then estimate by live Monte-Carlo simulation the threshold of that page's simplified decoder.

复盘整条推理链：矩阵与那个不肯交换的 −1（第 1 章）→ 冗余与只查奇偶的症状（第 2 章）→ 三条公设、泡利矩阵、本征值语言（第 3 章）→ 张量积、投影测量 P±=(I±S)/2、稳定子清单与对半定理、三比特码的判决书（第 4 章）→ 环面网格上的对易定理、∏=I 与 k=2、症状=∂链、同调类与逻辑圈、配对译码、d=L（第 5 章）。你没有「了解」toric code——你构造并检验了它的每一个零件。

The full chain, replayed: matrices and the −1 that refuses to commute (Ch. 1) → redundancy and parity-only syndromes (Ch. 2) → three postulates, Pauli matrices, eigenvalue language (Ch. 3) → tensor products, projective measurement P±=(I±S)/2, stabilizer checklists with the halving theorem, the 3-qubit code's verdict (Ch. 4) → the commutation theorem on the torus grid, ∏=I and k=2, syndrome = ∂chain, homology classes and logical loops, matching decoders, d = L (Ch. 5). You did not “learn about” the toric code — you constructed and certified each of its parts.

只欠一个现实问题：芯片是平的。《Surface Code · 高中数学版》把环面剪开：两种边界的分工、贴边溜走的错误链、完整的纠错循环与译码游戏，以及压轴的阈值——先用排列组合与等比数列证下界，再用蒙特卡洛当场实测。

One practical matter remains: chips are flat. “The Surface Code · High-School Edition” cuts the torus open: the two boundaries' division of labour, error chains slipping off the edge, the full correction cycle and decoding game, and the threshold finale — first a lower bound proved with counting and geometric series, then the true value measured live by Monte-Carlo.