Experimental Quantum Error Correction Below Threshold

Introduction

When Harvard’s neutral-atom team quietly dropped their new paper on a fault-tolerant architecture for universal quantum computation, a few days ago, it felt like the field had crossed an invisible line. For years we’ve had impressive pieces of the puzzle – better qubits here, a clever code there, some elegant theory everywhere – but Lukin’s group managed to put all of the core ingredients of scalable fault-tolerant computing into a single, working neutral-atom processor. They demonstrated below-threshold surface-code style error correction, transversal logical gates, teleportation-based universality, mid-circuit qubit reuse, and constant-entropy deep circuits on a 448-atom platform.

In practical terms, this isn’t “just another hardware paper”; it’s a concrete proof that a real device can behave like the textbooks say a fault-tolerant architecture should.

That’s why, in my write-up, I framed Harvard’s result as more than a neutral-atom story. It’s a validation of a capability that I keep coming back to in my work: the ability to operate below the error-correction threshold, where adding more qubits to a code actually reduces the logical error rate instead of making it worse. Once a platform crosses that line, you’re no longer playing in the NISQ sandbox – you’ve entered the phase where error correction is structurally on your side, and scaling the machine pushes you toward algorithmically relevant error rates, not away from them.

In my “Below-Threshold Quantum Error Correction” article, I argued that this regime is one of the most important qualitative transitions in the path to practical quantum computers. It’s not just another percentage point of gate fidelity; it’s a change in how the system scales. And in my “Path to CRQC / Predicting Q-Day” methodology, below-threshold operation is a dedicated capability axis alongside things like logical qubit capacity, logical operations budget, connectivity, decoding throughput, and stability. A platform that hasn’t yet shown below-threshold behavior is, in that framework, still fundamentally pre-CRQC, no matter how many physical qubits or how glossy the marketing.

Because of that, I think it’s worth stepping back and looking systematically at where and how this capability has actually been demonstrated. Harvard’s neutral-atom processor is one very visible milestone, but it stands on the shoulders of a sequence of key experiments across different platforms:

• bosonic cat codes pushing past break-even in superconducting cavities,
• early surface-code scaling results on superconducting qubits,
• trapped-ion demonstrations where fault-tolerant logical operations beat the underlying physical gates,
• and most recently, trapped-ion code-switching schemes that generate logical magic states with error rates lower than any native gate.

So I’ll walk through a curated list of those experiments over the last few years. The goal isn’t to be exhaustive, but to highlight where the field has actually crossed – or at least brushed against – the threshold line in hardware. If we care about forecasting cryptographically relevant quantum computers and Q-Day timelines, these are the data points that matter most: not just qubit counts or benchmark games, but concrete demonstrations that error correction is finally doing what it was promised to do.

Superconducting Qubits – Surface/Repetition Codes

Google Quantum AI (Acharya et al., Nature 2024): Demonstrated a surface code memory operating below threshold using distance-5 and distance-7 codes on a 72- and 105-qubit superconducting processor. One logical qubit was encoded into 49 data qubits plus ancillas (distance 7), with repeated cycles of error detection and real-time decoding. They observed error suppression: the logical error per cycle decreased as code distance increased, achieving an error suppression factor Λ > 2 (logical error reduced by >2× when increasing distance from 5 to 7). Notably, the distance-7 logical qubit’s lifetime exceeded that of the best single physical qubit by over 2×, marking the first clear below-threshold operation in a surface code. This experiment integrated fast feedback decoding and leakage removal, underscoring a significant step toward fault-tolerant superconducting qubit quantum computers.

(For more see my analysis: Google AI’s Surface Code Breaks the Quantum Error Threshold)

Google Quantum AI (Chen et al., Nature 2021): Implemented 1D repetition codes (a simplified QEC code) on a 2D superconducting qubit array, achieving exponential suppression of bit-flip and phase-flip errors with increasing code length. A logical qubit was encoded across up to 21 physical qubits (distance-11 repetition code), and by increasing from 5 to 21 qubits (distance 3 to 11) they reduced the logical error per cycle by over 100×. Crucially, this error suppression held steady over 50 repeated QEC cycles, indicating the physical error rates were below the repetition code threshold. This was one of the first demonstrations that scaling up a code can actively reduce logical error rates in real time, validating the below-threshold regime for specific error types on Google’s superconducting platform.

IBM/ETH Zurich (Krinner et al., Nature 2022): Realized repeated QEC on a distance-3 surface code (17 superconducting qubits encoding one logical) with a 1.1 µs cycle time. They preserved logical states through multiple rounds, correcting both bit-flip and phase-flip errors. The experiment achieved a logical error probability of ~3% per cycle (with heralded leakage removal). While this logical error rate was still on the order of – or slightly above – the best physical qubit errors, it showed that all components (gates, readout, etc.) were near the threshold. The stability of the logical error over repeated cycles and agreement with a simple error model were important evidence that the surface-code QEC was operating in a near-threshold regime. This was a milestone for IBM’s heavy-hexagon qubit architecture, implementing fast, repeated QEC and informing improvements needed to firmly enter the below-threshold zone.

Bosonic Qubits in Superconducting Circuits

Yale (Ofek et al., Nature 2016): Achieved the first QEC “break-even” point using a bosonic cat code in a 3D superconducting cavity. A single logical qubit was encoded in superpositions of coherent states (“cat” states) of a microwave resonator, with an ancilla transmon qubit to detect and correct single-photon loss errors. Using continuous error monitoring and feedback, they extended the logical qubit lifetime to 320 µs, slightly longer than the best physical qubit in the system (the cavity’s fundamental mode). This 1.1× improvement beyond the longest-lived component was the first time any QEC system exceeded the performance of an uncorrected qubit, heralding true below-threshold QEC. It required real-time decoding of photon-loss syndrome measurements and demonstrated the power of hardware-efficient encodings.

Yale (Sivak et al., Nature 2023): Demonstrated a fully stabilized logical qubit with an autonomous cat code that achieved a 2.3× coherence time gain over the best component qubit. Here a single logical qubit was encoded in an oscillator (a cavity mode) and actively error-corrected in real time using a transmon and custom feedback. They reported a “coherence gain” $$G=2.27\pm0.07$$ – meaning the logical qubit’s coherence time was about 2.3 times longer than even the best underlying physical qubit (the cavity without correction). This clear below-threshold operation was achieved through innovations in cavity fabrication (improving base coherence) and machine-learning-optimized control for error correction. The team also ran the QEC cycle indefinitely, showing the system could remove entropy faster than it accrued, a key hallmark of below-threshold QEC.

SUSTech (Ni et al., Nature 2023): Achieved beyond break-even QEC using a discrete-variable bosonic code. They encoded a logical qubit in a microwave cavity using a binomial code (a finite superposition of Fock states) coupled to a transmon, and repeatedly corrected photon-loss errors. The logical qubit’s lifetime was 16% longer than the best uncorrected qubit (exceeding the break-even point). In practice this was about a 1.16× lifetime improvement via QEC. They also maintained this advantage while performing real-time syndrome extraction and feedback. The code used 1 cavity + 1 ancilla qubit (so one logical from effectively two physical resonant modes) and corrected single energy quantum losses. This experiment, on a platform in China, illustrated that hardware-efficient bosonic QEC can reach the below-threshold regime without a large overhead, complementing the cat-code approach with a more discrete encoding.

Tsinghua/Yale (Hu et al., Nature Physics 2019): Demonstrated universal operations on a logical qubit encoded in a binomial bosonic code, with QEC that approached the break-even point. They used a circuit QED system (3D cavity + transmon) to encode a logical qubit in a four-component binomial codeword. Repetitive QEC cycles prolonged the logical qubit’s lifetime to about 2.8× that of an uncorrected logical qubit (i.e. if left idle without correction). While this fell just short of exceeding the best physical qubit’s T1, it came very close to break-even. Importantly, they also demonstrated high-fidelity logical gates (~97% fidelity) on the encoded qubit while QEC was running. This was the first instance of a universal gate set on an error-corrected logical qubit, showing that one can perform logical operations below the error threshold of the physical gates. It set the stage for later bosonic experiments that would fully cross the threshold.

(Another notable bosonic-code experiment is the autonomous QEC by Gertler et al. 2021, which used engineered dissipation to protect a cat-code qubit. While it did not surpass the best physical qubit’s lifetime, it showed error suppression without explicit feedback.)

Trapped-Ion Qubits – Multi-Qubit Codes

IonQ/University of Maryland (Egan et al., Nature 2021): Implemented a fault-tolerant QEC on a Bacon–Shor code using 13 trapped-ion qubits, achieving logical operation fidelities below the physical error rates. The [[9,1,3]] Bacon-Shor code (9 data + 4 ancilla for syndrome) can correct any single-qubit error. They designed fault-tolerant circuits for logical state prep, measurement, and a logical Clifford gate. The logical error rates for these operations were significantly lower than naive (non-FT) implementations – e.g. logical state prep/measure error ~0.6% and logical Clifford gate error ~0.3%. For comparison, physical two-qubit gate errors in the system were on the order of 1%, so the encoded operations outperformed a single physical gate. They also prepared logical “magic” states (for T-gates) with fidelity above the distillation threshold (~99% fidelity). Although repeated cycles were not done (correction was applied after the circuits), this was a key below-threshold demonstration: using fault-tolerant design, the logical qubit’s operations had lower error rates than the underlying physical operations, a necessary condition for scalable quantum computing.

Honeywell/Quantinuum (Ryan-Anderson et al., PRX 2021): Demonstrated real-time QEC on a trapped-ion system, encoding a logical qubit in the 7-qubit Steane code and performing repeated syndrome extraction. This was one of the first ion-trap experiments with mid-circuit measurements and feedback. They reported a lower logical error rate when running fault-tolerant syndrome extraction versus without it, indicating they were operating at or below the code’s threshold. (Detailed performance figures were reported in PRX; e.g. a logical T2 about twice the physical T2.) This showed that even with a modest ion chain and physical gate errors ~1e-3, real-time QEC could improve qubit fidelity. It validated the feasibility of fast feedback in trapped ions and informed the design of Quantinuum’s next-generation systems.

University of Innsbruck (Postler et al., Nature 2022): Demonstrated a universal fault-tolerant gate set on two logical qubits encoded in the 7-qubit color code (a.k.a. Steane code) using 14 trapped ions. They performed a fault-tolerant logical CNOT between two logical qubits, as well as state preparation and a magic-state injection (logical T-gate) via teleportation. Crucially, the fault-tolerant logic outperformed non-FT implementations: the logical two-qubit gate and T-gate had higher fidelity (by a clear margin) than if the same operations were attempted without the QEC encoding. Although the raw logical error was a few percent, it was lower than the physical two-qubit error rate, confirming below-threshold behavior. This was the first time an entangling gate between two logical qubits was realized fault-tolerantly. Along with parallel work on repeated QEC cycles, it marked a comprehensive demonstration of two-logical-qubit quantum computing with all components (gates and memory) at or below threshold.

Quantinuum (Dasu et al., arXiv Feb 2025): Reported a fault-tolerant non-Clifford gate on an ion-trap system using only 8 physical qubits. They prepared two logical qubits encoded in a compact [[6,2,2]] error-detecting code (6 physical qubits encoding 2 logical, distance-2) with two ancilla (“flag”) qubits for verification. Using a zero-overhead magic state injection approach, they implemented a controlled-Hadamard (CH) gate between the two logical qubits. The resulting logical CH gate had an error rate ≤2.3×10⁻⁴, significantly better than the ~1×10⁻³ error of an unencoded physical CH gate on the same hardware. This is a clear example of a logical operation outperforming its physical counterpart – a “break-even” non-Clifford gate. The scheme leveraged post-selected ancilla checks (discarding ~15% of runs) to ensure errors didn’t propagate. This experiment, done on Quantinuum’s H1-1 ion processor, introduced a low-overhead path to below-threshold logical gates using flag qubits and illustrated an approach to scale magic-state factories more efficiently.

Quantinuum (Daguerre et al., arXiv July 2025): Demonstrated high-fidelity logical magic state generation via code switching on a trapped-ion system. They first prepared a logical qubit in a 15-qubit Reed–Muller code (a type of color code allowing a transversal T-gate), then switched to the 7-qubit Steane code, yielding a logical “T-state” encoded in Steane’s code. This two-step encoding (using 28 physical ions for a single logical during the process) produced a logical magic state with infidelity ≤5.1×10⁻⁴ – about 2.9× lower error than the best physical two-qubit gate in the system. In other words, the logical state’s error probability was well below the native physical error rate, indicating the processor is operating below the pseudo-threshold for this non-Clifford operation. They verified the state’s fidelity rigorously, including a two-copy entanglement test on 56 qubits. This is notable as it effectively realizes a fault-tolerant magic state factory: combining this with previously demonstrated fault-tolerant Clifford operations on the same 2D color code platform yields a complete set of computational primitives with logical error rates better than physical. The work used Quantinuum’s H2-1 ion trap and highlights code-switching as a viable route to below-threshold universal quantum computing with fewer qubits than a single high-distance code.

(My analysis of these last two Quantinuum papers is here: Quantinuum’s Breakthrough Sets Course for Fault-Tolerant Quantum Computing by 2029)

Solid-State Spin Qubits (NV Centers)

Delft University (Abobeih et al., Nature 2022): Demonstrated fault-tolerant operations on a logical qubit encoded in a five-qubit code using spin qubits in diamond. They used a seven-qubit register (NV center electron spin plus six nuclear spins) to implement a distance-3 [[5,1,3]] code with one additional “flag” qubit for fault tolerance. Repeated stabilizer measurements with real-time feedforward were performed, marking one of the first multi-round QEC experiments in a solid-state spin system. The logical qubit was initialized and manipulated with fault-tolerant protocols, and they observed that error syndromes could be reliably identified without disturbing the logical state. While the logical error rates were still limited by slow gate times (hundreds of microseconds) and dephasing in the nuclear spin network, the experiment proved that fault-tolerant QEC is feasible in a small-scale NV-center quantum processor. It laid the groundwork for boosting logical performance in spin qubits, with the team aiming to eventually show exponential error suppression by scaling up the code distance. (Indeed, the concepts of flag qubits and real-time syndrome correction developed here are expected to help reach below-threshold operation as the hardware improves.)

In summary, across a variety of platforms – superconducting circuits, bosonic modes, trapped ions, and even solid-state spins – researchers have begun to cross the error-correction threshold. Evidence includes longer logical lifetimes than any single qubit (break-even), logical error rates dropping with increased code distance, and logical operations (memory and gates) outperforming their physical counterparts.

These achievements employ diverse QEC codes (surface and color codes, repetition codes, bosonic cat and binomial codes, Bacon-Shor and small CSS codes) but all show the hallmark of below-threshold QEC: scaling up the encoded system yields a net reduction in error. Each represents a notable innovation – from real-time decoding and flag qubits to code switching – and together they signify that the field has entered the regime where quantum error correction truly extends and enhances quantum information, rather than merely signaling errors.