What is a “logical-qubit demonstration” and how do you compare vendors?

TL;DR (status as of October 21, 2026): As of October 21, 2026, a “logical-qubit demonstration” is not one standardized measurement: the ten rows in the public record that Rosetta Quantum lines up below — eight hardware demos, one simulation and one roadmap — report their headline numbers per QEC cycle, per logical Clifford gate, per circuit or per state preparation, with decoders that range from real-time to fully offline and with discard rates that range from zero to more than 96%. Zero pairs of those headline numbers share the same unit, the same decoder mode and the same discard rules at once, so none of them can be ranked against another without re-deriving both. The freshest row is two days old: on October 19, 2026 Quantinuum reported a color-code logical error rate its paper states as 5×10⁻⁶ per syndrome cycle at distance 7 (Quantinuum paper, fetched 2026-10-21) — with every decode in that experiment run offline.

What counts as a “logical-qubit demonstration”?

Any experiment in which several physical qubits are operated as one encoded qubit, and the encoded error rate is compared against something — that comparison target is the first thing that varies. Rosetta Quantum covered the definition of a logical qubit and why the physical-to-logical ratio drives every fault-tolerance timeline in a dedicated entry; the short version is that an error-correcting code spreads one qubit of information across many noisy ones, and a decoder — a classical algorithm, covered here — turns the measured syndromes into corrections. A “demonstration” is any dated experiment on that stack. What it is not is a standardized benchmark: there is no agreed unit, no agreed decoder setting, no agreed rule on discarding runs, and no external referee. Each vendor picks its own ruler, measures honestly against it, and publishes a number that reads like a world record in a sport only that vendor plays.

That is not an accusation. Every row below is, as far as the public record shows, a real measurement (or is labeled as a simulation or a plan where it is one). The problem is structural: the same word — “demonstrated” — covers an idling memory patch, an entangled 24-qubit cat state, a randomized-benchmarking run of Clifford gates, and a circuit-level noise simulation with no hardware in it.

What did each vendor actually demonstrate?

The table is the answer. Dates are the dates of the primary source; where Rosetta verified a number in an earlier run and re-used it today, the row says so.

Three honesty notes on the table. First, the two “2:1” rows are not the same kind of fact: the iceberg 2:1 ran on hardware and paid for its ratio with discard rates above 96% (our Oct 16 verification), while the qLDPC 2:1 is a circuit-level simulation whose own authors state that “additional development is required to implement the full set of fault-tolerant logical gates” (QCR, 20-Apr-2026). Second, the Microsoft–Atom row contains a number its own source does not explain: the detect-only configuration (10.2%) outperformed the detect-and-correct configuration (26.6%) against the same 42% physical baseline (Azure blog, 19-Nov-2024) — we print both, in that order. Third, no row in this table demonstrates non-Clifford logical gates at its headline error rate: the Helix entry explicitly did not (arXiv:2609.03194), and the color-code entry is memory plus Clifford randomized benchmarking (Quantinuum paper). The computation everyone is buying error correction for sits outside every headline here.

Why can the headline numbers not be compared?

Because at least six dials differ between any two rows, and each dial moves the number by more than the gap being advertised.

The unit. Google’s 0.143% is per QEC cycle of an idling memory (arXiv:2408.13687); Helix’s 2.8×10⁻⁴ is per logical Clifford gate in randomized benchmarking (arXiv:2609.03194); the tesseract 0.001% is per Bell-state circuit (Nature, jun-2026); Atom’s 10.2% is per 24-qubit GHZ preparation (Azure blog). A cycle, a gate, a circuit and a state preparation are four different exposure times to noise. Dividing one by another is not a conversion; it is a new experiment.

The decoder, and when it runs. The number depends on which classical algorithm reads the syndromes and whether it runs inside the hardware deadline or afterwards on saved data. Rosetta measured this dial in its decoder entry: in Google’s own distance-5 data, the real-time decoder returned 0.35% per cycle and the offline most-accurate decoder 0.269% — same chip, same shots, different number (our Oct 19 verification of arXiv:2408.13687). The new color-code result states its Λ = 12 “using Tesseract” — an offline decoder — and every decode in the experiment was offline (Quantinuum paper).

The discards. Detection-based schemes reach low error rates by throwing away flagged runs. The iceberg demos discarded more than 96% of shots (our Oct 16 verification); the tesseract results “discard corrupted traces” via postselection (QCR, 12-Jun-2026); Helix improves from 4.6×10⁻⁵ to 1.9×10⁻⁵ per cycle when 0.5% of shots are postselected out (arXiv:2609.03194). A number with discards and a number without them are not the same quantity, and most headlines do not say which they are.

The state being protected. Idling memory (Google, color code), entangled states (Atom, Harvard), benchmarking circuits (Helix), small algorithms (Atom’s 28-logical-qubit Bernstein–Vazirani on 112 physical qubits, Azure blog). Error rates do not transfer across these workloads.

Hardware versus simulation versus plan. One row is a simulation at an assumed physical error rate of 0.1% (arXiv:2604.16209); one row will exist in 2029 if IBM’s roadmap holds (IBM roadmap). Both are legitimate publications; neither is a demonstration in the hardware sense, and we mark them accordingly.

The baseline. “Better than physical” divides by each platform’s own physical error rate — 42% for Atom’s GHZ baseline, 1.2×10⁻³ for Quantinuum’s two-qubit gates. The same word, three orders of magnitude apart. Even the two error-suppression factors in the table — Λ = 2.14 ± 0.02 (Google surface code) and Λ = 12(+3/−2) (Quantinuum color code) — are measured on different codes, different noise floors and different decoders; both are real, and the single number that would let a buyer rank them, a time-to-solution ratio at equal budget on the same task, exists for neither, because that is not what memory experiments measure. Who is ahead on raw hardware is a different question, mapped here.

What changed this week, and what does the primary source say?

On October 19, 2026 Quantinuum announced a color-code result on Helios, and it is the clearest recent case for reading the paper instead of the press. The press framing reports “99.9995% fidelity”, “five errors per million operations”, a 10× reduction from the company’s September record, a claim of “100 times lower than the best published result” on other modalities, and “up to 37 physical qubits per logical qubit” (TQI, 19-Oct-2026, reporting the company release). The paper states the result as a logical error rate of 5(+4/−2)×10⁻⁶ per syndrome extraction cycle at distance 7, in memory experiments that used 13, 37 and 73 physical qubits at distances 3, 5 and 7, with Λ = 12(+3/−2) under the Tesseract decoder, and with all decoding performed offline (Quantinuum paper PDF, fetched 2026-10-21).

Two deltas matter. The unit: “per operation” and “per syndrome cycle” are different rulers, and the paper uses the second. The ratio: the distance-7 experiment that produces the headline number ran 73 physical qubits for one logical qubit; the press’s “up to 37” matches the distance-5 configuration, which has a higher error rate. When a press release and a paper from the same issuer differ, Rosetta prints both, attributed, and reads the paper as binding — the same rule we applied to IBM’s portfolio-optimization coverage one day earlier. None of this makes the result small: on its own ruler it is the lowest logical error rate in the public record, and the 12× suppression per distance step is, as far as our table shows, unmatched. It will become comparable to Google’s 0.143% the day someone publishes both under the same unit, the same decoder mode and the same discard accounting — which, as of October 21, 2026, nobody has.

What would a comparable demonstration look like?

It will exist when a demo states, in one table: the error rate per QEC cycle with no postselection; the same rate with postselection and the exact fraction discarded; the decoder used and whether it ran within the real-time budget of the hardware; the physical baseline on the same device; and the non-Clifford story, even if the entry is “none yet”. That is five declared dials, not a new benchmark suite — every row above already measured most of them and simply does not print them side by side. The harder upgrade is the referee: every number in our table was produced, decoded and scored by the team being measured. The quantum field has pre-registered benchmarks (QOBLIB) and now DARPA’s private stage-gated verification (the QBI), but no blind external judge for logical-qubit claims — the instrument that, as we argued for models, eliminates self-scoring. Until one exists, the honest reading of any logical-qubit headline will remain: one vendor, one ruler, one world record in a sport with one player.

What we don’t know

• Whether the color-code number survives real-time decoding. Every decode in the October 19 experiment was offline; the authors argue feasibility from decoder timings of a few hundred microseconds per round on an H100 GPU, and argument is not demonstration (Quantinuum paper).
• The physical-qubit count behind the 24-logical-qubit GHZ. The Azure post does not state it, so the table carries the ratio only for the Bernstein–Vazirani run (Azure blog, 19-Nov-2024).
• Why detect-only beat detect-and-correct in that same experiment. The source reports 10.2% versus 26.6% and does not explain the inversion; we print it without a theory.
• Whether any row generalizes to computation. No entry demonstrates non-Clifford logical gates at its headline error rate; fault-tolerant computation will also need magic-state distillation, and no row here touches it.
• Two numbers we did not re-verify today. The Bring’s-code row and the iceberg row come from our October 17 and October 16 verifications of their primary sources, re-used here and declared as such; the Google real-time-versus-offline pair (0.35% vs 0.269%) comes from our October 19 run.
• Our own “0”. The hero’s zero — no two headline numbers share unit, decoder mode and discard rules — is Rosetta’s reading of this table under those three declared criteria, not a community-agreed statistic. Add or remove criteria and the count changes; we chose the three that a buyer would need first.

Sources

• Google Quantum AI — Quantum error correction below the surface code threshold, arXiv:2408.13687 (Nature 638, 2024; re-verified 2026-10-21)
• Bluvstein et al. — Logical quantum processor based on reconfigurable atom arrays, arXiv:2312.03982 (Nature, DOI 10.1038/s41586-023-06927-3)
• Microsoft Azure Quantum blog — Microsoft and Atom Computing, 19-Nov-2024
• Quantum Computing Report — Microsoft and Quantinuum publish peer-reviewed QEC data in Nature, 12-Jun-2026 · the Nature paper
• Quantum Computing Report — QuEra, Harvard and MIT demonstrate 2:1 ratio, 20-Apr-2026 · arXiv:2604.16209
• Quantum Computing Report — Quantinuum demonstrates Helix on Helios, 9-Sep-2026 · arXiv:2609.03194
• Quantinuum — Quantum error correction well below the color code threshold (paper PDF) (fetched 2026-10-21)
• The Quantum Insider — Quantinuum reports a 10× reduction in logical error rate on Helios, 19-Oct-2026
• NVIDIA developer blog, 17-Nov-2025 (Bring’s code demo; verified in our Oct 17 run, anatomy here)
• IBM quantum roadmap (Starling, planned 2029)

Rosetta Quantum publishes verdicts with raw, reproducible data. This is educational content, not a product claim. Quantum, independently measured.