Quantum Code Distance Explained: 10 of 26 Papers Overestimated It — IBM's Real Distance Is 16, Not 18
Image: IBM Quantum System Two — the paper certifies IBM's two-gross memory circuits. Photo: Irekia / Eusko Jaurlaritza (Basque Government), via Wikimedia Commons, CC BY 4.0
📌 Key Highlights
- Researchers Bin Cheng, Naixu Guo and Feng Pan published "Certifying quantum code and circuit distances at scale" on arXiv on 5 November 2026 (arXiv:2611.08247).
- Their method certifies exact distances for codes with up to 31,200 qubits and memory circuits with up to 800,000 fault mechanisms.
- An audit of 26 recent papers found 10 contained overestimated distances or non-tight upper bounds; the largest gap was at least eight.
- IBM's two-gross memory circuits are certified at circuit distance 16 with the standard schedule — not the assumed 18. A redesigned schedule reaches 18 at the cost of one extra timestep per cycle.
- At 99.98% junction yield, keeping gross-code memory blocks with dead checks that are certified at distance 10 or more lifts the estimated usable share from 53% to 94%.
Quantum code distance explained: what the number actually means
Quantum error correction works by spreading one logical qubit — the unit of information a quantum computer actually computes with — across many physical qubits, so that errors on individual qubits can be detected and fixed. The code distance is the headline number for how well that protection works: it is the smallest number of physical errors that can change the encoded information without being caught. A distance-d code can correct any combination of up to (d−1)/2 errors, and below the error threshold its logical error rate falls roughly as p^(d/2), where p is the physical error rate. That is why distance guides code comparisons, schedule choices and resource estimates — it is the number every fault-tolerance roadmap is built on.
There is a catch, and it is the reason this paper exists. Code distance describes the code in the ideal. Circuit distance counts faults in the real syndrome-measurement circuit, where a single fault can spread onto several qubits. The two numbers can differ — and the circuit number is the one that matters in hardware. IBM's gross code, for example, has code distance 12 but circuit distance 10 with its standard schedule. Overestimating the circuit distance by two inflates the predicted exponent of p in the low-noise logical error rate, so the code looks much better on paper than it performs in a real machine. Riverlane's surface-code error correction work attacks the same problem from the decoding side, cutting logical errors by improving how syndromes are interpreted.
The audit: 10 of 26 papers overestimated their distances
Most published distances are only upper bounds produced by heuristic searches, not exact values. The new paper changes that. The authors express both code and circuit distances as tropical partition functions, then evaluate them with rank-based dynamic programming and weight-bounded search. Proved lower bounds, combined with explicit logical errors of matching weight, certify the exact values. Three algorithms — a dense rank-based dynamic program, a truncated program and a search — are coordinated by a cost model that predicts which one will be cheapest for each problem.
It is fast as well as exact: certifying a distance took under 10 seconds up to distance 25 on a single processing thread, while other general-purpose exact solvers stalled beyond distance 15. On two benchmarks the method certifies more instances than all other tested exact solvers combined. The scale is new too: distances certified for codes with up to 31,200 qubits, such as Google's modular hyperbolic codes, and for memory circuits with up to 800,000 fault mechanisms, such as high-rate Cornucopia codes.
Illustrative image: a Bloch sphere diagram of a qubit. Image: Smite-Meister, Wikimedia Commons, CC BY-SA 3.0
The audit itself covered 26 recent papers, using the instances the authors could reconstruct from published data or circuit files. In 10 of them, the reported distance was overestimated or the upper bound was not tight, with a maximum discrepancy of at least eight. One example: a [[200,24,14]] routing code with weight-11 checks has circuit distance 10 — four below its published upper bound. The authors are careful about what this does and does not mean: an overestimated upper bound is not necessarily a wrong result, but presenting an upper bound as an exact value invites misreading. Rydberg-atom error correction faces the same certification question on a different hardware platform. One honest caveat: the paper is a preprint, not yet peer-reviewed, and the audit is limited to cases the authors could reconstruct.
IBM's real distance is 16, not 18
The finding most likely to ripple through roadmaps concerns IBM's two-gross memory circuits — a widely studied system in the low-density parity-check (qLDPC) family. The numbers, before and after certification:
| Circuit | Published assumption | Certified distance | What changes |
|---|---|---|---|
| IBM two-gross memory circuits, standard schedule | 18 | 16 | The code protects against fewer errors than assumed |
| IBM two-gross memory circuits, redesigned schedule | — | 18 at one noisy cycle | Costs one more timestep per cycle |
| IBM gross code | Code distance 12 | Circuit distance 10 | Single faults spread across qubits in the circuit |
| [[200,24,14]] routing code | Upper bound 14 | 10 | Four below the published upper bound |
The IBM correction is a difference of two, but in error correction that is not a rounding error: every unit of distance changes the exponent of the logical error rate. The redesigned schedule that recovers 18 does so by adding one timestep per cycle — a real trade-off between speed and reliability, now priced honestly instead of assumed away.
Why it matters: chips, schedules and honest numbers
The most practical consequence is about chip yield. Fabricated quantum chips are never perfect: some checks are dead on arrival. Until now, the safe assumption was to use only perfect memory blocks. The certification shows that gross-code memory blocks with dead checks, certified at distance 10 or more, remain usable — and at 99.98% junction yield, keeping them lifts the estimated usable share from 53% for perfect blocks alone to 94% with an improved schedule. For a chipmaker, that is the difference between discarding nearly half of all fabricated memory blocks and keeping almost all of them.
For designers, certified distances turn schedule choices into engineering decisions with known costs: one extra timestep buys back two units of distance on IBM's two-gross circuits. And for the field as a whole, the audit is a reminder that roadmaps and resource estimates built on upper bounds are optimistic by an unknown amount. Verified claims matter across quantum research — from error correction to the recently settled Aaronson–Ambainis conjecture — and an independent certification method gives the field a way to check its own numbers instead of trusting them.
Should you care?
✅ Yes, if you follow quantum computing roadmaps or work on error correction — from now on, quote certified distances, not assumed ones, and expect IBM's and Google's published numbers to be re-checked against this method. ⏳ For everyone else, this is a methods paper, not a new computer — its effect shows up later, in more honest roadmaps and in cheaper quantum chips because fewer fabricated blocks are thrown away.
FAQs
What is quantum code distance?
It is the smallest number of physical errors that can change the encoded logical information without being detected. A higher distance means stronger error suppression: a distance-d code can correct any combination of up to (d−1)/2 errors, and its logical error rate falls roughly as p^(d/2) as physical errors shrink.
What is the difference between code distance and circuit distance?
Code distance describes the code itself in the ideal, while circuit distance counts faults in the actual measurement circuit, where a single fault can spread onto several qubits. Circuit distance can therefore be lower — IBM's gross code has code distance 12 but circuit distance 10 with its standard schedule — and it is the circuit number that predicts real hardware behaviour.
How many errors can a quantum code correct?
Any combination of up to (d−1)/2 errors, where d is the code distance. A distance-16 code, like IBM's certified two-gross circuits, corrects up to 7 errors; a distance-10 code corrects up to 4.
Why does code distance matter for fault-tolerant quantum computing?
Distance sets how fast logical errors fall as hardware improves, and it guides code comparisons, schedule choices and resource estimates. Overestimating it makes a machine look closer to fault tolerance than it really is — which is why an independent method that certifies exact distances matters.
Takeaway: Quantum error correction's headline numbers were, in 10 of 26 audited papers, upper bounds dressed as exact values. A fast certification method now exists to check them — and its first big correction is that IBM's two-gross circuits protect against 16 errors' worth of faults, not 18. The paper's full text is free on arXiv: if you build or study quantum error correction, check whether the distances your work relies on are certified or only upper bounds.
Comments
Post a Comment