Role of QEC in Fault-Tolerant Quantum Computing

Why Quantum Computers Need Error Correction to Succeed Introduction: Power Meets Fragility Quantum computers promise breakthroughs in cryptography, drug discovery, and complex simulations far beyond classical capabilities. But there’s a catch: today’s quantum machines are extremely prone to errors. Unlike classical bits, quantum bits—or qubits—are affected by even the tiniest disturbances in their environment. This fragility threatens to undermine the power of quantum computing unless a robust solution is implemented. What Is Quantum Error Correction (QEC)? • Error rates in perspective: • Classical bits have error rates near 1 in 1 trillion. • Qubits, by contrast, can fail as often as 1 in 1,000 operations. • Without correction, these errors render large-scale quantum computations practically unusable. • How QEC works: • QEC does not directly repair faulty qubits. • Instead, it spreads quantum information across multiple physical qubits, creating a logical qubit protected by redundancy. • When an error occurs, algorithms identify and correct it without directly measuring the quantum data (which would collapse the quantum state). • Unique challenges: • Quantum mechanics forbids copying unknown quantum states (no-cloning theorem). • QEC must detect and fix errors indirectly, using entanglement and careful circuit design. • Correcting both bit-flip and phase-flip errors requires layered strategies that are computationally intensive. Why QEC Is Crucial • Scalability: • To solve meaningful real-world problems, quantum computers must scale from 100s to millions of qubits. • That’s only possible with robust error correction to manage fault tolerance. • Longevity of quantum states: • Quantum decoherence—the loss of information over time—limits the duration of computations. • QEC helps extend coherence times, enabling deeper quantum algorithms to run successfully. • Toward “quantum advantage”: • To outperform classical supercomputers at useful tasks, quantum systems must process longer and more complex instructions without breaking down. • QEC is the bridge to achieving true quantum advantage in practical settings. Conclusion: The Road to Reliable Quantum Computing Quantum error correction is not just a technical detail—it’s the foundation on which the future of quantum computing rests. Without it, today’s fragile machines will never evolve into tomorrow’s powerful problem-solvers. With it, we edge closer to unlocking a new era of computation. Keith King https://lnkd.in/gHPvUttw

Today, I'd like to highlight an often overlooked, yet essential aspect of the Google Willow experiment: the repeatability of error correction cycles. What is this exactly? Well, because errors are happening constantly during a computation, error correction must run constantly too. Some even say that the art of fault-tolerant quantum computing is to squeeze useful operations between quantum error correction cycles. An error correction cycle is a series of operations aimed at detecting and correcting errors: - You perform a bunch of gates (usually CNOTs) between the qubits carrying your data and a set of "auxiliary" qubits - You measure your auxiliary qubits - You use the result to guess which data qubits (if any) experienced an error Interestingly, an error correction cycle doesn't always include actually correcting errors when they are detected. Knowing what errors happened may be enough, and you may just post-process the results of your circuit using the output of error correction cycles. What happens when repeating error correction cycles is well illustrated in the graph below, taken from Google's latest paper. There's a lot to unpack here, so let's explain. Each point in this graph corresponds to 10^5 repetitions of an experiment where: - A logical state is prepared - t error correction cycles are applied and their results are stored - The logical state is measured - Using all the measurements above, the authors try to guess what was the initial logical state Usually, half of the experiments are done in the Z basis (prepare |0>, measure Z) and half in the X basis (prepare |+>, measure X). When the state is not successfully retrieved, this counts as an error. The error rate then determines how high the point is. As can be expected, the more error correction cycles you apply, the less likely you are to retrieve the initial state at the end of the experiment. Each cycle misses some of the errors and this effect only compounds. You can however see that using a long distance for their error correction code (dark blue curve), Google is able to retrieve the initial state with a higher probability than by simply letting their best physical qubit decohere (green curve). To the best of my knowledge, no experiments run on neutral atoms or trapped ions have been able to repeat error correction cycles like Google just did here. They did show one, maybe a handful of repetitions, but not hundreds like in the graph below. As I understand it, this is because on these platforms, it is hard to immediately reuse an auxillary qubit after it has been measured. This is a challenge they will have to overcome if they wish to run the deep circuits for which we need fault-tolerant quantum computers. Of course, superconducting circuits will also have challenges of their own. But repeating error correction cycles doesn't seem to be one, and I hope you now understand how Google brilliantly showed it.

Over the last few weeks, the quantum timeline has been crowded with big headlines: Quantinuum’s Helios launch, IBM’s new Loon and Nighthawk processors, and a steady stream of new “record” benchmarks and roadmaps. In that flood of news, one announcement from Harvard flew a bit under the radar - and it arguably deserves as much attention as any of them. Lukin’s group has just published a Nature paper describing “a fault-tolerant neutral-atom architecture for universal quantum computation”. In practice, they show a reconfigurable neutral-atom processor that brings together the key building blocks of scalable fault tolerance: below-threshold surface-code style error correction, transversal logical gates, teleportation-based logical rotations, mid-circuit qubit reuse, and deep logical circuits that are explicitly engineered to keep entropy under control. I’ve broken down what they achieved, how it compares to other platforms, and why I think this is a genuine inflection point for neutral atoms and for fault tolerance more broadly: https://lnkd.in/gqnYdPXQ This also ties directly into something I’ve been arguing for years in my Path to CRQC / Q-Day methodology: operating below the error-correction threshold is not a nice-to-have, it’s a capability in its own right – the tipping point where adding more qubits and more code distance finally starts to reduce logical error, instead of making things worse. Motivated by the Harvard result, I’ve also published a companion piece that walks through some of the most important below-threshold QEC experiments across platforms – bosonic cat codes, trapped-ion Bacon–Shor and color codes, superconducting surface codes, and now neutral atoms: https://lnkd.in/gvJDNhgm If you’re trying to separate marketing noise from genuine progress toward fault-tolerant, cryptographically relevant quantum computers, these are the kinds of milestones worth tracking. My analysis of the Harvard announcement is here: https://lnkd.in/gqnYdPXQ #Quantum #QuantumComputing #QEC

Everyone agrees quantum error correction (QEC) is essential. But why do we care so much about things like ≤ 𝟬.𝟭% 𝗴𝗮𝘁𝗲 𝗲𝗿𝗿𝗼𝗿 or µ𝘀-𝘀𝗰𝗮𝗹𝗲 𝗱𝗲𝗰𝗼𝗱𝗲𝗿 𝗹𝗮𝘁𝗲𝗻𝗰𝘆? Here’s the core idea: QEC combines many noisy qubits into a more stable 𝘭𝘰𝘨𝘪𝘤𝘢𝘭 qubit. If your hardware is good enough, you can reduce error rates 𝗲𝘅𝗽𝗼𝗻𝗲𝗻𝘁𝗶𝗮𝗹𝗹𝘆 by increasing code size. But that only works if your system can keep up—𝗱𝗲𝗰𝗼𝗱𝗶𝗻𝗴 𝗲𝗿𝗿𝗼𝗿𝘀 𝗮𝗻𝗱 𝗿𝗲𝗮𝗰𝘁𝗶𝗻𝗴 𝗺𝗶𝗱-𝗰𝗶𝗿𝗰𝘂𝗶𝘁, fast. Especially for circuits with non-Clifford gates (like T-gates), you need real-time feedback between measurements and feedforward operations. That’s where the hardware starts to feel the pressure: • Gate fidelity ≤ 𝟬.𝟭% • Decoder latency ≤ 𝟭𝟱 µ𝘀 • Controller-Decoder Communication ≤ 𝟭𝟬 µ𝘀 • Bandwidth ≥ 𝟭 𝗠𝗯𝗶𝘁/𝘀 𝗽𝗲𝗿 𝗾𝘂𝗯𝗶𝘁 These aren’t wishful targets. They come from full-stack simulations of real quantum circuits, like Shor’s algorithm for factoring 21 using surface codes. In those simulations, the system must handle: • ~13 decoding tasks • ~5 mid-circuit corrections • ~1000 physical qubits    That’s the blueprint. It doesn’t just explain 𝘸𝘩𝘺 QEC is hard—it points us toward what needs to work for it to succeed at scale. Image Credits: Yaniv Kurman et al. (2024, arXiv)

New work from a Harvard team highlights a major bottleneck in fault-tolerant quantum computing: the classical decoder used in quantum error correction. Quick primer on QEC: 1. Encode: A logical qubit is spread across many physical qubits, so no single error destroys the information. 2. Detect: Stabilizer measurements run repeatedly. They do not reveal the quantum state, but they do flag when something has gone wrong. The pattern of those flags is called the syndrome. 3. Decode: A classical computer reads the syndrome and infers which error most likely occurred. 4. Correct: The correction is applied, and the logical qubit survives. Step 3 is where things get hard. For quantum LDPC codes, one of the most promising routes to efficient fault tolerance, practical decoders have usually forced a tradeoff between speed and accuracy: the fast ones are too weak, and the accurate ones are too slow for real-time use. This paper introduces Cascade, a geometry-aware convolutional neural decoder. The key idea is not just “use a neural network,” but to build the structure of the code directly into the model: locality, translation equivariance, and anisotropy. That makes this feel less like generic ML and more like architecture co-design. Some of the headline results: - On the [[144, 12, 12]] Gross code, Cascade achieves logical error rates up to 17x lower than prior practical decoders, with 3–5 orders of magnitude higher throughput - It reveals a “waterfall” regime in which logical errors fall much faster than standard distance-based formulas would suggest, largely because earlier decoders were not strong enough to expose it - In one surface code example, that translates to roughly 40% fewer physical qubits to reach a target logical error rate of 10^-9 - Its confidence estimates are well calibrated, which enables post-selection. In one setting on the [[72, 12, 6]] code, that implies roughly 20x fewer retries for repeat-until-success protocols such as magic state distillation - Current GPU latencies already fit the timing budgets for trapped-ion and neutral-atom platforms. Superconducting qubits still require a tighter ~1 microsecond budget, with FPGA and ASIC paths supported by the hardware estimates in the supplement The broader takeaway: decoder quality is not just an implementation detail. It directly shapes how many qubits and how much time fault-tolerant quantum computing actually requires, and those costs may be meaningfully lower than standard estimates assume. Paper: https://lnkd.in/g9D82Ry8

The real significance of Google's Willow quantum chip... Fundamentally, building quantum computers (QC) is about achieving low operation errors. Sure, other metrics matter too, but the error rate is the big one. If you look at the landscape of QC applications, many of them require *ridiculously* low error rates - say 1 error in 10^12 operations or less. Nobody thinks this can be achieved through hardware engineering alone - this needs quantum error correction (QEC) for sure. But should we be confident that QEC will actually work? Sure, it will work to some extent - but can it work well enough to reach error rates as low as 1e-12 or less? QEC makes non-trivial assumptions about the nature of the physical errors which are never quite true, and deviations from those assumptions could plausibly derail QEC by setting a "logical noise floor" - an error rate below which QEC ceases to work. The previous most thorough search for the logical noise floor in QEC was performed by Google in 2023. At that time, they found that QEC ceases to work at a rather high error rate of 1e-6. This was due to high-energy cosmic rays hitting their qubit chips, causing large-scale correlated errors which cannot be taken out by QEC. That's a *big* issue! Google latest chip incorporates design changes to make it immune to cosmic ray errors. After incorporating those changes, the logical noise floor search was repeated and reported in the recent paper. It turns out the mitigation work, and the logical noise floor was pushed all the way down to a new record of 1e-10, i.e. 1 error per 10^10 operations! This is the most convincing evidence to date that - in a well-engineered QC - QEC is actually capable of pushing the error rates down to levels compatible with most known QC applications. To me, this repetition-code is actually the most important finding reported in Google's paper! Funnily enough, Google's team reports that they actually don't know where this error may be coming from. Error rates this low are also really challenging to study, because it can take considerable data acquisition time to establish meaningful statistics. But I'm sure they'll figure it out soon enough... 😇