A first-principles walkthrough — from undergraduate quantum mechanics up to the paper's result
Start with the thing we actually want. A quantum computer is useless if it cannot remember. We need to store a quantum state — a vector in a Hilbert space, a superposition with real relative phases — and have it still be there, intact, much later. The trouble is that quantum states are exquisitely fragile: every stray coupling to the environment (decoherence) nudges the state, and unlike a classical bit you cannot simply read it to check on it, because measurement collapses the superposition you were trying to protect. Worse, the no-cloning theorem forbids the classical fix of keeping backup copies.
So “just store it” is off the table. The realistic goal comes in two flavours:
A class of exotic phases of matter called fracton order is a tantalizing candidate for the passive route, for reasons we will make precise in §5. Its excitations cannot move freely, which suggests (heuristically) an energy barrier to errors that grows with system size. Whether that actually yields a long memory lifetime is a hard question about Hamiltonian dynamics that this paper does not settle — passive memory is the motivation, the backdrop, not a result claimed here.
But here is the point that survives regardless of the dynamics. Any memory, active or passive, is worthless unless, after noise has crept in, you can read out which state was stored — you must recover the logical information from the corrupted physical system. That recovery step is called decoding, and as we will see, fracton codes have a notorious decoding problem: the standard tools that work for ordinary quantum codes do not apply to them. The rest of this page is about building the decoder they were missing.
Next: to even define “decoding,” we need the machinery that detects errors without destroying the data.
The central trick of quantum error correction resolves the measurement paradox. You do not measure the logical state. Instead you measure a set of multi-qubit operators — the stabilizers — chosen so that (i) they all commute with one another, so they can be measured simultaneously, and (ii) they commute with the logical information, so measuring them tells you nothing about the stored state and therefore cannot collapse it.
Concretely, work in the \(N\)-qubit Pauli group: tensor products of \(\{I, X, Y, Z\}\). A stabilizer group \(\mathcal{S}\) is an abelian subgroup of the Pauli group not containing \(-I\). The codespace is the simultaneous \(+1\)-eigenspace of all its elements: the “good” states \(|\psi\rangle\) with \(S|\psi\rangle = +|\psi\rangle\) for every \(S \in \mathcal{S}\). Because the stabilizers commute, this joint eigenspace is well-defined and you can measure all of them at once.
Now suppose a Pauli error \(E\) strikes. Each stabilizer \(S\) either commutes or anticommutes with \(E\) (any two Paulis do one or the other). If they commute, \(S\) still reads \(+1\). If they anticommute, \(SE|\psi\rangle = -ES|\psi\rangle = -E|\psi\rangle\): the measurement now reads \(-1\). That flipped sign is a detection event. The pattern of which stabilizers read \(-1\) is the syndrome — and crucially it depends only on \(E\), not on the protected state \(|\psi\rangle\). You learn that something happened, and a fingerprint of what, without learning the secret.
For the codes we care about, all of this linearizes beautifully. Restrict attention to the bit-flip channel: errors built from \(X\) operators (we will justify this restriction in §3.3). An \(X\)-error is then just a subset of qubits — a binary vector \(e \in \mathbb{F}_2^N\), where \(e_i = 1\) means “qubit \(i\) was flipped.” All arithmetic happens over \(\mathrm{GF}(2)\) (also written \(\mathbb{F}_2\) or \(\mathbb{Z}_2\)): the field \(\{0,1\}\) where \(+\) is XOR, \(1+1=0\), and there are no carries.
A stabilizer that anticommutes with \(X\)-errors is a \(Z\)-type operator, and you can write it as a row of a parity-check matrix \(H\): each row is one check, each column one qubit, and a \(1\) marks participation. The commute-or-anticommute question becomes a parity: check \(r\) fires iff an odd number of its qubits were flipped. Collecting all rows,
\[ s \;=\; H e \pmod 2, \]the syndrome \(s\) is the list of violated checks. The abstract Pauli statement — “does \(E\) anticommute with stabilizer \(S\)?” — is now a matrix-vector product over \(\mathbb{F}_2\). (More generally a Pauli maps to a binary symplectic vector with \(X\)- and \(Z\)-parts, and commutation is a symplectic inner product; for the bit-flip channel only the picture above is needed.)
A CSS code is a stabilizer code whose checks split cleanly into independent \(X\)-type and \(Z\)-type families — the \(X\)-checks catch \(Z\)-errors, the \(Z\)-checks catch \(X\)-errors. The two families must be compatible (every \(X\)-check commutes with every \(Z\)-check), which over \(\mathbb{F}_2\) is exactly the orthogonality condition
\[ H_X H_Z^\top = 0. \]Counting dimensions then gives the number of protected logical qubits:
\[ k \;=\; N - \mathrm{rank}(H_X) - \mathrm{rank}(H_Z). \]The remaining vocabulary:
We will see the paper machine-verify \(H_X H_Z^\top = 0\) and \(k = N - \mathrm{rank}\,H_X - \mathrm{rank}\,H_Z\) directly from the matrices in §9.1 — the code object is checked to be real before any learning happens.
Next: the checks fire, but they don’t hand you the error. Turning the syndrome back into a correction is the decoding problem.
Noise applies some error \(e\); you cannot observe it. All you observe is \(s = He\): which checks fired. The decoder must look at \(s\) and propose a correction. The difficulty is fundamental and combinatorial: the map \(e \mapsto He\) is many-to-one, so exponentially many errors are consistent with any given syndrome. You can never know which \(e\) actually happened.
Fortunately you do not need the exact \(e\). Two errors that differ by a stabilizer are physically identical — correcting one corrects the other, because applying a stabilizer does nothing to a codestate. So the errors consistent with \(s\) partition into equivalence classes, and within the relevant group only one distinction matters: which logical coset the error lies in. Formally, fix once and for all some error \(R(s)\) consistent with the syndrome (a “pure error,” read directly off \(H_Z\)). The true error satisfies \(e = R(s) \oplus (\text{logical}+\text{stabilizer part})\), so the only freedom left is the logical coset of the residual \(e \oplus R(s)\).
Getting that coset right is a clean recovery. Getting it wrong means you “corrected” the state but actually applied an undetectable logical operator — a logical error, silent data corruption. This reframing — decode to the coset, not the exact error — is the hinge the paper’s learning task hangs on (§6).
To make “the error rate” well-defined we fix the simplest standard noise model, the code-capacity channel: each qubit is independently hit by an \(X\) (bit-flip) error with probability \(p\), and the stabilizers are measured perfectly, once. No measurement errors, no repeated rounds, no circuit-level noise. This is the cleanest setting in which to ask whether a decoder exploits the code’s structure — and it is why §2.2’s purely binary, \(X\)-only picture is exactly what we need. The bit-flip errors are detected by the \(Z\)-type checks, so from here on “syndrome” means the pattern of violated \(Z\)-checks.
Next: the field already has two workhorse decoders. We need to understand them — and see precisely where each one is about to break.
The famous surface code is decoded by MWPM, and it works because of a special geometric fact: there, an error is a string of flips, and it lights up exactly two detection events — one at each endpoint of the string. Decoding then reduces to: given the lit-up defects, pair them up with the cheapest set of connecting strings. “Pair them up at minimum total cost” is precisely minimum-weight perfect matching, a classic graph problem with fast, near-optimal algorithms. The entire method relies on defects coming in pairs joined by a string you can trace.
For a general low-density parity-check (qLDPC) code without that string structure, the default is BP+OSD. Belief propagation is iterative message passing on the Tanner graph (qubits on one side, checks on the other): each check and qubit repeatedly exchange estimates — “beliefs” — about how likely each qubit is to be flipped, hopefully converging to a consistent assignment. OSD (we use order-0, hence BP+OSD-0) is a linear-algebra cleanup that produces a valid answer when BP fails to converge. BP is excellent when the Tanner graph is sparse and locally tree-like; it gets confused when checks overlap heavily and form short loops, because the same evidence circulates around the loops and is double-counted.
Hold onto the two preconditions: MWPM needs defects in string-joined pairs; BP needs a loop-sparse check graph. The next section introduces a code that violates both at once — and that is the whole opening.
Fracton order is a class of phases discovered around 2011–2016 (Chamon; Haah; Vijay–Haah–Fu) whose defining strangeness is the restricted mobility of excitations. In an ordinary topological phase like the toric/surface code, a defect is a free particle: a string operator drags it anywhere. In a fracton phase the excitations are geometrically stuck:
This restricted mobility is what makes fracton codes attractive as memory motivation: it yields nonlocal conservation laws and a subextensive but growing number of logical qubits. The X-cube code stores \(k = 6L-3\) of them on an \(L\times L\times L\) torus — a count that grows with \(L\), rather than a fixed handful. (This is a growing logical count, not a high asymptotic rate: \(k/N = (6L-3)/3L^3 = O(1/L^2) \to 0\).) It is sometimes conjectured that immobile excitations imply an energy barrier growing with system size, hence a long-lived self-correcting memory — but that depends on Hamiltonian dynamics and lifetime scaling, which this paper does not establish. Self-correction is the motivating backdrop, not a demonstrated property here.
The X-cube code (Vijay–Haah–Fu, 2016) lives on a periodic \(L\times L\times L\) cubic lattice with qubits on the edges: \(N = 3L^3\) of them (three edge-directions per site). It is a CSS code with two stabilizer families — equivalently the ground space of \(H = -\sum_c A_c - \sum_v B_v\) with:
And the decoding target is the vector of \(6L-3\) logical-\(Z\) parities of the error,
\[ \ell_j \;=\; \langle \mathrm{logical}_Z^{(j)},\, e\rangle \bmod 2, \qquad j = 1,\dots,6L-3, \]one bit per logical sector: did the error land in the “flipped” or “not-flipped” coset of sector \(j\)? Predicting all \(6L-3\) of them is the full decode (this is the coset statement of §3.2, made concrete). We report two metrics:
Because block failure needs all \(6L-3\) bits right at once and \(6L-3\) grows with \(L\), it is harsh at large \(L\) for everyone — one slip ruins the block. Per-sector LER is where per-qubit quality, and the scaling story, show up cleanly.
This is the opening. The very feature that makes fractons attractive — logical information carried by non-local line and membrane structures (lineon lines, planon membranes) rather than short strings — is exactly what defeats the standard decoders, which only ever look at local neighbourhoods or trace local strings. So the paper makes a bet: build a decoder whose architecture is shaped like those lines, and it can read the non-local structure the standard methods cannot.
Next: before we can train anything, we must turn “decode a quantum code” into a well-posed learning problem.
Here is the move that converts “decode a quantum code” into “train a classifier.” By §3.2, given a syndrome \(s\) we fix a pure error \(R(s)\) (directly from \(H_Z\)), and the only remaining ambiguity is the logical coset of \(e \oplus R(s)\) — exactly the \(6L-3\) parity bits. So the recovery is
\[ \text{recovery} \;=\; R(s)\ \text{(fixed, from }H_Z\text{)} \quad\text{then}\quad \text{predicted logical representative}. \]In the experiments the network is trained to predict the raw logical parities \(\langle \mathrm{logical}_Z^{(j)}, e\rangle\) of the sampled error; an explicit recovery with an arbitrary \(R(s)\) just adds a fixed known offset \(\langle \mathrm{logical}_Z^{(j)}, R(s)\rangle\) (zero if \(R(s)\) is chosen with zero logical parities). A per-sector logical error occurs precisely when a predicted parity bit is wrong. This is amortized maximum-likelihood coset decoding — the same target neural surface-code decoders already use. Predicting the \(6L-3\) parities is the full decoding output, not a proxy or a toy.
We have a supervised problem: input = the \(L\times L\times L\) cube-syndrome field (a 3D binary image, §5.2); output = \(6L-3\) parity bits. A 3D image with no time axis is the natural home of a 3D convolutional neural network — the same inductive bias (locality + translation equivariance) that makes CNNs work on ordinary images, now over a periodic cubic lattice. That choice is forced by the data structure, not imposed. What is not yet decided is how to read out the non-local logical lines — and that read-out head is the whole inventive step.
Next: the one code-aware component — the head that aggregates along the logical lines.
The decoder is a generic body plus a code-aware head:
Training recipe (per cell): \(3\times10^5\) samples, 30 epochs, a cosine learning-rate schedule, and batch size 2048 for \(L\le6\) (reduced to 768 at \(L=8\) and 384 at \(L=10\) for memory). Each \((L,p)\) cell is trained separately — so the scaling claim ahead is about a family of separately-trained decoders, one per size, not zero-shot transfer to bigger codes. Keep that distinction; a skeptic will (§11).
Next: before trusting any number, fix what would make the numbers believable.
A win is only meaningful against honest baselines, with controls that explain it, under a protocol fixed in advance. The paper sets all three before showing results.
This is the cleverest piece of the design, and not a competitor — it is a control. The Gate-0 oracle is a held-out, radius-1 local-pattern maximum-likelihood lookup: for each logical line it is handed the empirically best prediction based only on the syndrome in a radius-1 transverse neighbourhood of that line. Its advantage over trivial is an empirical estimate of how much signal lives in that local window — an indicative measure of locally-available information, not a formal Bayes-optimal bound over all conceivable local decoders. The logic: if the local window contains almost no usable signal, yet the network wins big, the network must be using non-local information.
reproduce_xcube_results.py.Next: the evidence.
Before any decoding, the script machine-verifies CSS commutation (\(H_X H_Z^\top = 0\)) and the logical-qubit count \(k = 6L-3\) straight from the parity-check matrices — the §2.3 formulas, checked:
| \(L\) | \(N\) (qubits) | \(\mathrm{rank}\,H_X\) | \(\mathrm{rank}\,H_Z\) | \(k\) computed | \(6L-3\) | CSS ok? |
|---|---|---|---|---|---|---|
| 2 | 24 | 11 | 4 | 9 | 9 | yes |
| 3 | 81 | 46 | 20 | 15 | 15 | yes |
| 4 | 192 | 117 | 54 | 21 | 21 | yes |
| 5 | 375 | 236 | 112 | 27 | 27 | yes |
| 6 | 648 | 415 | 200 | 33 | 33 | yes |
| 8 | 1536 | 1001 | 490 | 45 | 45 | yes |
| 10 | 3000 | 1971 | 972 | 57 | 57 | yes |
\(N = 3L^3\) as expected for edge qubits, and \(k\) matches \(6L-3\) exactly across every simulated size \(L\in\{2,3,4,5,6,8,10\}\) (\(k = 9,15,21,27,33,45,57\)) — including the \(L=8\) and \(L=10\) sizes the scaling rows report. The code object is real and correct before any learning happens.
Table 1 of the paper is the centerpiece. Lower is better in every column; bold marks the winner (always the learned decoder); these are 3-seed means.
| \(L\) | \(p\) | Block failure | Per-sector LER | ||||||
|---|---|---|---|---|---|---|---|---|---|
| Learned | BW-naive | BP+OSD-0 | Triv. | Learned | BW-naive | BP+OSD-0 | Triv. | ||
| 3 | 0.03 | 0.306 | 0.391 | 0.372 | 0.735 | 0.042 | 0.098 | 0.110 | 0.085 |
| 3 | 0.05 | 0.626 | 0.703 | 0.688 | 0.887 | 0.104 | 0.204 | 0.228 | 0.136 |
| 4 | 0.03 | 0.343 | 0.682 | 0.465 | 0.914 | 0.035 | 0.169 | 0.140 | 0.110 |
| 4 | 0.05 | 0.724 | 0.937 | 0.840 | 0.981 | 0.110 | 0.301 | 0.316 | 0.172 |
| 6 | 0.03 | 0.282 | 0.935 | 0.595 | 0.996 | 0.018 | 0.242 | 0.233 | 0.155 |
| 6 | 0.05 | 0.800 | 0.999 | 0.979 | 1.000 | 0.104 | 0.392 | 0.451 | 0.234 |
| 8 | 0.03 | 0.194 | 0.993 | 0.864 | 1.000 | 0.008 | 0.295 | 0.361 | 0.195 |
| 8 | 0.05 | 0.850 | 1.000 | 1.000 | 1.000 | 0.095 | 0.441 | 0.492 | 0.285 |
| 10 | 0.03 | 0.118 | 1.000 | 0.978 | 1.000 | 0.003 | 0.336 | 0.427 | 0.231 |
| 10 | 0.05 | 0.863 | 1.000 | 1.000 | 1.000 | 0.080 | 0.466 | 0.494 | 0.326 |
Reading it: at every operating point, on both metrics, the learned decoder is strictly best — it beats our BW-naive implementation, BP+OSD-0, and trivial at every cell. The seed CIs against trivial do not overlap, and paired McNemar gives \(p < 10^{-12}\) against trivial and BP+OSD-0 at every cell (and against BW-naive for \(L\le 6\), where the paired test is tabulated; BW-naive is compared by aggregate failure rate, not paired shot-by-shot, at \(L\ge 8\)). For example at \(L=3, p=0.03\): learned-vs-trivial \(b=53294\) wins to \(c=1794\) losses; learned-vs-BP+OSD-0 \(b=511\) vs \(c=99\); learned-vs-BW-naive \(b=12648\) vs \(c=2499\). The lopsided \(b \gg c\) is what makes the win statistically real, not a coin flip. (Full per-cell CIs and counts are in §11.)
And the predeclared win condition of §8.3 is met: at \(L=3, p=0.05\) the learned block-failure CI upper bound \(0.6282\) sits below the trivial CI lower bound \(0.8859\) — non-overlapping, learned below trivial. Declaring this before looking at the data is what makes it a genuine test rather than a story told afterward.
This is the result the title promises. Read the per-sector LER at \(p=0.03\) as \(L\) goes \(3 \to 4 \to 6 \to 8 \to 10\):
| \(L\) | Learned | BP+OSD-0 | Trivial | BW-naive |
|---|---|---|---|---|
| 3 | 0.042 | 0.110 | 0.085 | 0.098 |
| 4 | 0.035 | 0.140 | 0.110 | 0.169 |
| 6 | 0.018 | 0.233 | 0.155 | 0.242 |
| 8 | 0.008 | 0.361 | 0.195 | 0.295 |
| 10 | 0.003 | 0.427 | 0.231 | 0.336 |
| trend | ↓ better | ↑ worse | ↑ worse | ↑ worse |
The learned per-sector LER drops \(0.042 \to 0.035 \to 0.018 \to 0.008 \to 0.003\), while trivial worsens \(0.085 \to 0.110 \to 0.155 \to 0.195 \to 0.231\) and BP+OSD-0 worsens \(0.110 \to 0.140 \to 0.233 \to 0.361 \to 0.427\). At \(L=6\) the learned decoder is roughly a 9× per-sector improvement over trivial, widening to ~24× at \(L=8\) and ~66× at \(L=10\) — where, strikingly, both BP+OSD-0 and BW-naive per-sector LER now exceed the trivial floor, leaving the learned decoder the only one of the four that beats doing nothing on the per-sector metric (its learned-vs-trivial McNemar at \(L=8,p=0.03\) has \(c=0\): trivial never once beat it across 72,574 discordant shots, and the same holds at \(L=10\): \(c=0\) across 79,351 shots). Against BW-naive the margin widens with size: at \(L=6, p=0.03\) the learned LER (0.018) is about 13× below BW-naive’s (0.242). The basis-invariant block-failure rate tells the same story from \(L=4\) onward (\(0.343 \to 0.118\) at \(p=0.03\)).
Meanwhile BP+OSD-0’s failure is structural, exactly as §5.3 predicted: its BP convergence fraction falls from about 0.8 at \(L=3\) to about 0.03 at \(L=6, p=0.05\). The loop-heavy cube checks defeat message passing.
Next: winning is not the same as understanding why. Two controls turn the win into a mechanism.
Is the win raw network capacity, or specifically the line-aware head? The ablation swaps out only the head, holding the body fixed, at \(L=3, p=0.03\), seed 42:
| Head | Block failure | Per-sector LER |
|---|---|---|
| Trivial (floor) | 0.7342 | 0.0846 |
| Global average pool | 0.7342 | 0.0847 |
| Coordinate conv | 0.3022 | 0.0420 |
| AxisLineonHead | 0.3026 | 0.0421 |
The result is sharp: the global-average-pool head — same powerful CNN body, but a head that destroys spatial structure by averaging everything together — collapses to exactly the trivial baseline (0.7342). It learns nothing useful. Swap in either structure-preserving head (line aggregation or coordinate convolution) and the win returns (0.303 / 0.302). The head, not the body’s capacity, carries the result. Capacity without the right inductive bias is worthless here.
The §8.2 Gate-0 oracle now pays off. It estimates how much advantage the best radius-1 local rule could extract:
| Cell | Local-window advantage over trivial |
|---|---|
| \(L=3, p=0.03\) | 34.2% |
| \(L=3, p=0.05\) | 7.3% |
| \(L=4, p=0.03\) | 5.7% |
| \(L=4, p=0.05\) | 0.1% |
| \(L=6\) (all cells) | ≤ 0.3% |
The radius-1 local signal largely collapses by \(L=4\) and is negligible by \(L=6\) — the best local-window rule could barely beat the floor. Yet the learned decoder wins decisively at \(L=4\) and \(L=6\) (Table 1). So it cannot be leaning on local patterns: it must be exploiting non-local correlations — the lineon/planon line and membrane structure. That dovetails with the ablation: line aggregation is precisely the inductive bias that surfaces that non-local structure. Two independent controls, one conclusion.
Next: put on a referee’s hat and try to break it.
You are now the author reviewing your own work. Here is where a sharp referee will press — and how the paper answers.
n_distinct_syndromes_cap). Ask whether radius-1 and that cap could understate local signal — the mechanism argument needs the local estimate to be a fair measure, and it is presented as an empirical estimate, not a formal bound over all local decoders.A note on significance reporting. The paper reports the paired-McNemar comparisons as \(p < 10^{-12}\), not “\(p \approx 0\).” The \(\chi^2\) statistics are enormous (e.g. \(\sim 48{,}000\) for learned-vs-trivial at \(L=3, p=0.03\)), so the continuity-corrected \(\chi^2\) test — or an exact binomial test — gives \(p < 10^{-12}\) in every tabulated paired comparison: an honest, representable bound rather than a claim of exact zero. With \(b \gg c\) in every cell, the win is no coincidence. Appendix A backs this per cell:
| \(L\) | \(p\) | Learned bf [95% CI] | BW-naive bf [95% CI] | McNemar \((b,c)\) vs trivial | McNemar \((b,c)\) vs BP+OSD-0 | McNemar \((b,c)\) vs BW-naive |
|---|---|---|---|---|---|---|
| 3 | 0.03 | 0.306 [0.303, 0.308] | 0.391 [0.387, 0.394] | (53294, 1794) | (511, 99) | (12648, 2499) |
| 3 | 0.05 | 0.626 [0.624, 0.628] | 0.703 [0.699, 0.705] | (33405, 2079) | (499, 115) | (12663, 3470) |
| 4 | 0.03 | 0.343 [0.343, 0.344] | 0.682 [0.681, 0.685] | (69620, 1154) | (988, 257) | (43529, 2852) |
| 4 | 0.05 | 0.724 [0.720, 0.728] | 0.937 [0.936, 0.938] | (31555, 719) | (859, 146) | (26963, 1399) |
| 6 | 0.03 | 0.282 [0.272, 0.296] | 0.935 [0.934, 0.936] | (85691, 31) | (2067, 218) | (78726, 369) |
| 6 | 0.05 | 0.800 [0.796, 0.807] | 0.999 [0.999, 0.999] | (23950, 11) | (1108, 22) | (23854, 30) |
| 8 | 0.03 | 0.194 [0.183, 0.210] | 0.993 [0.992, 0.993] | (72574, 0) | (4067, 23) | — |
| 8 | 0.05 | 0.850 [0.842, 0.856] | 1.000 [1.000, 1.000] | (13485, 0) | (905, 0) | — |
| 10 | 0.03 | 0.118 [0.108, 0.134] | 1.000 [0.999, 1.000] | (79351, 0) | (792, 1) | — |
| 10 | 0.05 | 0.863 [0.851, 0.887] | 1.000 [1.000, 1.000] | (12337, 0) | (117, 0) | — |
The learned CIs sit entirely below the BW-naive CIs at every cell — the “beats BW-naive on block failure at every cell” claim made visible. And the \(c\)-counts vs trivial shrink toward zero as \(L\) grows (1794 at \(L=3,p=0.03\) down to 31 at \(L=6,p=0.03\), and exactly 0 at \(L=8,10\)): at large codes the learned decoder is almost never wrong on a shot where guessing all-zero would have been right.
Expected: that a flexible neural net beats vanilla BP+OSD on a code BP is bad at — that’s nearly the point of §5.3. Surprising and load-bearing: (a) the per-sector LER improving with size while everyone else worsens; (b) the global-pool head tying trivial to four decimal places, a clean demonstration that capacity alone is worthless without the right inductive bias; and (c) the Gate-0 oracle showing the local signal essentially gone by \(L=4\) while the net keeps winning, pinning the win on non-local structure. Those three together are what make this more than “we trained a CNN and it did okay.”
Follow the chain back: we wanted a quantum memory; that demanded error correction; correction is defined by the syndrome, which demands a decoder; the standard decoders rely on geometric assumptions (string-joined defect pairs; loop-sparse checks) that the X-cube code violates by its very nature; that nature — logical information carried on non-local lines — both defeats the old tools and suggests the new one; a network shaped like those lines is the answer; and the evidence shows it not only wins but scales, for a reason two controls isolate. The one-sentence summary you were not given at the top is now something you can see is true:
Tutorial generated as a companion to main.tex in this directory. All numerical values are taken verbatim from the paper’s Table 1, Table 2, and the JSON outputs in data/ (xcube_L346_gen.json, xcube_L810_gen.json, xcube_L4_psweep.json) per REPRODUCIBILITY.md. No results were invented.