Errors: The Central Challenge of Quantum Computing

The Bug You Cannot Catch

Software engineers understand bugs. A null pointer dereference crashes your process. A race condition produces wrong results intermittently. An off-by-one error shifts your array index. In every case, the bug is discrete: something is either right or wrong, and you can, in principle, find it, reproduce it, and fix it.

Quantum errors don’t work this way. Imagine debugging a system where every variable is simultaneously drifting in a random direction, where looking at a variable changes its value, where you cannot make a copy of the program state to examine it, and where the drift gets worse the longer your program runs. That’s quantum computing in 2025.

This is not an engineering problem that will be solved by better manufacturing, the way semiconductor defect rates dropped over decades. The source of quantum errors is physics itself: the unavoidable interaction between quantum states and their environment. The strategies for managing these errors define the entire architecture of quantum computing and determine its practical timeline.

The Three Sources of Quantum Error

Decoherence: The Clock Is Always Ticking

A qubit’s quantum state is fragile. It exists in superposition, holding information about both 0 and 1 simultaneously, along with the precise phase relationship between them. Any interaction with the environment, a stray photon, a thermal vibration, an electromagnetic fluctuation, disturbs this state.

Two types of decoherence matter. T1 relaxation is energy decay: the qubit spontaneously falls from its excited state to its ground state, like a ball rolling downhill. T2 dephasing is the loss of phase information: even if the qubit stays in superposition, the precise relationship between its 0 and 1 components gets scrambled by environmental noise.

The numbers are stark. Superconducting qubits: T1 times of 100-300 microseconds, T2 times of 50-200 microseconds. Trapped ions: T1 times of seconds to minutes, T2 times of seconds (with dynamical decoupling techniques extending this further). Neutral atoms: coherence times of 1-10 seconds depending on the atomic species and encoding.

These numbers define a computational budget. If your two-qubit gate takes 200 nanoseconds (superconducting) and your coherence time is 100 microseconds, you can execute roughly 500 gates before decoherence destroys your computation. That’s your circuit depth limit. Anything deeper than that is noise, not signal.

Gate Infidelity: Every Operation Introduces Error

Even within the coherence window, every gate operation on a qubit introduces a small error. The gate doesn’t perform exactly the rotation it’s supposed to. The error is small, typically 0.1% to 1% for two-qubit gates, but it compounds.

If each gate has 99.5% fidelity (0.5% error rate), a circuit with 200 two-qubit gates has an expected fidelity of roughly 0.995^200 = 0.37. That means the correct answer appears only 37% of the time. With 500 gates: 0.995^500 = 0.08. The signal is gone.

This arithmetic is relentless. It doesn’t matter how clever your algorithm is. If the circuit depth exceeds what the error rates allow, the computation returns noise. The phrase “quantum volume” (discussed in Chapter 7) attempts to capture this tradeoff between qubit count and gate fidelity, but the underlying constraint is simple multiplication.

Current state-of-the-art two-qubit gate fidelities:

• Superconducting (IBM, Google): 99.0-99.5%
• Trapped ion (Quantinuum, IonQ): 99.5-99.9%
• Neutral atom (QuEra, Pasqal, Atom Computing): 99.0-99.5%

These numbers improve every year, but the improvement is incremental: going from 99.5% to 99.9% is a 5x reduction in error rate, and going from 99.9% to 99.99% (four nines) has not been reliably achieved on any multi-qubit platform for two-qubit gates.

Crosstalk and Measurement Error: The Hidden Tax

Two additional error sources receive less attention but matter considerably.

Crosstalk occurs when operating on one qubit inadvertently affects neighboring qubits. On a superconducting chip, microwave pulses meant for qubit 7 can partially rotate qubit 8. On a trapped-ion chain, laser beams addressing one ion can scatter photons that disturb others. Crosstalk errors are correlated, which makes them particularly dangerous for error correction schemes that assume independent errors.

Measurement error affects the final readout. When you measure a qubit, there’s a probability of reading 0 when the state is actually 1, or vice versa. Current measurement fidelities range from 97% to 99.9% depending on the platform and measurement scheme. This sounds minor, but when your algorithm requires measuring hundreds of qubits, even 1% measurement error per qubit means the full bitstring is corrupted with high probability.

Three Strategies, Three Maturity Levels

The quantum computing community has developed three distinct approaches to dealing with errors, and the distinctions between them matter enormously for evaluating claims and timelines.

Error Suppression: Making Physical Qubits Better

The most direct approach: reduce the error rate of the physical hardware itself. Better materials, better fabrication, better control pulses, better shielding from environmental noise.

Techniques include dynamical decoupling (applying sequences of pulses that refocus dephasing), optimal control theory (designing pulse shapes that are robust to specific error types), and hardware improvements (better materials, improved fabrication tolerances, enhanced filtering).

This is incremental engineering. It works. Gate fidelities have improved by roughly 10x per decade since the first multi-qubit gates. But the improvement follows a diminishing-returns curve. The easy gains have been captured. Each additional nine of fidelity requires substantially more effort than the last.

Maturity: high. This is standard practice on every quantum platform. It’s necessary but not sufficient for useful computation.

Error Mitigation: Statistical Tricks to Extract Signal

Error mitigation doesn’t prevent or correct errors during the computation. Instead, it uses classical post-processing to statistically reduce the impact of errors on the final result.

Zero-noise extrapolation intentionally amplifies the noise (by stretching gate durations or adding extra gates), measures how the result degrades, and extrapolates back to what the zero-noise result would be. Probabilistic error cancellation characterizes the noise process and applies inverse operations probabilistically, effectively “uncomputing” the noise statistically. Measurement error mitigation characterizes the measurement confusion matrix and inverts it.

These techniques are genuinely useful for NISQ devices. They can extend the effective circuit depth by 2-5x in practice. But they come with exponential sampling overhead: as errors accumulate, you need exponentially more repetitions to extract the signal. This limits their applicability to moderately noisy circuits, not deeply noisy ones.

Maturity: medium. Widely used in current quantum experiments. Published results from IBM, Google, and others routinely use error mitigation. The techniques are well-understood but have fundamental scaling limitations.

Error Correction: The Real Solution (Eventually)

Quantum error correction (QEC) encodes one logical qubit across many physical qubits, detects errors through syndrome measurements, and actively corrects them during computation. Done correctly, it allows arbitrarily long computations with arbitrarily low error rates, at the cost of enormous qubit overhead.

The surface code is the most studied QEC scheme. It arranges physical qubits in a 2D grid and uses nearest-neighbor interactions (compatible with superconducting chip architectures) to detect and correct errors. A distance-d surface code uses roughly 2d^2 physical qubits and can correct up to (d-1)/2 errors. For useful error suppression on problems requiring millions of gates, distances of 15-30 are needed, meaning roughly 450 to 1,800 physical qubits per logical qubit.

But the surface code is not the only option. Newer quantum LDPC (Low-Density Parity-Check) codes, particularly those based on product constructions and the recent bivariate bicycle codes, achieve better encoding rates: more logical qubits per physical qubit. These codes could reduce the overhead from 1000:1 to perhaps 100:1, but they require non-local connectivity between qubits, which is challenging for superconducting architectures (where connectivity is local) and more natural for trapped-ion and neutral-atom systems.

Key milestones achieved in 2024-2025:

Google demonstrated “below breakeven” error correction on its Willow chip: a distance-5 surface code had a lower logical error rate than a distance-3 code, proving that adding more qubits to the error correction scheme actually helped rather than making things worse. This was a genuine milestone, crossing a threshold that had been pursued for over a decade.

Quantinuum demonstrated real-time error correction on trapped ions, detecting and correcting errors during a computation rather than only characterizing them after the fact.

Microsoft and Atom Computing demonstrated error correction on a neutral-atom platform, showing that the reconfigurable connectivity of optical tweezer arrays is well-suited to certain QEC codes.

Harvard and QuEra demonstrated a 48-logical-qubit error-corrected system using neutral atoms, the largest logical qubit demonstration to date.

These are real achievements. They are also still far from the scale needed for practical fault-tolerant computation.

Maturity: low to medium. Proof-of-principle demonstrations work. Scaling to useful levels requires 10-100x more physical qubits than current machines provide, along with sustained physical error rates below a threshold (roughly 0.1% to 1% depending on the code), which some platforms are approaching.

The Scaling Challenge in Numbers

To make the overhead concrete, consider a practical use case: simulating the electronic structure of a molecule relevant to drug design, say a molecule requiring 100 logical qubits and a circuit depth of 10 million gates.

With the surface code at distance 17 (needed for this circuit depth at current physical error rates): roughly 578 physical qubits per logical qubit. Total physical qubits: 57,800. Plus ancilla qubits for syndrome measurement. Total system: perhaps 100,000 physical qubits, all operating with error rates below the code’s threshold.

With optimistic LDPC codes at a 50:1 ratio: 5,000 logical qubits from the encoding, but the non-local connectivity requirements add engineering complexity.

Current largest quantum computers: around 1,000-1,200 physical qubits (IBM). The gap between here and there is roughly 100x in qubit count, while simultaneously maintaining or improving per-qubit quality.

This is not an impossible gap. Semiconductor fabs routinely scale by 100x over a decade. But quantum qubits are not transistors. Each qubit must maintain quantum coherence, not just switch between 0 and 1. The scaling challenge is qualitatively different.

Honest Timelines

The question everyone asks: when will we have fault-tolerant quantum computers?

Optimistic scenario (2029-2032): Rapid improvement in physical qubit quality, combined with new error-correcting codes that reduce overhead, leads to early fault-tolerant machines with 100-1,000 logical qubits. Useful for quantum simulation and chemistry. Not yet sufficient for breaking cryptography.

Central scenario (2030-2035): Steady progress across multiple platforms. First commercially useful fault-tolerant computations in specialized domains (pharmaceutical simulation, materials science). Cryptographically relevant machines arrive toward the end of this window.

Conservative scenario (2035-2040+): Physical qubit quality plateaus before reaching the error correction threshold for useful logical qubit counts. Practical fault tolerance requires new breakthroughs in either qubit technology or error correction theory.

These timelines are informed by the current rate of progress, stated hardware roadmaps from IBM, Google, Quantinuum, Microsoft, QuEra, and PsiQuantum, and published analyses from academic groups. They are estimates, not predictions. Every five-year forecast in quantum computing’s history has been too optimistic.

What This Means for Planning

If you’re a technical leader evaluating quantum computing investments, the error picture tells you several concrete things.

Any vendor claiming useful computation on current NISQ hardware must explain how they handle the error budget. Ask: what is the circuit depth? What is the gate fidelity? What error mitigation techniques are used? What is the sampling overhead? If these questions can’t be answered precisely, the claimed results should be treated skeptically.

Post-quantum cryptography migration is urgent regardless of the fault-tolerance timeline. The “harvest now, decrypt later” threat means data encrypted today is at risk from future quantum computers. The migration timeline for large organizations is 5-10 years. The threat timeline might be 10-15 years. The arithmetic is uncomfortably close.

For quantum simulation and chemistry applications, the 2028-2032 window is when early fault-tolerant machines may produce genuinely useful results. Organizations in pharmaceuticals, materials science, and energy should be building quantum literacy and identifying candidate problems now, not to run them now, but to be ready when the hardware arrives.

The central challenge of quantum computing is not building more qubits. It’s making each qubit good enough, and then making enough good qubits work together, to overcome the error budget. Every other question about quantum computing’s future reduces to this one.