拓扑替我们算出门 Topology computes the gates

记号：n = 物理量子比特数，k = 逻辑量子比特数，d = 码距，L = 环面每行每列的格数，c = 两条泡利串中两个都不是 I 且不同的字母同格相遇的位置数（只有 X、Z 时就是 X 遇 Z）。X̄、Z̄（上面加横线）= 逻辑 X、逻辑 Z；下标 1、2 区分两个逻辑比特。

Notation: n = number of physical qubits, k = number of logical qubits, d = distance, L = cells per row and per column of the torus, c = number of cells where the two Pauli strings carry two different non-identity letters (for a pure-X and a pure-Z string: where an X meets a Z). X̄, Z̄ (with a bar) = logical X, logical Z; subscripts 1, 2 distinguish the two logical qubits.

取 L = 3 的环面码，[[18, 2, 3]]（QEC-Bank 标签 toric_L3）。第 0 章事实 4 给了两条逻辑算符。Z̄₁：沿第二行的 3 条横边各放一个 Z（蓝色）。X̄：沿第二列的 3 条横边各放一个 X——这 3 条横边被一条竖直的对偶路径dual path：不沿着边走、而是穿过边、从一块面走到相邻面的路径。X 型逻辑算符住在这种路径穿过的边上；它与每个星检查的字母都是 X，所以自然对易，不需要穿过偶数次。（橙色虚线）依次穿过，这条路径绕环面竖直一圈。两条算符各自与所有检查对易（Toric Code 教程 5.6 节已验）。现在只问一件事：它们共用几条边？

Take the toric code with L = 3, [[18, 2, 3]] (QEC-Bank label toric_L3). Fact 4 of Chapter 0 gave two logical operators. Z̄₁: a Z on each of the 3 horizontal edges of the second row (blue). X̄: an X on each of the 3 horizontal edges of the second column; these 3 edges are crossed in turn by a vertical dual pathA path that does not run along edges but crosses them, stepping from one plaquette to a neighbouring one. X-type logical operators live on the edges such a path crosses; it shares only X letters with every star check, hence commutes without any even-crossing condition. (amber, dashed) that winds once vertically around the torus. Each operator commutes with every check (verified in section 5.6 of the toric-code guide). Now ask one thing only: how many edges do they share?

答案是 1：第二行、第二列那条横边。在那一格里 Z 遇上 X，c = 1，奇数——按碰撞定理，Z̄₁ 与 X̄ 反对易。这就是第 0 章事实 5 的「恰好交叉一次」，只不过我们把「交叉」落实成了「共用一条边」。人话：两条圈相遇的次数，决定两个逻辑算符是对易还是反对易。下面的沙盘就是这个码。先自己做一遍：切到 Z，点亮第二行的 3 条横边；切到 X，点亮第二列的 3 条横边；数一数两种颜色重叠的边。

The answer is 1: the horizontal edge in the second row and second column. In that cell a Z meets an X, c = 1, odd; by the collision theorem Z̄₁ and X̄ anticommute. This is the “cross exactly once” of fact 5 in Chapter 0, with “crossing” made concrete as “sharing one edge”. In plain words: the number of times two loops meet decides whether two logical operators commute or anticommute. The sandbox below is this code. Do it yourself first: switch to Z and light the 3 horizontal edges of the second row; switch to X and light the 3 horizontal edges of the second column; count the edges carrying both colours.

现在把 Z̄₁ 变形。「变形」在稳定子码里只有一种合法方式：乘上一条检查。乘上一块面检查（4 条边各放 Z），已经有 Z 的边上 Z·Z = I 消掉，没有 Z 的边上多出一个 Z——圈的形状变了，但它仍与所有检查对易，仍不是面检查的乘积，仍是同一个逻辑算符 Z̄₁（Toric Code 教程 5.6 节说的「相差一个可收缩部分即视为相同」）。下图把 Z̄₁ 乘上标 ★ 的两块面检查。重数一次它和 X̄ 共用的边：

Now deform Z̄₁. In a stabilizer code “deforming” has only one legal form: multiply by a check. Multiplying by a plaquette (a Z on each of its 4 edges) cancels Z·Z = I on edges that already carried a Z and adds a Z on those that did not; the loop changes shape, yet still commutes with every check, is still not a product of plaquettes, and is still the same logical operator Z̄₁ (“loops differing by a contractible part count as the same”, section 5.6 of the toric-code guide). The figure below multiplies Z̄₁ by the two plaquettes marked ★. Count its shared edges with X̄ again:

3 条。数变了，奇偶没变。这不是巧合，而是可以在三行里证明的事实：X̄ 与每块面检查对易（事实 2、4），也就是说 X̄ 与任何一块面共用偶数条边（0 或 2 条）；乘上一块面，共用边的条数就改变一个偶数；奇数加偶数还是奇数。对 X̄ 变形（乘星检查）同理。于是：

3. The number changed; its parity did not. That is no coincidence but a fact provable in three lines: X̄ commutes with every plaquette (facts 2 and 4), which is to say X̄ shares an even number of edges with any plaquette (0 or 2); multiplying by a plaquette therefore changes the number of shared edges by an even amount; odd plus even is odd. Deforming X̄ (multiplying by stars) works the same way. Hence:

记号：c(A, B) = 泡利串 A 与 B 中两个不同的非 I 字母相遇的格数（纯 X 串对纯 Z 串时就是 X 遇 Z；第 0 章事实 1），在这里就是两条圈共用的边数；「mod 2」读「模 2」，只看除以 2 的余数，即奇偶。

Notation: c(A, B) = the number of cells where A and B carry two different non-identity letters (an X meeting a Z, for a pure-X and a pure-Z string) (fact 1 of Chapter 0), here the number of edges the two loops share; “mod 2” means keep only the remainder on division by 2, the parity.

数学家给「怎么连续变形都不变的数」起的名字是拓扑不变量topological invariant：一个只依赖形状的「类」、不依赖具体画法的量。这里的「变形」= 乘检查，「类」= 同调类，「量」= 交叉数的奇偶。。这里的不变量是一个奇偶（0 或 1），叫两条圈的交叉数intersection number（mod 2）：两条圈相遇次数的奇偶。foundations/pauli-symplectic 把碰撞定理的这一版叫「crossing-count picture」。。QEC-Bank 的基础页 foundations/pauli-symplectic/intuition.md 把碰撞定理的这个画法直接叫 “Crossing-count picture”：“Every crossing means one local anticommutation. The symplectic inner product is simply the parity of those crossings.” 人话：对易还是反对易，是一个拓扑问题；画法怎么变都不影响答案。

The mathematician's name for “a number that survives every continuous deformation” is a topological invariantA quantity that depends only on the shape “class”, not on the particular drawing. Here “deformation” = multiplying by checks, “class” = homology class, “quantity” = the parity of the crossing count.. The invariant here is a parity (0 or 1), the intersection numberThe parity of how many times two loops meet (mod 2). foundations/pauli-symplectic calls this version of the collision theorem the “crossing-count picture”. of the two loops. The QEC-Bank foundations page foundations/pauli-symplectic/intuition.md calls this drawing of the collision theorem the “Crossing-count picture” outright: “Every crossing means one local anticommutation. The symplectic inner product is simply the parity of those crossings.” In plain words: commuting or anticommuting is a topological question; however the drawing changes, the answer does not.

既然只有奇偶要紧，就给每条闭合圈贴一个两位的标签 (h, v)：h = 它绕环面水平方向的圈数的奇偶，v = 绕竖直方向的圈数的奇偶。可收缩的圈是 (0,0)，Z̄₁（水平圈）是 (1,0)，Z̄₂（竖直圈）是 (0,1)，两者相乘是 (1,1)。乘检查不改变标签（1.2 节）。Toric Code 教程 5.6 节末尾说过：把「相差检查乘积即视为相同」的圈归类，恰好四类，学名同调类homology class：把「相差一个可收缩部分」的圈视为同一个类。环面上的一阶 ℤ₂ 同调恰有 4 个类，对应 4 个 Z 型逻辑算符 I、Z̄₁、Z̄₂、Z̄₁Z̄₂（相差检查乘积视为相同）。。同样给 X̄ 圈（对偶路径）贴标签 (h′, v′)。那么两条圈的交叉数只由标签决定：

Since only parity matters, give every closed loop a two-digit label (h, v): h = the parity of how many times it winds around the torus horizontally, v = the parity of how many times it winds vertically. A contractible loop is (0,0), Z̄₁ (horizontal) is (1,0), Z̄₂ (vertical) is (0,1), their product is (1,1). Multiplying by checks does not change the label (section 1.2). The end of section 5.6 of the toric-code guide said it: sorting loops by “differing by a product of checks counts as the same” gives exactly four classes, formally homology classesLoops differing by a contractible part are put in the same class. The first ℤ₂ homology of the torus has exactly 4 classes, matching the 4 Z-type logical operators I, Z̄₁, Z̄₂, Z̄₁Z̄₂ (up to products of checks).. Give X̄ loops (dual paths) labels (h′, v′) likewise. Then the crossing parity of two loops depends only on the labels:

记号：(h, v) = Z 圈的标签，(h′, v′) = X 对偶圈的标签，每个都是 0 或 1；「·」是普通乘法，「+ (mod 2)」是只看奇偶的加法（1 + 1 = 0）。

Notation: (h, v) = label of the Z loop, (h′, v′) = label of the X dual loop, each digit 0 or 1; “·” is ordinary multiplication, “+ (mod 2)” is addition keeping only parity (1 + 1 = 0).

为什么是这个式子：一条水平 Z 圈只会和竖直的 X 对偶路径相遇（h 配 v′），一条竖直 Z 圈只会和水平的 X 对偶路径相遇（v 配 h′），每次各贡献一个交叉；两项相加取奇偶。把 4 × 4 = 16 种组合填成表，就是环面码上「哪对逻辑算符反对易」的完整答案——它正是 Toric Code 教程 5.6 节那条 X̄_iZ̄_j = (−1)^δ_ij Z̄_jX̄_i 换了一件衣服：

Why this formula: a horizontal Z loop can only meet a vertical X dual path (h pairs with v′), a vertical Z loop only a horizontal one (v pairs with h′), each meeting contributing one crossing; add the two and keep the parity. Filling the 4 × 4 = 16 combinations into a table gives the complete answer to “which pairs of logical operators anticommute” on the toric code; it is the rule X̄_iZ̄_j = (−1)^δ_ij Z̄_jX̄_i of section 5.6 of the toric-code guide in different clothes:

表里的每个 1 都可以在 1.1 节的沙盘上手数验证（画出两条圈，数重叠的边）。注意第一行第一列全是 0：可收缩的圈（检查的乘积）与谁都对易——这就是「稳定子与逻辑算符对易」在拓扑语言里的样子。人话：逻辑算符之间的全部对易关系，可以从圈的标签算出来，而不必逐格检查泡利串。这已经是「拓扑替我们算」的第一个例子，只是算出的是对易关系，不是门。

Every 1 in the table can be checked by hand on the sandbox of section 1.1 (draw the two loops, count overlapping edges). Note the first row and first column are all 0: a contractible loop (a product of checks) commutes with everything, which is “stabilizers commute with logicals” in topological language. In plain words: all commutation relations among logical operators can be computed from loop labels, without checking Pauli strings cell by cell. This is already a first instance of “topology computing for us”, except that what it computes is commutation, not gates.

先分清两件事。1.3 节那张表是一种配对：左边拿一条 Z 圈的标签，上边拿一条 X 串的标签，配出一个数 0 或 1。数学里还有一种乘法，两个输入是同一类东西，输出还是这一类东西，叫上积cup product，记作 ⌣：把一个 p 次上同调类和一个 q 次上同调类乘成一个 p + q 次上同调类。公式见本节。，记作 α ⌣ β。要说清它，先说清它的输入：上同调类。

First, two things must be kept apart. The table of 1.3 is a pairing: take the label of a Z loop on the left and the label of an X string on top, and get a number, 0 or 1. Mathematics also has a multiplication whose two inputs are the same kind of object and whose output is again that kind, the cup productWritten ⌣: it multiplies a degree-p cohomology class and a degree-q cohomology class into a degree-(p + q) cohomology class. Formula in this section., written α ⌣ β. To say what it does, first say what its inputs are: cohomology classes.

「上同调」听起来远，其实 1.3 节已经用过它最简单的一例。在环面码上，「给每条边分配一个 0 或 1」就是「在标 1 的边上各放一个 X」；「边界规则」要求每块面的边上 1 的个数为偶数，这正是这串 X 与每块面检查（Z 型）对易；两种分配若只差「把某个顶点周围的边全翻一次」，就算同一个类，这正是相差一条星检查。所以环面码上一个 1 次上同调类，就是一个 X 型逻辑算符（相差星检查视为相同），1.3 节给 X 串贴的标签 (h′, v′) 就是它的标签；Z 圈的标签 (h, v) 则是同调类。这里的「1 次」（degree 1）指数值分配在边这种 1 维的格子上；分配在顶点上的叫 0 次，分配在面（三角形）上的叫 2 次。

“Cohomology” sounds remote, but section 1.3 already used its simplest instance. On the toric code, “assign a 0 or 1 to every edge” means “put an X on every edge marked 1”; the “boundary rule” demands an even number of 1s on the edges of every face, which is exactly that this X string commutes with every face check (Z-type); two assignments that differ only by “flipping every edge around one vertex” count as the same class, which is exactly differing by a star check. So on the toric code a degree-1 cohomology class is an X-type logical operator (up to star checks), and the labels (h′, v′) that 1.3 gave to X strings are its labels, while the labels (h, v) of Z loops are homology classes. “Degree 1” means the numbers sit on 1-dimensional cells, the edges; numbers on vertices make degree 0, numbers on faces (triangles) degree 2.

次数不等于你在图上看到的形状的维数。一个 1 次类画在环面上是一条对偶圈：从面走到面、依次穿过那些标 1 的边的线（1.1 节的橙色虚线）。「标 1 的边 ↔ 穿过它们的对偶形状」这个对应叫庞加莱对偶Poincaré duality：在 n 维的闭空间里，一个 p 次上同调类对应一个 n − p 维的对偶形状（穿过那些标 1 的格子）。环面 n = 2：1 次类 ↔ 对偶圈；三维 n = 3：1 次类 ↔ 对偶膜。：在 n 维的空间里，一个 p 次类对应一个 n − p 维的形状。环面 n = 2，所以 1 次类对应 1 维的圈；在三维空间里 n = 3，1 次类对应的是 2 维的膜，不是圈——1.5 节的三维构造要用到这一点。

The degree is not the dimension of the shape you see in the picture. On the torus a degree-1 class is drawn as a dual loop: the line that runs from face to face crossing, one after another, the edges marked 1 (the amber dashed line of 1.1). This correspondence, “edges marked 1 ↔ the dual shape crossing them”, is called Poincaré dualityIn a closed n-dimensional space a degree-p cohomology class corresponds to an (n − p)-dimensional dual shape crossing the cells marked 1. Torus, n = 2: degree-1 class ↔ dual loop; three dimensions, n = 3: degree-1 class ↔ dual membrane.: in an n-dimensional space a degree-p class corresponds to an (n − p)-dimensional shape. The torus has n = 2, so a degree-1 class corresponds to a 1-dimensional loop; in three-dimensional space, n = 3, a degree-1 class corresponds to a 2-dimensional membrane, not a loop, which the three-dimensional construction of 1.5 needs.

上积的规则：p 次类乘 q 次类得 p + q 次类（次数相加，不是「高一维」）。两个 1 次类相乘得 2 次类，也就是给每个三角形一个 0/1。公式（Zhu，arXiv:2501.19375 第 II.1 节式 (14)、(18)）要求每个三角形的三个顶点排好顺序 v₀ → v₁ → v₂，然后规定：

The rule: a degree-p class times a degree-q class gives a degree-(p + q) class (degrees add; it is not “one dimension higher”). Two degree-1 classes multiply into a degree-2 class, a 0/1 on every triangle. The formula (Zhu, arXiv:2501.19375, section II.1, eqs. (14) and (18)) needs the three corners of each triangle ordered v₀ → v₁ → v₂, and then says:

记号：α[v₀v₁] = α 在从 v₀ 到 v₁ 那条边上的值（0 或 1），β[v₁v₂] 同理；「·」是普通乘法；∫α ⌣ β 读「α 杯 β 的总值」，把所有三角形上的值加起来（Σ）只看奇偶。人话：α 看三角形的第一条边，β 看第二条边，两者都是 1 的三角形才算 1。

Notation: α[v₀v₁] = the value (0 or 1) of α on the edge from v₀ to v₁, β[v₁v₂] likewise; “·” is ordinary multiplication; ∫α ⌣ β, read “the total of alpha cup beta”, adds the values over all triangles (the Σ) and keeps the parity. In plain words: α looks at a triangle's first edge, β at its second; a triangle scores 1 only when both are 1.

手算一次（图 1.4）。把 3 × 3 环面的每个方格沿对角线切成两个三角形：9 个顶点、27 条边、18 个三角形；边的方向一律向右、向上、向右上，每个三角形的顶点就沿箭头排好了序。取 α = 1 在穿过列 0 与列 1 之间那条竖直对偶圈的 6 条边上（3 条横边、3 条对角边），β = 1 在穿过行 0 与行 1 之间那条水平对偶圈的 6 条边上（3 条竖边、3 条对角边）。每个三角形里 α 为 1 的边数是 0 或 2，β 也是，所以两者都满足边界规则。现在逐块算。阴影那块：v₀ = (列 0, 行 0)，v₁ = (1, 0)，v₂ = (1, 1)；第一条边 v₀v₁ 是横边，在 α 里，值 1；第二条边 v₁v₂ 是竖边，在 β 里，值 1；乘积 1。它正上方同形状的那块 (0, 1)、(1, 1)、(1, 2)：第一条边在 α 里（1），第二条边 (1, 1) → (1, 2) 不在 β 里（0），乘积 0。另一种三角形（v₀ 左下、v₁ 左上、v₂ 右上）的第一条边都是竖边，而 α 在竖边上全是 0，所以都得 0。18 块里只有阴影那一块得 1，∫α ⌣ β = 1。反过来 ∫β ⌣ α 也是 1（这回是 (0, 0)、(0, 1)、(1, 1) 那块得 1），∫α ⌣ α = 0。本篇脚本把 18 块逐一算过，又给 α、β 各自加上 2 000 组随机的「翻转某些顶点周围的所有边」（相差星检查）再算，总值始终不变：∫ 只看类，不看代表。

Compute one by hand (Fig. 1.4). Cut every square of the 3 × 3 torus along its diagonal into two triangles: 9 vertices, 27 edges, 18 triangles; orient every edge right, up or up-right, and the corners of each triangle are ordered along the arrows. Let α = 1 on the 6 edges crossed by the vertical dual loop between column 0 and column 1 (3 horizontal, 3 diagonal), and β = 1 on the 6 edges crossed by the horizontal dual loop between row 0 and row 1 (3 vertical, 3 diagonal). Every triangle has 0 or 2 edges with α = 1, and likewise for β, so both obey the boundary rule. Now triangle by triangle. The shaded one: v₀ = (col 0, row 0), v₁ = (1, 0), v₂ = (1, 1); the first edge v₀v₁ is horizontal and in α, value 1; the second edge v₁v₂ is vertical and in β, value 1; product 1. The same-shaped triangle just above it, (0, 1), (1, 1), (1, 2): the first edge is in α (1), the second edge (1, 1) → (1, 2) is not in β (0), product 0. In the other kind of triangle (v₀ bottom left, v₁ top left, v₂ top right) the first edge is vertical, and α is 0 on every vertical edge, so all of them score 0. Only the shaded triangle of the 18 scores 1: ∫α ⌣ β = 1. The other way round, ∫β ⌣ α is 1 as well (now the triangle (0, 0), (0, 1), (1, 1) scores), and ∫α ⌣ α = 0. This guide's script computed all 18 triangles, then added to α and β 2 000 random sets of “flip every edge around some vertices” (differing by star checks) and recomputed: the total never changed. ∫ sees the class, not the representative.

这个 1 与 1.3 节表里「Z̄₁ 对竖直 X 串」的那个 1 是同一个数，原因就是对偶：α 的对偶圈是竖直的，β 的是水平的，它们恰好交叉一次；论文式 (30) 写的正是「∫α ⌣ β = 两条对偶圈交叉次数的奇偶」。把 α、β 换成四个类（0、α、β、α + β）的所有组合，16 个总值排成的表与 1.3 节的表同形（本篇脚本核对）。所以在环面上，1.3 节的配对表可以读成上积表；但两件事仍要分开：配对吃一个同调类和一个上同调类，吐出一个数；上积吃两个上同调类，吐出一个更高次的类，数要到最后「求总值」那一步才出现。只有上积能接着再乘第三个类——1.5 节的非 Clifford 门正要用到这一步。

This 1 is the same number as the 1 of “Z̄₁ against the vertical X string” in the table of 1.3, and duality is the reason: the dual loop of α is vertical, that of β horizontal, and they cross exactly once; the paper's eq. (30) says precisely “∫α ⌣ β = parity of the number of crossings of the two dual loops”. Running α and β over all pairs of the four classes (0, α, β, α + β), the 16 totals form a table of the same shape as the table of 1.3 (checked by this guide's script). So on the torus the pairing table of 1.3 can be read as a cup-product table; yet the two things stay distinct: the pairing takes one homology class and one cohomology class and returns a number; the cup product takes two cohomology classes and returns a class of higher degree, and a number appears only in the final “take the total” step. Only the cup product can go on to multiply a third class, the step that the non-Clifford gates of 1.5 need.

最后一步是「门」。存住逻辑比特不等于计算；要计算就要对逻辑比特做门，而且最想要的是便宜的门——每个物理比特只参与少数几个小操作、深度为常数、不需要长时间的测量协议（表面码逻辑操作教程 1.1 节：需要哪些门）。上积怎样变成这样的门，Zhu 的论文（arXiv:2501.19375 第 II.1–II.2 节）给出了一个具体的构造。下面按它的条件陈述；门的层级（Clifford、第 3 级）见本节末的补课。

The last step is “gates”. Storing logical qubits is not computing; computing means applying gates to them, and the gates one wants most are the cheap ones: each physical qubit takes part in only a few small operations, constant depth, no long measurement protocol (surface-code operations guide 1.1: which gates are needed). How cup products become such gates is shown by a concrete construction in Zhu's paper (arXiv:2501.19375, sections II.1–II.2), stated below with its conditions; the levels of gates (Clifford, level 3) are explained in the catch-up at the end of this section.

二维：两份码，一张 CZ 电路。条件：一个 CSS 码放在一个二维的三角剖分triangulation：把曲面切成三角形，任意两个三角形要么不相碰、要么共用一条边或一个顶点。图 1.4 就是环面的一个三角剖分。上——比特在边上，X 检查在顶点上（星），Z 检查在三角形上——例如图 1.4 那块切成三角形的环面（环面码的三角形变体）。这个三角剖分还要是闭的：整张曲面没有边缘，每条边恰好挨着两个三角形（图 1.4 的环面是闭的；剪开成有边界的平面贴片就不是）。论文第 II.1 节的一般说法是：总值 ∫ 只在一组没有边缘的三角形 Σ 上求和，∂Σ = 0，意思是每条边被 Σ 里偶数个三角形挨着；闭曲面就取 Σ = 整张曲面。为什么要这一条：引理 1 的证明里，乘一颗星（X 检查）会让总值多出两项，一项因为另一份码满足 Z 检查而为 0，另一项按斯托克斯定理等于 Σ 边缘上的一个和；没有边缘，它才是 0，电路才不把态推出码空间。取这个码的两份拷贝 A、B。电路：对每个三角形 [v₀v₁v₂]，在 A 的边 v₀v₁ 上的比特和 B 的边 v₁v₂ 上的比特之间做一个 CZcontrolled-Z：两个比特都是 1 时把态乘 −1，否则不变。它是 Clifford 门。——正是公式里「α 看第一条边、β 看第二条边」的样子。常深度的理由：闭曲面上每条边只挨两个三角形，所以每个比特最多进 2 个 CZ，每个 CZ 最多和另外 2 个 CZ 共用比特；把 CZ 逐个放进第一个没有冲突的层，最多 3 层就排完，码再大也不变。（在一般的复形上，一条边可以挨任意多个三角形；那时要另外要求「每个比特进的门数有一个与码大小无关的上界」，常深度才成立。）论文的引理 1 证明：这个电路保持码空间，而且对逻辑比特做的是：在 A 的逻辑比特 α 与 B 的逻辑比特 β 之间做一个逻辑 CZ，当且仅当 ∫α ⌣ β = 1。在图 1.4 的环面上，∫α ⌣ β = ∫β ⌣ α = 1，∫α ⌣ α = ∫β ⌣ β = 0，所以电路做的是两个逻辑 CZ：(A 的 α)–(B 的 β) 与 (A 的 β)–(B 的 α)。相位的小例子：A 的两个逻辑比特读作 (α, β) = (1, 0)，B 读作 (0, 1)：指数 = 1·1·∫α ⌣ β = 1，这个态乘上 −1；A、B 都读作 (1, 0)：指数 = 1·1·∫α ⌣ α = 0，不变。16 种组合的指数表与 1.3 节的表同形（脚本核对）。CZ 是 Clifford 门，与二维的 Bravyi–König 天花板一致。

Two dimensions: two copies, one CZ circuit. Conditions: a CSS code on a two-dimensional triangulationCutting a surface into triangles such that two triangles either do not touch or share exactly one edge or one vertex. Fig. 1.4 is a triangulation of the torus., with qubits on edges, X checks on vertices (stars) and Z checks on triangles, for example the triangulated torus of Fig. 1.4 (a triangular variant of the toric code). The triangulation must also be closed: the surface has no edge, so every edge borders exactly two triangles (the torus of Fig. 1.4 is closed; a planar patch cut out of it is not). The general form in section II.1 of the paper: the total ∫ is summed over a set of triangles Σ without boundary, ∂Σ = 0, meaning that every edge borders an even number of triangles of Σ; on a closed surface Σ is the whole surface. Why this is needed: in the proof of Lemma 1, multiplying by a star (an X check) adds two terms to the total; one vanishes because the other copy passes its Z checks, and the other equals, by Stokes' theorem, a sum over the boundary of Σ. Only without a boundary is that term 0, so that the circuit does not push the state out of the code space. Take two copies A and B. The circuit: for every triangle [v₀v₁v₂], apply a CZcontrolled-Z: multiplies the state by −1 when both qubits are 1, otherwise does nothing. It is a Clifford gate. between the qubit on edge v₀v₁ of A and the qubit on edge v₁v₂ of B, the “α looks at the first edge, β at the second” of the formula. Why the depth is constant: on a closed surface each edge borders two triangles, so each qubit joins at most 2 CZs and each CZ shares a qubit with at most 2 others; placing the CZs one by one into the first layer without a conflict uses at most 3 layers, however large the code. (On a general complex an edge can border any number of triangles; constant depth then needs the extra condition that the number of gates per qubit has a bound independent of the code size.) Lemma 1 of the paper proves that this circuit preserves the code space and acts on the logical qubits as follows: a logical CZ between logical qubit α of A and logical qubit β of B exactly when ∫α ⌣ β = 1. On the torus of Fig. 1.4, ∫α ⌣ β = ∫β ⌣ α = 1 and ∫α ⌣ α = ∫β ⌣ β = 0, so the circuit performs two logical CZs: (α of A)–(β of B) and (β of A)–(α of B). A small phase example: A's two logical qubits read (α, β) = (1, 0) and B's read (0, 1): exponent = 1·1·∫α ⌣ β = 1, so this state is multiplied by −1; A and B both read (1, 0): exponent = 1·1·∫α ⌣ α = 0, unchanged. The table of exponents over all 16 combinations has the same shape as the table of 1.3 (checked by script). CZ is a Clifford gate, as the two-dimensional Bravyi–König ceiling requires.

三维：三份码，一张 CCZ 电路。条件：CSS 码放在三维的三角剖分上（比特在边上，X 检查在顶点上，Z 检查在三角形上），三份拷贝 A、B、C。三角剖分同样要是闭的（没有边缘，比如下面的三维环面），或者只在一组没有边缘的四面体 Σ 上求和（∂Σ = 0），理由与二维相同。电路：对每个四面体 [v₀v₁v₂v₃]（用 Σ 的那种做法时，只对属于 Σ 的四面体；否则不能保证码空间不变），在 A 的边 v₀v₁、B 的边 v₁v₂、C 的边 v₂v₃ 上的三个比特做一个 CCZcontrolled-controlled-Z：三个比特都是 1 时把态乘 −1，否则不变。它在 Clifford 层级的第 3 级，不是 Clifford 门。。三维里一条边可以挨很多个四面体，所以常深度要一个额外的条件：每个比特进的 CCZ 个数有一个与码大小无关的上界 s。有了它，每个 CCZ 最多和 3(s − 1) 个别的 CCZ 共用比特，逐个放层最多要 3s − 2 层。下面 3 × 3 × 3 的例子里 s = 2，脚本实际排成 2 层。引理 2 证明：它保持码空间，并在 A 的 α、B 的 β、C 的 γ 之间实现逻辑 CCZ，当且仅当 ∫α ⌣ β ⌣ γ = 1。三维里 1 次类的对偶形状是膜（1.4 节），所以 ∫α ⌣ β ⌣ γ 数的是三张对偶膜共同交点个数的奇偶（论文式 (42)），不是「三条圈相遇」。例子：三维环面（一个立方体，三对相对的面各自粘起来）有三个 1 次类 x、y、z，对偶膜分别是垂直于三个坐标轴的平面；三张互相垂直的平面恰好交于一点，所以 ∫x ⌣ y ⌣ z = 1；只要有两个方向相同（比如 x、x、y），两张平行的膜不相交，总值为 0。本篇脚本在 3 × 3 × 3 的三维环面（27 个顶点、162 个四面体）上逐一核对了全部 27 种组合，并对 300 组随机的星检查变形复算，结果不变。相位：每份码有 3 个逻辑比特，记成 (x 位, y 位, z 位)。脚本算出 ∫ = 1 的组合 (A 的类, B 的类, C 的类) 正好是 x、y、z 的 6 种排列，所以这张电路是 6 个逻辑 CCZ 的乘积，相位指数 = 这 6 项「A 的位 · B 的位 · C 的位」之和 mod 2。例：A = (1, 0, 0)、B = (0, 1, 0)、C = (0, 0, 1)，只有 (x, y, z) 一项是 1，态乘上 −1。反例：A = B = (1, 1, 0)、C = (0, 0, 1)，(x, y, z) 与 (y, x, z) 两项都是 1，和为 2，态不变——虽然 A 的 x 位、B 的 y 位、C 的 z 位都是 1。所以只看三个指定的位不够，别的位要一起算。脚本对全部 512 种逻辑赋值（每份码取随机的代表）核对了这条公式。CCZ 在第 3 级，是非 Clifford 门——正是三维里 Bravyi–König 允许到的层级。

Three dimensions: three copies, one CCZ circuit. Conditions: a CSS code on a three-dimensional triangulation (qubits on edges, X checks on vertices, Z checks on triangles), three copies A, B, C. The triangulation must again be closed (no boundary, like the three-torus below), or the sum must run over a set of tetrahedra Σ without boundary (∂Σ = 0), for the same reason as in two dimensions. The circuit: for every tetrahedron [v₀v₁v₂v₃] (in the Σ variant, only for the tetrahedra belonging to Σ; otherwise the code space is not guaranteed to be preserved), apply a CCZcontrolled-controlled-Z: multiplies the state by −1 when all three qubits are 1, otherwise does nothing. It sits at level 3 of the Clifford hierarchy and is not a Clifford gate. to the qubits on edge v₀v₁ of A, edge v₁v₂ of B and edge v₂v₃ of C. In three dimensions an edge can border many tetrahedra, so constant depth needs an extra condition: the number of CCZs per qubit has a bound s independent of the code size. Then each CCZ shares a qubit with at most 3(s − 1) others, and placing them one by one needs at most 3s − 2 layers. In the 3 × 3 × 3 example below s = 2, and the script packs the circuit into 2 layers. Lemma 2 proves that it preserves the code space and performs a logical CCZ on α of A, β of B and γ of C exactly when ∫α ⌣ β ⌣ γ = 1. In three dimensions the dual shape of a degree-1 class is a membrane (1.4), so ∫α ⌣ β ⌣ γ counts, mod 2, the points common to three dual membranes (the paper's eq. (42)), not “three loops meeting”. Example: the three-dimensional torus (a cube with each pair of opposite faces glued) has three degree-1 classes x, y, z whose dual membranes are planes perpendicular to the three axes; three mutually perpendicular planes meet in exactly one point, so ∫x ⌣ y ⌣ z = 1; whenever two directions repeat (x, x, y, say), two parallel membranes never meet and the total is 0. This guide's script checked all 27 combinations on the 3 × 3 × 3 three-torus (27 vertices, 162 tetrahedra) and recomputed after 300 random star-check deformations, with the same results. Phase: each copy has 3 logical qubits, written (x bit, y bit, z bit). The script finds that the combinations (class of A, class of B, class of C) with ∫ = 1 are exactly the 6 orderings of x, y, z, so the circuit is a product of 6 logical CCZs and the phase exponent is the sum of the 6 terms “bit of A · bit of B · bit of C”, mod 2. Example: A = (1, 0, 0), B = (0, 1, 0), C = (0, 0, 1); only the (x, y, z) term is 1, so the state is multiplied by −1. Counterexample: A = B = (1, 1, 0), C = (0, 0, 1); both the (x, y, z) and the (y, x, z) terms are 1, the sum is 2, and the state is unchanged, even though A's x bit, B's y bit and C's z bit are all 1. So the three named bits alone do not decide the phase; the other bits count too. The script checked this formula on all 512 logical assignments (each copy in a random representative). CCZ is at level 3, a non-Clifford gate, which is exactly the level Bravyi–König allows in three dimensions.

这个构造说明了什么，没说明什么。它证明：满足这些条件的码带着这些具体的常深度电路作为逻辑门，门由上积的总值决定。它不说一个码只有这些门，也不能判定任意一个常深度操作做的是什么门；单看两两或三三重叠也不能给门分类。这就是标题那句话的范围：如果机器能在码的结构上算出上积，它就能为这样构造出来的门出具证书——而不是判定这个码所有的门，也不能取代 Bravyi–König 那样的禁止定理。QEC-Bank 设计文档 3.2 节把这一点写进了数据模型：“cohomology operations (cup products) — these are operations-facet inputs, since they certify native non-Clifford logicals on product codes (Zhu, arXiv:2501.19375).” 本篇读了这篇论文的第 II.1–II.2 节（上面两个构造的出处）；第 VI.1–VI.2 节只读了检查与比特放在哪一维的格子上（4.4 节用到），没有读它怎样把一般的乘积码变成这样的复形的构造与证明（第 III–V 节及第 VI 节其余部分）。

What the construction shows, and what it does not. It proves that codes meeting these conditions carry these particular constant-depth circuits as logical gates, the gates being fixed by the totals of cup products. It does not say that a code has only these gates, it cannot decide which gate an arbitrary constant-depth operation performs, and pairwise or triple overlaps on their own do not classify gates. That is the scope of the title: if a machine can compute cup products on a code's structure, it can certify the gates built this way, not classify every gate a code might have, and not replace obstructions such as Bravyi–König. The QEC-Bank design document, section 3.2, wrote this into the data model: “cohomology operations (cup products) — these are operations-facet inputs, since they certify native non-Clifford logicals on product codes (Zhu, arXiv:2501.19375).” This guide read sections II.1–II.2 of that paper (the source of the two constructions above); of sections VI.1–VI.2 it read only which cell dimensions hold the checks and the qubits (used in 4.4), not the constructions and proofs that turn general product codes into such complexes (sections III–V and the rest of VI).

逐词翻译。Compute：要机器算出来，不是从论文抄。cup products / cohomology operations：1.4 节那种「两个上同调类乘成第三个」的运算及其推广。chain complexes：链复形chain complex：QEC-Bank 存放 CSS 码的标准形式——几张 0/1 矩阵（谁是谁的边界）串成一列，相邻两张相乘为零。基础页一句话：“Two classical codes with H_X H_Z^T = 0 are one chain complex; homology counts logicals.”，QEC-Bank 存 CSS 码的标准形式：环面码的「顶点—边—面」三层，就是一个链复形（qLDPC 教程 1.2 节的两张稀疏矩阵加对易条件）。product codes：乘积码product code：把两个小的经典码或链复形「相乘」得到的量子码。表面码与环面码 = 重复码 × 重复码（超图积）；BB 码是提升积。——用两个小零件「相乘」造出来的码：表面码和环面码是重复码 × 重复码（qLDPC 教程 3.1 节），BB 码是把 0/1 换成多项式的提升积（BB 教程 2.3 节）。这道题的 related 恰好是这两个条目：surface 与 bivariate_bicycle。certify：给出机器能核对的证明，不只是断言。native non-Clifford logicals：码自带的非 Clifford 逻辑门（第 3 级的门，如 T、CCZ），不靠外部注入的「魔法态」（表面码操作教程 1.3 节）。(arXiv:2501.19375)：题目指向的论文（1.5 节的两个构造出自它的第 II 节），QEC-Bank 的参考文献登记表里尚无它的条目——据条目记载，登记待补。人话：让机器在 QEC-Bank 已有的乘积码结构上算出上积，从而证明「这个码天生带一个非 Clifford 门」（比如 1.5 节那种 CCZ）。

Word by word. Compute: the machine must work it out, not copy it from a paper. cup products / cohomology operations: the “two cohomology classes multiplied into a third” operation of 1.4 and its generalizations. chain complexes: the chain complexThe QEC-Bank's standard form for CSS codes: several 0/1 matrices (who is whose boundary) in a row, with adjacent ones multiplying to zero. The foundations one-liner: “Two classical codes with H_X H_Z^T = 0 are one chain complex; homology counts logicals.”, the QEC-Bank's standard form for CSS codes: the toric code's three layers vertices, edges, faces form one (the two sparse matrices plus commutation condition of qLDPC guide 1.2). product codes: product codesQuantum codes obtained by “multiplying” two small classical codes or chain complexes. Surface and toric codes = repetition × repetition (hypergraph product); BB codes are lifted products., codes built by “multiplying” two small parts: surface and toric codes are repetition × repetition (qLDPC guide 3.1), BB codes are lifted products with 0/1 replaced by polynomials (BB guide 2.3). This item's related list is exactly those two entries: surface and bivariate_bicycle. certify: produce a machine-checkable proof, not just an assertion. native non-Clifford logicals: non-Clifford logical gates (level-3 gates such as T or CCZ) the code has on its own, without externally injected “magic states” (surface operations guide 1.3). (arXiv:2501.19375): the paper the item points to (the two constructions of 1.5 come from its section II); the QEC-Bank reference registry has no entry for it yet: cited by the entry, registration pending. In plain words: have a machine compute cup products on the product-code structures the QEC-Bank already holds, and thereby prove “this code natively carries a non-Clifford gate” (a CCZ like that of 1.5, say).

四个词。Curated：人工整理——由人读论文、挑出条目、写进卡片；QEC-Bank 的证据词表里，与它相对的是 derived（机器从数据算出）和 verified（机器算出并有证书核对）。operations entries：每个条目 card.yaml 里的 operations 字段，一条记录 = 一个门。with refs：每条附一个文献键。人话：今天「这个码有哪些门」这一栏，除了少数小码上 Pauli / Clifford 层面的 verified 记录（环面码的两块 CNOT、[[4,2,2]] 的 CZ），其余全是人抄的；非 Clifford 门一条也不是机器算的。

Four words. Curated: assembled by hand, a person read the papers, picked the items and wrote them into the card; in the QEC-Bank vocabulary its opposites are derived (computed by the machine from data) and verified (computed and checked against a certificate). operations entries: the operations field of each entry's card.yaml, one record = one gate. with refs: each carries a bibliography key. In plain words: today, apart from a few Pauli- or Clifford-level verified records on small entries (the toric two-block CNOT, the [[4,2,2]] CZ), the column “which gates does this code have” is copied by people, and no non-Clifford gate has been computed by the machine.

下表逐字转录 codes/surface/card.yaml 的 operations 字段（九条断言 atlas-assertion:surface:operations:0…8），也就是 QEC-Bank 表面码条目「逻辑操作」页面上显示的内容。每条有 gate（门）、mechanism（机制）、level（层级）、cost（成本）与 origin（证据词 + 文献键）。

The table transcribes the operations field of codes/surface/card.yaml verbatim (the nine assertions atlas-assertion:surface:operations:0…8), which is what the QEC-Bank surface entry's “Logical operations” page displays. Each has gate, mechanism, level, cost and origin (evidence word + bibliography key).

mechanism 一栏的词（第 2.2 节的表也用到）。transversal（横向）：每个物理比特上各做一个门，两块码之间则在位置对应的比特对上各做一个门；同一块码里的比特互不作用，所以一个故障最多坏掉每块里的一个比特。surgery（格点手术）：暂时在两块码的边界之间加上新的检查，把它们「缝」成一块，重复测量若干轮再拆开；缝合时读出的检查值合起来，就是两块逻辑算符乘积（例如 Z̄⊗Z̄）的测量结果，CNOT 由几次这样的测量拼成。braiding（编织）：在码里「挖洞」（关掉一片检查），随时间把一个洞沿闭合路径绕另一个洞一圈，绕法决定做了哪个门（例如 CNOT）。fold-transversal（折叠横向）：利用码的一种把 X 检查换成 Z 检查的对称（例如表面码沿对角线的镜像），像把码沿对称轴对折一样：落在折痕上的比特各做一个单比特门，被折到一起的比特对各做一个双比特门。measurement-based（基于测量）：门由测量、以及按测量结果做的泡利修正完成。automorphisms（自同构）：把比特重新编号、使检查的集合整体不变的一种置换；它把码空间映到自己，因而给出逻辑门。

The words of the mechanism column (the table of 2.2 uses them too). transversal: one gate on each physical qubit, or, between two blocks, one gate on each pair of qubits in corresponding positions; qubits of the same block never interact, so one fault damages at most one qubit per block. surgery (lattice surgery): temporarily add new checks across the boundary between two blocks, “stitching” them into one, measure for several rounds, then cut them apart; the check values read while stitched combine into the measurement of a product of the two blocks' logical operators (Z̄⊗Z̄, say), and a CNOT is assembled from a few such measurements. braiding: cut “holes” in the code (switch off a patch of checks) and, over time, move one hole along a closed path around another; the path decides the gate (a CNOT, for example). fold-transversal: use a symmetry of the code that exchanges X checks with Z checks (the diagonal mirror of the surface code, for example), as if folding the code along that axis: qubits on the crease get one single-qubit gate each, and pairs folded onto each other get one two-qubit gate each. measurement-based: the gate is done by measurements plus Pauli corrections chosen from their outcomes. automorphisms: a relabelling of the qubits that maps the set of checks onto itself; it maps the code space to itself and so yields logical gates.

九条的 origin 全是 claimed。唯一一条 non-Clifford 是第 8 条 T 门，它的 cost 字段原文是：“inject and distill a magic state, then consume it by gate teleportation; factory spacetime dominates.” 也就是说，这个 T 不是表面码自带的：先在码外制备一个带噪的魔法态magic state：一个特殊的单比特量子态，配合 Clifford 操作与测量可以「传送」出一个 T 门。要用许多份带噪的蒸馏成一份高质量的，代价极大。，再蒸馏，再用门传送消耗掉，「工厂的时空体积占主导」。这不是 Wanted 板要的 native（自带的）非 Clifford 门。而且对二维表面码来说，自带的 T 门根本不可能：表面码操作教程 1.3 节讲过 Bravyi–König 定理——二维拓扑稳定子码上，局域、常深度的操作最多做到 Clifford 层级。QEC-Bank 的基础页 foundations/bounds/bravyi-koenig.md 把它压成一句口号：“A constant-depth local circuit gets one hierarchy level per spatial dimension.” 人话：表面码的 T 是买来的，不是天生的；而且二维平面上天生不了。

All nine origins are claimed. The only non-Clifford one is record 8, the T gate, whose cost field reads: “inject and distill a magic state, then consume it by gate teleportation; factory spacetime dominates.” That is, this T is not native to the surface code: a noisy magic stateA special single-qubit quantum state which, together with Clifford operations and measurements, can “teleport” a T gate into place. Many noisy copies must be distilled into one good one, at great cost. is prepared outside the code, distilled, then consumed by gate teleportation, with “factory spacetime dominating”. That is not the native non-Clifford gate the Wanted board asks for. And for the two-dimensional surface code a native T is impossible outright: section 1.3 of the surface operations guide covered the Bravyi–König theorem, that on a 2D topological stabilizer code, local constant-depth operations reach at most the Clifford level. The QEC-Bank foundations page foundations/bounds/bravyi-koenig.md compresses it into a slogan: “A constant-depth local circuit gets one hierarchy level per spatial dimension.” In plain words: the surface code's T is bought, not born; and in a 2D plane it cannot be born.

BB 条目的 operations 字段有五条（atlas-assertion:bivariate_bicycle:operations:0…4）。BB 逻辑操作教程 1.3 节已经逐字转录并逐条讲解，这里只列门、机制、层级与证据词：

The BB entry's operations field has five records (atlas-assertion:bivariate_bicycle:operations:0…4). Section 1.3 of the BB operations guide already transcribes and explains them one by one; here only gate, mechanism, level and evidence word:

五条 level 全是 Clifford，origin 全是 claimed，而且 applies_to 全是 eczoo-entity:qcga#collection——说的是 BB 这一族，不是 gross 一块。BB 条目没有任何一条非 Clifford 记录：既没有自带的，也没有买来的。BB 操作教程 5.2 节给出的负面结论是「gross 没有普适的横向门集」，5.3 节说 T 仍要靠码外的魔法态。注意区别：BB 码不是二维局域的（BB 教程 1.2 节），Bravyi–König 定理不直接禁止它有自带的非 Clifford 门——所以「BB 卡片上没有」是没有记录，不是证明了没有。这正是这道 Wanted 题会改变的地方。

All five levels are Clifford, all origins claimed, and applies_to is eczoo-entity:qcga#collection throughout, the BB family rather than the single gross block. The BB entry has no non-Clifford record at all, native or bought. Section 5.2 of the BB operations guide states the negative conclusion “no universal transversal gate set for gross”, and 5.3 that T still relies on magic states from outside the code. Mind the distinction: BB codes are not 2D-local (BB guide 1.2), so the Bravyi–König theorem does not directly forbid a native non-Clifford gate for them; hence “none on the BB card” means no record, not proven absent. That is exactly what this Wanted item would change.

Wanted 板上还有一道题瞄准同一个目标，状态是 partial（部分完成），本系列不为它单开一篇。transversal-gate-cert「Transversal-gate certification library」的 statement 原文：“Given a code, enumerate/certify its transversal logical gates. Routes: triorthogonality checks (done, exact), automorphism-based logical Cliffords (Tanner-graph autos via nauty), brute force for small n.” 它的 why_it_matters：“Turns the operations facet from claimed(ref) into verified for the gates that matter; feeds fair comparison of computation, not just memory.” 两道题的区别：transversal-gate-cert 走代数路线——直接在检查矩阵上检验一种叫三正交性的条件（已完成、精确）、或枚举 Tanner 图的对称（待做）、或对小 n 穷举；cup-products 走拓扑路线——从链复形的形状算出门。目标一样：把 operations 的 claimed 变成 verified。

One more item on the Wanted board aims at the same target, with status partial; this series gives it no page of its own. The statement of transversal-gate-cert, “Transversal-gate certification library”, verbatim: “Given a code, enumerate/certify its transversal logical gates. Routes: triorthogonality checks (done, exact), automorphism-based logical Cliffords (Tanner-graph autos via nauty), brute force for small n.” Its why_it_matters: “Turns the operations facet from claimed(ref) into verified for the gates that matter; feeds fair comparison of computation, not just memory.” The difference: transversal-gate-cert takes the algebraic road, testing a condition called triorthogonality directly on the check matrices (done, exact), or enumerating Tanner-graph symmetries (to do), or brute force for small n; cup-products takes the topological road, computing gates from the shape of the chain complex. Same goal: turn claimed into verified in the operations facet.

这里有三个生词。三正交性（triorthogonality，Bravyi 与 Haah，arXiv:1209.2426）：一个 0/1 矩阵，若任意两行的重叠（两行同时为 1 的位置个数）都是偶数，任意三行的重叠也都是偶数，就叫三正交的；他们证明，由三正交矩阵构造的稳定子码对全部逻辑比特有横向 T 门（可能再配上 Clifford 门）。手算一例：三行 11110000、11001100、10101010。两两重叠：第 1、2 行同时为 1 的是第 1、2 位，2 个；第 1、3 行是第 1、3 位，2 个；第 2、3 行是第 1、5 位，2 个——都是偶数。三行同时为 1 的只有第 1 位，1 个，奇数，所以这个矩阵不是三正交的。加长到 16 位就可以：四行 0000000011111111、0000111100001111、0011001100110011、0101010101010101（0 到 15 这 16 个数写成 4 位二进制，每行取其中一位），两两重叠都是 4，三三重叠都是 2（本篇脚本核对）。这项检查只数重叠，所以是精确的。Tanner 图：每个比特画一个点、每条检查画一个方块，检查碰到哪个比特就连一条线；它的自同构是保持所有连线不变的重新编号，也就是上面说的码的自同构。nauty：一个常用的程序，专门计算图的自同构。在 Wanted 板上查看 transversal-gate-cert →

Three new words here. Triorthogonality (Bravyi and Haah, arXiv:1209.2426): a 0/1 matrix is triorthogonal when the overlap of any two rows (the number of positions where both are 1) is even, and the overlap of any three rows is even as well; they prove that the stabilizer code built from a triorthogonal matrix has a transversal T gate on all its logical qubits (possibly together with Clifford gates). A worked example: the three rows 11110000, 11001100, 10101010. Pairwise overlaps: rows 1 and 2 are both 1 in positions 1 and 2, two positions; rows 1 and 3 in positions 1 and 3, two; rows 2 and 3 in positions 1 and 5, two; all even. All three rows are 1 only in position 1, one position, odd, so this matrix is not triorthogonal. Lengthened to 16 bits it works: the four rows 0000000011111111, 0000111100001111, 0011001100110011, 0101010101010101 (write the 16 numbers 0 to 15 in 4-bit binary and let each row take one of the digits) have all pairwise overlaps 4 and all triple overlaps 2 (checked by this guide's script). The test only counts overlaps, which is why it is exact. Tanner graph: draw a dot for every qubit and a square for every check, and join a check to every qubit it touches; its automorphisms are relabellings that keep every line, i.e. the automorphisms of the code mentioned above. nauty: a widely used program for computing the automorphisms of a graph. See transversal-gate-cert on the Wanted board →

QEC-Bank 给每个码存一架「表示阶梯」，R1 到 R5。R1 是检查矩阵，R2 是结构。设计文档 3.2 节对 R2 的规定原文：“for all CSS-type entries the chain complex is the default canonical form — homology gives k and logical representatives, systolic data gives distance bounds.” 这就是 why_it_matters 里的 homological representation（同调表示）：对每个 CSS 码，链复形是默认的标准形式，从它算出 k（第 0 章事实 3 的「2」正是环面的同调算出来的）和逻辑算符的代表元（1.3 节的四个类）。LogicalOperation facet 就是第 2 章那两张表所在的侧面。Connects … directly：今天两者之间没有箭头——R2 算出「有哪些逻辑算符」就停了，「对它们能做哪些门」另起一行由人填。上积计算器就是那个缺失的箭头。人话：QEC-Bank 已经存了圈的结构，只是还没有人教机器从圈的结构里读出门。

The QEC-Bank stores a “representation ladder” for every code, rungs R1 to R5. R1 is the check matrices, R2 the structure. The design document, section 3.2, on R2 verbatim: “for all CSS-type entries the chain complex is the default canonical form — homology gives k and logical representatives, systolic data gives distance bounds.” That is the homological representation of why_it_matters: for every CSS code the chain complex is the default canonical form, from which k is computed (the “2” of fact 3 in Chapter 0 is exactly the homology of the torus) along with representatives of the logical operators (the four classes of 1.3). The LogicalOperation facet is the facet holding the two tables of Chapter 2. Connects … directly: today there is no arrow between them; R2 stops at “which logical operators exist”, and “which gates act on them” is a separate line filled in by a person. A cup-product calculator is the missing arrow. In plain words: the QEC-Bank already stores the structure of the loops; nobody has yet taught the machine to read gates off that structure.

具体到卡片上的字段：

Down to the fields on the card:

三件事。第一，问「gross 上有没有上积构造能证出的非 Clifford 门」并得到机器的回答。今天卡片给的是沉默——五条 Clifford 记录之外什么都没有——而沉默既不是「有」也不是「没有」。机器的「这个构造证不出」也只回答这个构造，不回答「gross 有没有自带的非 Clifford 门」。第二，公平地比较两个乘积码的「计算能力」。QEC-Bank 比较码的性价比用的是 k·d²/n 一类的存储指标（BB 教程 1.1 节）；transversal-gate-cert 的 why_it_matters 说得直白：“feeds fair comparison of computation, not just memory”。没有机器算出的门表，「哪个码更适合算」这一栏根本不存在。第三，让新登记的乘积码的一部分门由机器算出。今天每新登记一个码，operations 就要有人去读论文再抄；有了上积计算器，上积构造能证出的那些门可以像 k 一样从登记的复形里算出来。其余的门（手术、编织、魔法态等机制）仍要有人登记并注明出处。人话：今天 QEC-Bank 能告诉你一个码存得多好，不能告诉你它算得多好。

Three things. First, ask “does the cup-product construction certify a non-Clifford gate on gross” and get an answer from the machine. Today the card offers silence, nothing beyond five Clifford records, and silence is neither “yes” nor “no”. A machine's “this construction certifies none” would also answer only for this construction, not the question “does gross have a native non-Clifford gate”. Second, compare the “computational power” of two product codes fairly. The QEC-Bank ranks codes by storage figures of merit such as k·d²/n (BB guide 1.1); the why_it_matters of transversal-gate-cert says it plainly: “feeds fair comparison of computation, not just memory”. Without machine-computed gate tables the column “which code computes better” does not exist. Third, have part of a newly registered product code's gates computed by the machine. Today every new code needs a person to read papers and copy its operations; with a cup-product calculator the gates the cup-product construction certifies could be computed from the registered complex, like k. The other gates (surgery, braiding, magic states and other mechanisms) would still be entered and cited by people. In plain words: today the QEC-Bank can tell you how well a code stores, not how well it computes.

输入。一个乘积码的链复形。QEC-Bank 基础页 foundations/css-chain-complexes/intuition.md 的一句话定义：“Two classical codes with H_X H_Z^T = 0 are one chain complex; homology counts logicals.” 对环面码，这就是「顶点—边—面」三层和两张矩阵：哪些边碰哪个顶点（星检查），哪些边围哪块面（面检查）。但只有矩阵还不够：上积的公式（1.4 节）要用到复形的形状——哪些格子是三角形、每个三角形的顶点怎样排序。乘积码的矩阵本身不带这些，要从它是怎样乘出来的（两个零件各是什么、怎样配对）去造出这样的复形，这正是 arXiv:2501.19375 所做的事（4.3 节）。

Input. The chain complex of a product code. The one-line definition on the QEC-Bank foundations page foundations/css-chain-complexes/intuition.md: “Two classical codes with H_X H_Z^T = 0 are one chain complex; homology counts logicals.” For the toric code this is the three layers vertices, edges, faces and two matrices: which edges touch which vertex (star checks), which edges bound which face (plaquette checks). Matrices alone are not enough, though: the cup-product formula (1.4) needs the shape of the complex, which cells are triangles and how each triangle orders its corners. The matrices of a product code do not carry this, so such a complex must be built from how the code was multiplied together (what the two parts are and how they pair), which is what arXiv:2501.19375 does (4.3).

记号：H_X = X 型检查的 0/1 矩阵（每行一条星检查，每列一个比特），H_Z = Z 型检查的矩阵；上标 T = 转置（行列互换）；乘积为 0 是「每条星检查与每条面检查共用偶数个比特」的矩阵写法，即第 0 章事实 1 的对易条件（qLDPC 教程 1.2 节）。

Notation: H_X = the 0/1 matrix of X-type checks (one row per star check, one column per qubit), H_Z = the matrix of Z-type checks; superscript T = transpose (swap rows and columns); the product being 0 is the matrix form of “every star and every plaquette share an even number of qubits”, the commutation condition of fact 1 in Chapter 0 (qLDPC guide 1.2).

输出。两样东西。(1) 一张上积表：对比特所在那一次的上同调类（X 型逻辑算符的类；环面码上是 1 次类，一般的次数 q 见 4.4 节）的每一对、每一个三元组，它们的上积是什么——环面码上就是图 1.4 算出的那些总值（再加上三元组一栏，在环面上全为零：三个 1 次类的上积是 3 次类，而二维的环面上没有 3 维的格子，也就没有非零的 3 次类）。(2) 从表里读出的门证书：对 1.5 节那样由上积构造出来的常深度电路，证明它保持码空间、实现哪个逻辑门、层级是 Clifford 还是非 Clifford，每条附一份机器能核对的证书——是「证明有这些门」，不是「判定全部门」。第 (2) 项就是能直接写进 operations 字段、origin 标 derived 或 verified 的东西。人话：进去的是 QEC-Bank 已经有的矩阵和乘法配方，出来的是门的清单和证书。

Output. Two things. (1) A cup-product table: for every pair and every triple of cohomology classes of the qubits' degree (classes of X-type logicals; degree 1 on the toric code, the general degree q in 4.4), their cup product; on the toric code these are the totals computed with Fig. 1.4 (plus a triples column, all zero on the torus: the product of three degree-1 classes has degree 3, and a two-dimensional torus has no 3-dimensional cells, hence no nonzero degree-3 class). (2) Gate certificates read off the table: for constant-depth circuits built from cup products as in 1.5, a proof that each preserves the code space, which logical gate it performs and whether it is Clifford or non-Clifford, each with a machine-checkable certificate — “these gates exist”, not “all gates decided”. Item (2) is what could be written straight into the operations field with origin derived or verified. In plain words: what goes in is matrices and a multiplication recipe the QEC-Bank already has; what comes out is a list of gates with certificates.

Wanted 板给难度只有两个词。hard-engineering = 「知道怎么做，但要做很多」；open-research = 「没人知道怎么做」。这道题是 open-research。对照 2.3 节：transversal-gate-cert 是 hard-engineering，因为三正交性检查、图自同构枚举、小 n 穷举都是已知算法，缺的是把它们做完；cup-products 是 open-research：理论构造已经有了（arXiv:2501.19375），但它能不能用在 QEC-Bank 关心的码上、怎样变成可运行的程序，还没有答案（4.3 节）。设计文档 4.1 节的对照表也这样写：“Recent theory (arXiv:2501.19375; Freedman–Hastings lineage); no computational library” —— 有理论，没有可运行的库。

The Wanted board grades difficulty with two words only. hard-engineering = “known how, but much to do”; open-research = “nobody knows how”. This item is open-research. Compare 2.3: transversal-gate-cert is hard-engineering because triorthogonality checks, graph-automorphism enumeration and small-n brute force are known algorithms awaiting completion; cup-products is open-research: a theoretical construction exists (arXiv:2501.19375), but whether it applies to the codes the QEC-Bank cares about, and how it becomes a runnable program, is unanswered (4.3). The design document's comparison table in section 4.1 says the same: “Recent theory (arXiv:2501.19375; Freedman–Hastings lineage); no computational library”, theory exists, a runnable library does not.

一、QEC-Bank 存的链复形没有几何。上积的教科书定义依赖「哪块面的哪个角是哪个顶点」这类形状信息，而 QEC-Bank 的链复形库只有矩阵。Wanted 板上另一道 partial 的题 chain-complex-lib 的 statement 原文说得清楚：“Extend the minimal ChainComplex (length-3, no geometry) to cell complexes with boundaries, higher dimensions, and coordinate embeddings.” 它的 current_proxy 是 “qeclib.chain (length-3, matrix-only) + hand-coded lattice dicts.” 也就是说，上积计算器的输入格式本身还没有建好：只有 3 项（顶点、边、面这种三层）的矩阵，没有形状，也没有更高维的层。

One: the chain complexes the QEC-Bank stores have no geometry. The textbook definition of the cup product relies on shape information such as “which corner of which face is which vertex”, while the QEC-Bank chain-complex library holds only matrices. The statement of another partial item on the board, chain-complex-lib, says so verbatim: “Extend the minimal ChainComplex (length-3, no geometry) to cell complexes with boundaries, higher dimensions, and coordinate embeddings.” Its current_proxy is “qeclib.chain (length-3, matrix-only) + hand-coded lattice dicts.” In other words, the input format for a cup-product calculator does not exist yet: 3-term matrices only (three layers, like vertices, edges, faces), no shape and no higher layers.

二、乘积码不一定是「形状」，要先给它造一个。环面码画得出来，因为它真的是一个甜甜圈的表面：比特正好在曲面剖分的边上，检查正好是剖分的星和面。BB 码不是这样的码。它的检查要连到隔几格、绕过环面的比特（BB 教程 1.2 节），所以它不是「比特平铺在平面上、每条检查只碰距离有限的比特、单位面积比特数有界」这种二维局域布局上的码；对这种布局，Bravyi–Poulin–Terhal 定理限定 k·d² ≤ c·n（BB 教程 1.1 节）。注意这和「连线画不画得上曲面」是两回事：任何有限的图都能画在洞足够多（亏格足够高）的曲面上而不交叉；而表面码意义下的「曲面上的码」要求检查恰好是一个剖分的星和面，这比「图能画上去」严格得多。一般的超图积（qLDPC 教程第 2 章）同样不是现成的曲面。arXiv:2501.19375 正是为这件事而写：它的摘要说，从乘积构造得到的 qLDPC 码与 CSS 码都带着「隐藏的」单纯复形或 CW 复形结构——把零件码的 Tanner 图「加厚」成流形，再三角剖分（或收缩回一个 CW 复形），上积就定义在这个结构上，并能诱导非 Clifford 门；论文对两类三维乘积码给出了常深度的逻辑 CCZ。所以缺的不是「没人知道怎样定义」，而是两段具体的空白。其一是适用范围：论文引言写明，要得到第 3 级的非 Clifford 门，码要定义在三维（4 项）链复形上，而 gross 这样的 BB 码是 3 项的；论文的例子也是它自己构造的三维乘积码，不是 QEC-Bank 里现成的 surface 或 gross。能不能、怎样用在 QEC-Bank 的条目上，要有人去做。其二是实现：把论文的构造写成程序、在具体复形上算出上积、再把结果写成证书，今天没有这样的库（4.2 节）。

Two: a product code need not be a “shape”; one has to be built for it. The toric code can be drawn because it really is the surface of a doughnut: its qubits sit exactly on the edges of a cellulation of the surface and its checks are exactly the stars and faces. BB codes are not codes of that kind. Their checks reach qubits a few sites away and around the torus (BB guide 1.2), so they are not codes on a two-dimensional local layout, “qubits tiled in the plane, every check touching only qubits within a bounded distance, a bounded number of qubits per unit area”; for such layouts the Bravyi–Poulin–Terhal theorem caps k·d² ≤ c·n (BB guide 1.1). Note that this is a different matter from whether the connections can be drawn on a surface: every finite graph can be drawn without crossings on a surface with enough holes (high enough genus), while a “code on a surface” in the surface-code sense requires the checks to be exactly the stars and faces of a cellulation, far stricter than “the graph can be drawn”. General hypergraph products (qLDPC guide, Chapter 2) are not ready-made surfaces either. arXiv:2501.19375 is written for exactly this: its abstract states that qLDPC and CSS codes obtained from product constructions carry “hidden” simplicial or CW complex structures, obtained by thickening the Tanner graphs of the component codes into manifolds and triangulating them (or retracting to a CW complex); cup products are defined on that structure and can induce non-Clifford gates, and the paper gives constant-depth logical CCZ gates for two kinds of three-dimensional product codes. So what is missing is not “nobody knows how to define it” but two concrete gaps. One is applicability: the paper's introduction says that a gate at level 3 needs a code defined on a three-dimensional (4-term) chain complex, while BB codes such as gross are 3-term; the paper's examples are three-dimensional product codes it constructs itself, not the QEC-Bank's existing surface or gross. Whether and how it applies to QEC-Bank entries remains to be worked out. The other is implementation: turning the construction into a program, computing cup products on concrete complexes and writing the results as certificates; no such library exists today (4.2).

三、从上积表到「门」还有一段路。即使算出了表，「这个常深度电路在 gross 上实现某个逻辑 CCZ」还要在这个具体的复形上核对论文引理的条件（这样才能保证它保持码空间）、算出它对全部逻辑比特的作用（gross 有 k = 12 个逻辑比特，BB 操作教程 3.2 节列了认证一个门的五步），再写成证书。这一段与 transversal-gate-cert 重叠，是 hard-engineering 而非 open-research，但它今天也没有做。

Three: from the cup-product table to a “gate” there is still a road. Even with the table computed, “this constant-depth circuit implements some logical CCZ on gross” still needs the conditions of the paper's lemmas checked on that concrete complex (which is what guarantees it preserves the code space), its action on all logical qubits computed (gross has k = 12, and BB operations guide 3.2 lists the five steps to certify a gate), and the result written as a certificate. This stretch overlaps with transversal-gate-cert and is hard-engineering rather than open-research, but it too is undone today.

和 《大码的码距》那道题不同，这道题的难点不是组合爆炸。先说清要数的是什么。上积的输入是比特所在那一层的上同调类：比特放在 q 维的格子上，输入就是 q 次上同调类，对 CSS 码就是 X 型逻辑算符的类（相差 X 检查视为相同）；Z 型逻辑算符是同调类，配对时才用，不是这里的输入。两两上积落在 2q 次，三三落在 3q 次。环面码与 1.5 节的例子里比特在边上，q = 1，所以前面一直说「1 次类」。q 不一定是 1：Zhu 把一般的量子码搬到 CW 复形上时（第 VI.1–VI.2 节，沿用 Freedman–Hastings 的映射），X 检查、比特、Z 检查分别放在 3 维、4 维、5 维的格子上，码空间的一组基由第 4 层的同调群 H₄ 标记（dim H₄ = k 时，量子码空间是 2^k 维；同调群本身是 0/1 系数的空间，不是量子态的希尔伯特空间），输入就是 4 次类，两两乘积在 8 次、三三在 12 次；它的加厚三维超图积码把比特放在 12 维流形三角剖分的 4 维单形上，三个 4 次类的上积正好是 12 次，在整个流形上求和（引言与定理 4）。一份码的 q 次上同调类组成一个 k 维的空间：每个类由 k 个 0/1 的「位」决定，所以取 k 个基类就够。又因为上积对每个输入都是线性的（(α + α′) ⌣ β = α ⌣ β + α′ ⌣ β，论文式 (13) 的「双线性」），只要算基类之间的乘积，其余的都由加法得到。环面码 k = 2，基类就是图 1.4 的 α、β：两两上积 2 × 2 = 4 个，每个输出是 2 次类；环面上 2 次类只有一个维度（「整张曲面」），所以每个输出就是一个数，即图 1.4 下算出的 ∫ 值。gross k = 12：如果先给它造出一个带上积的复形，并在其中认出一个 12 维的逻辑输入空间（q 次上同调里对应 gross 那 12 个逻辑比特的部分），两两才有 12 × 12 = 144 个输出，三三 12³ = 1 728 个；造出的复形若让输入空间更大或更小，这两个数随之改变。每个输出写成多少个数，取决于那个复形的 2q 次、3q 次上同调各有多少维，这同样要等复形造出来才知道（4.3 节）。QEC-Bank 存的 3 项复形本身只有三层（q = 1，没有 3 次的格子），即使在它上面定义了上积，三三乘积也只能全为零。这些计数都不大，但表的格数说明不了计算要花多久：那取决于复形有多大、用什么算法，本篇没有估算。难的是第 4.3 节的前两条：在什么复形上算（要先造出来，而且要有足够的维数）和拿什么算（输入格式和程序都还不存在）。人话：这不是一道「表太大算不完」的题，而是一道「要算的那个复形和程序都还没有」的题。

Unlike the “Distance for large codes” item, the difficulty here is not combinatorial explosion. First, what is to be counted. The inputs of the cup product are cohomology classes of the layer that holds the qubits: with qubits on q-dimensional cells, the inputs are degree-q cohomology classes, which for a CSS code are the classes of X-type logical operators (up to X checks); Z-type logicals are homology classes, used in the pairing, and are not inputs here. Pairwise products land in degree 2q, triple products in degree 3q. On the toric code and in the examples of 1.5 the qubits sit on edges, q = 1, which is why the text so far said “degree-1 classes”. q need not be 1: when Zhu carries a general quantum code over to a CW complex (sections VI.1–VI.2, following the Freedman–Hastings mapping), X checks, qubits and Z checks sit on 3-, 4- and 5-dimensional cells, a basis of the code space is indexed by the layer-4 homology H₄ (when dim H₄ = k the quantum code space has dimension 2^k; the homology itself is a space with 0/1 coefficients, not the Hilbert space of quantum states), and the inputs are degree-4 classes, with pairwise products in degree 8 and triple ones in degree 12; its thickened 3D hypergraph product codes put the qubits on the 4-simplices of a triangulated 12-manifold, where the product of three degree-4 classes has degree exactly 12 and is summed over the whole manifold (introduction and Theorem 4). The degree-q cohomology classes of one code form a k-dimensional space: each class is fixed by k bits of 0/1, so a basis of k classes suffices. And since the cup product is linear in each input ((α + α′) ⌣ β = α ⌣ β + α′ ⌣ β, the “bilinear” of the paper's eq. (13)), only products of basis classes need computing; the rest follow by addition. The toric code has k = 2, with basis classes the α and β of Fig. 1.4: 2 × 2 = 4 pairwise products, each output a degree-2 class; on the torus the degree-2 classes form a single dimension (“the whole surface”), so each output is one number, the ∫ values computed with Fig. 1.4. gross has k = 12: if one first builds a complex with cup products for it and identifies in it a 12-dimensional logical input space (the part of degree-q cohomology that corresponds to the 12 logical qubits of gross), there are 12 × 12 = 144 pairwise outputs and 12³ = 1 728 triple ones; a complex whose input space is larger or smaller changes both numbers. How many numbers each output takes depends on how many dimensions the degree-2q and degree-3q cohomology of that complex has, which is likewise known only once the complex is built (4.3). The QEC-Bank's stored 3-term complex has only three layers (q = 1, no degree-3 cells), so even if a cup product were defined on it, every triple product would be zero. These counts are small, but a table's cell count says nothing about how long the computation takes: that depends on the size of the complex and on the algorithm, and this guide makes no estimate. The hard part is the first two points of 4.3: on which complex to compute (it must first be built, with enough dimensions) and with what (neither the input format nor the program exists yet). In plain words: this is not a problem whose table is too big to finish; it is one where the complex to compute on and the program to compute with do not exist yet.

记号：q = 比特所在格子的维数，也就是上积输入的次数；k = 逻辑比特数，也就是 q 次上同调类空间的维数；12 × 12 与 12³ 是本篇自己算的个数，前提是认出了 12 维的逻辑输入空间，不是 QEC-Bank 页面上的数。

Notation: q = the dimension of the cells that hold the qubits, which is the degree of the cup-product inputs; k = the number of logical qubits, which is the dimension of the space of degree-q cohomology classes; 12 × 12 and 12³ are counts computed for this guide, assuming a 12-dimensional logical input space has been identified, not numbers from QEC-Bank pages.

回到 1.1 节的沙盘（或纸上的 3 × 3 环面）。四条基本圈：Z̄₁ = 某一行的 3 条横边，Z̄₂ = 某一列的 3 条竖边，X̄_竖 = 某一列的 3 条横边（竖直对偶路径穿过它们），X̄_横 = 某一行的 3 条竖边（水平对偶路径穿过它们）。对每一对 (Z 圈, X 圈) 数共用的边：

Return to the sandbox of 1.1 (or a 3 × 3 torus on paper). Four basic loops: Z̄₁ = the 3 horizontal edges of some row, Z̄₂ = the 3 vertical edges of some column, X̄_vert = the 3 horizontal edges of some column (a vertical dual path crosses them), X̄_horiz = the 3 vertical edges of some row (a horizontal dual path crosses them). For each pair (Z loop, X loop) count shared edges:

与 1.3 节的公式 h·v′ + v·h′ 逐格相符。最后一格值得停一下：Z̄₁Z̄₂ 与 X̄_竖X̄_横 共用 2 条边，偶数，对易——两条都「双绕」的圈互相不反对易。这在 Toric Code 教程 5.6 节的 δ_ij 公式里对应 X̄₁X̄₂ 与 Z̄₁Z̄₂ 交换时出现两个 −1 相乘为 +1。你刚刚用 9 次「数边」重建了环面码全部逻辑算符的对易表——这就是「拓扑替我们算」在最小尺度上的样子。

Cell by cell this matches the formula h·v′ + v·h′ of 1.3. The last cell deserves a pause: Z̄₁Z̄₂ and X̄_vertX̄_horiz share 2 edges, even, so they commute; two “doubly winding” loops do not anticommute. In the δ_ij rule of section 5.6 of the toric-code guide this is two factors of −1 multiplying to +1 when X̄₁X̄₂ and Z̄₁Z̄₂ are swapped. With 9 edge counts you have just rebuilt the full commutation table of the toric code's logical operators, which is “topology computing for us” at the smallest scale.

下面的圈实验室是一个 5 × 5 的环面。画一条可收缩的小圈，再画一条绕环面一圈的圈，然后给 Z 圈乘上几块面（点击相邻的边把圈推过去）。观察两件事：可收缩的圈不管怎么变都还是可收缩的（能被面检查乘掉），缠绕的圈不管怎么变都还缠绕（1.3 节的标签 (h, v) 不变）。这就是 1.2 节「变形不改变标签」的动手版。再试交叉奇偶：画好一条缠绕的 Z 圈后，切到「画 X 串」，画一条沿另一个方向缠绕的 X 串（沿一列横边）；两种串会同时留在画面上，读数对 Z 串和 X 串各给一句判断。实验台不会替你数两者的交叉：自己数两种颜色同时占着的边，记下奇偶；然后把 Z 圈推过一块面（或给 X 串乘一颗星：把一个顶点周围的四条边各点一次，每条都切换——没选的选上，已经选着的熄掉），再数一次。数目可能变，奇偶不变。

The loop lab below is a 5 × 5 torus. Draw a small contractible loop, then a loop that winds around the torus, then multiply the Z loop by a few plaquettes (click neighbouring edges to push the loop over). Watch two things: a contractible loop stays contractible however it changes (it can be multiplied away by plaquettes), and a winding loop stays winding (the label (h, v) of 1.3 is unchanged). This is the hands-on version of “deformation does not change the label” from 1.2. Then try the crossing parity: with a winding Z loop drawn, switch to “draw X string” and draw an X string winding the other way (along the horizontal edges of one column); both strings stay on the canvas, and the readout gives one verdict for the Z string and one for the X string. The lab does not count their crossings for you: count the edges held by both colours yourself and note the parity; then push the Z loop over one plaquette (or multiply the X string by a star: click each of the four edges around one vertex once, which toggles each of them, so unselected edges turn on and edges already selected turn off) and count again. The number may change; its parity does not.

平面版本也值得看一眼。把环面剪开成有边界的平面贴片（表面码），缠绕圈变成「从一条边界跨到对面边界」的串；逻辑 X 串与逻辑 Z 串仍然恰好交叉一次。下面的逻辑算符实验室画的就是这种串，并当场检验它与所有检查对易——同一个奇偶不变量，换了一个舞台。

The planar version is worth a look too. Cut the torus open into a planar patch with boundaries (the surface code) and a winding loop becomes a string “from one boundary to the opposite one”; the logical X string and logical Z string still cross exactly once. The logical-operator lab below draws such strings and checks on the spot that they commute with every check: the same parity invariant on a different stage.

相关条目。yaml 的 related 列出 surface 与 bivariate_bicycle。两个条目的「逻辑操作」教程逐条讲了第 2 章那 14 条记录：表面码逻辑操作教程第 1 章（需要哪些门、三条路、Bravyi–König 天花板）与 BB 逻辑操作教程第 1 章（五条记录一览）、第 5 章（自对偶子族与非 Clifford 的边界）。乘积码的结构在 qLDPC 教程第 2 章（超图积）与 BB 教程第 2 章（多项式即稀疏矩阵）。

Related entries. The yaml's related list names surface and bivariate_bicycle. Their operations guides explain the 14 records of Chapter 2 one by one: surface operations guide, Chapter 1 (which gates are needed, three roads, the Bravyi–König ceiling) and BB operations guide, Chapter 1 (the five records at a glance), Chapter 5 (the self-dual subfamily and the non-Clifford boundary). The structure of product codes is in qLDPC guide, Chapter 2 (hypergraph product) and BB guide, Chapter 2 (polynomials as sparse matrices).

这道题的两个邻居。同一个目标的代数路线是 partial 的 transversal-gate-cert（2.3 节，Wanted 板）；它需要的输入格式是 partial 的 chain-complex-lib（4.3 节，Wanted 板）。这道题的 yaml 没有登记 working_repo。

The item's two neighbours. The algebraic road to the same goal is the partial transversal-gate-cert (2.3, Wanted board); the input format it needs is the partial chain-complex-lib (4.3, Wanted board). The item's yaml registers no working_repo.

同一系列。「从形状读出代数」的反面——「两个不同形状是不是同一个码」——是 《同一个码穿不同的衣服》；「把结论写成机器能核对的证书」是 《一张机器能核对的「没有更轻逻辑算符」证书》。

In this series. The converse of “reading algebra off a shape”, namely “are two different shapes the same code”, is “The same code in different clothes”; “writing the conclusion as a machine-checkable certificate” is “A machine-checkable certificate that nothing lighter exists”.

回放一遍。环面码上一条 Z 圈与一条 X 圈共用的边数，随变形而变，奇偶不变；这个奇偶就是两个逻辑算符对易与否，四个圈类之间的全部答案是一张 4 × 4 表，公式 h·v′ + v·h′。上积把两个上同调类乘成一个更高次的类，次数相加；在切成三角形的环面上，它的总值就是两条对偶圈交叉的奇偶，所以那张表也能读成上积表。它能再乘第三个类：在三维的复形上，三个 1 次类的总值数的是三张对偶膜共同交点的奇偶。Zhu 的构造把这些总值变成门：二维上两份码之间的一张 CZ 电路（Clifford），三维上三份码之间的一张 CCZ 电路（第 3 级，非 Clifford）——它证出这些门，不判定一个码的全部门。QEC-Bank 今天在 surface 与 bivariate_bicycle 的「逻辑操作」侧面存了 9 + 5 = 14 条记录，全部 claimed，唯一的非 Clifford 是靠魔法态买来的 T，自带的一条也没有——「没有记录」而非「证明没有」。一台能在乘积码的链复形上算上积的机器，能为上积构造证出的那些门（1.5 节）写出 derived 或 verified 的记录，让「哪个码更适合算」多出一栏可以比较的内容；这 14 条里靠魔法态的 T 以及手术、编织等其余机制的记录不在此列，仍要有人登记并注明出处（3.3 节）。难度 open-research：论文已经给乘积码造出了带上积的复形（arXiv:2501.19375，登记待补），但它要 4 项的复形、例子是论文自己构造的码，用到 QEC-Bank 的条目上还没人做；输入格式（chain-complex-lib 是 partial）和程序也都还没有。难的不是表的大小：即使在造出的复形里认出了 gross 的 12 维逻辑输入空间，两两上积也只有 12 × 12 = 144 个输出。

Replay. On the toric code the number of edges a Z loop and an X loop share changes under deformation; its parity does not. That parity is whether the two logical operators commute, and the full answer among the four loop classes is one 4 × 4 table, formula h·v′ + v·h′. The cup product multiplies two cohomology classes into a class of higher degree, the degrees adding; on the torus cut into triangles its total is the crossing parity of two dual loops, so the table can also be read as a cup-product table. It can multiply a third class: on a three-dimensional complex the total of three degree-1 classes counts, mod 2, the points common to three dual membranes. Zhu's construction turns these totals into gates: a CZ circuit between two copies in two dimensions (Clifford), a CCZ circuit between three copies in three dimensions (level 3, non-Clifford); it certifies these gates and does not decide all the gates of a code. Today the QEC-Bank holds 9 + 5 = 14 records in the “Logical operations” facets of surface and bivariate_bicycle, all claimed; the only non-Clifford one is a T bought with magic states, and native ones number zero, “no record” rather than “proven absent”. A machine computing cup products on the chain complexes of product codes could write derived or verified records for the gates the cup-product construction certifies (1.5), giving “which code computes better” some content that can be compared; the T by magic states and the other records among the 14 (surgery, braiding and other mechanisms) are outside its reach and still have to be entered by people with their sources (3.3). Difficulty open-research: the paper has built complexes with cup products for product codes (arXiv:2501.19375, registration pending), but it needs 4-term complexes and its examples are codes it constructs itself; nobody has yet carried it over to QEC-Bank entries, and neither the input format (chain-complex-lib is partial) nor a program exists. Table size is not the issue: even once a 12-dimensional logical input space for gross is identified in a built complex, its pairwise cup products have only 12 × 12 = 144 outputs.