What Is Error in Quantum Computing?

#

Why qubits fail, what that failure means, and how we protect computation

#

Part 23 of the Learning Quantum Physics series.

In Quantum Computing Careers the stack has a layer that is easy to treat as a slogan: error correction. This article is the concept behind that layer.

The question is not “do quantum computers make mistakes?” Every computer does. The useful questions are:

What, exactly, is being spoiled? Why does it spoil so easily? And what can we do about it without destroying the computation we were trying to run?

1. A classical error is usually a flipped bit

#

A classical bit is a robust label. The hardware chooses two well-separated physical states and calls them 0 and 1. Designers then leave a margin. On the 5 V logic most engineers first learn, about 0–2 V still counts as 0, about 3–5 V still counts as 1, and the 2–3 V band in between is undefined — a transition or a fault, not a third legal value. TTL is a little tighter (0 below 0.8 V, 1 above 2.0 V). Modern chips use lower supplies, but they keep the same idea: a large slice of the voltage range is reserved so ordinary noise does not flip the bit.

When a bit does flip, we have a friendly toolkit:

Copy the bits
        ↓
Store extras
        ↓
Take a majority vote
        ↓
Correct the odd one out

Parity bits, checksums, RAID, ECC memory, and TCP all rest on two facts we barely notice:

1. We can copy unknown classical data.
2. We can read it without destroying it.

Quantum computing loses both facts.

2. A quantum error is a spoiled state

#

A qubit is not only a label. In the computational basis it is a state

where $\alpha$ and $\beta$ are complex amplitudes. Two things matter at once:

An error is any unwanted change to that state.

The change can be large and obvious: the device that should still be $|0\rangle$ is now closer to $|1\rangle$. It can also be quiet. The populations can look almost unchanged while the phase that an algorithm was counting on has been scrambled. From the algorithm’s point of view, that quiet damage is still a complete failure.

A useful first picture:

Intended state     |ψ⟩  =  what the circuit asked for
Actual state       |ψ'⟩ =  what the hardware holds
Error              the difference we did not request

In the hardware article this fragility is why quantum machines cannot copy the classical habit of “absorb noise in the margin.”

3. Why it happens: we must isolate and we must touch

#

A bit is a label. In classical hardware that label is usually encoded as a voltage. A qubit is also a label — $|0\rangle$, $|1\rangle$, and the superpositions between them — but it is encoded as the quantum state of a physical system: a superconducting circuit at milli-kelvin temperatures, an ion in a vacuum, a photon in a waveguide, or an electron spin in silicon. Those states are quantum. The rest of the universe is a large, warm, noisy environment.

Unwanted interaction with that environment is decoherence. Thermal radiation, stray electromagnetic fields, vibration, neighboring qubits, and noise on control lines all push $|\psi\rangle$ toward a mixture that no longer interferes the way the algorithm needs.

The engineering paradox is sharp:

Isolate the qubit from the environment
              AND
Interact with the qubit to compute

If we isolate too well, we cannot apply gates or read the answer. If we expose the qubit too much, the state dies before the circuit finishes. Every control line, laser path, microwave pulse, and detector is both a tool and a leak.

That is why “error” in quantum computing is not a software bug that we can patch after the fact. It is a physical process that begins as soon as the physical object—the photon, electron, ion, or circuit—that realizes the qubit exists.

4. The main kinds of error

#

Names help, as long as we remember they are models, not separate universes. Real devices mix them.

Bit-flip

#

The state that should be $|0\rangle$ picks up a component of $|1\rangle$, or the reverse. In the usual cartoon this is an accidental $X$ gate.

Phase-flip

#

The relative sign between $|0\rangle$ and $|1\rangle$ flips or wanders. In the cartoon this is an accidental $Z$ gate. Populations can look fine. Interference is ruined.

Combined (depolarizing) noise

#

Bit-flip and phase-flip can happen together. A common textbook model replaces the intended state, with some probability, by a fully mixed one. The point of the model is not realism in every detail. It is that both kinds of damage must be handled.

Amplitude damping and energy relaxation

#

The device tends to fall toward its ground state. A superconducting qubit that should stay in the excited state $|1\rangle$ decays toward $|0\rangle$. This is closer to friction than to a random coin flip.

Leakage

#

A “qubit” is an idealization: we pretend only two levels exist. Real systems have more. A pulse that is too strong, or a photon that is lost the wrong way, can send the system out of the qubit subspace. Standard two-level error correction does not automatically see that.

Crosstalk

#

A pulse meant for qubit 3 disturbs qubit 4. As machines grow, this becomes a systems problem, not a single-device footnote.

Control, calibration, and measurement error

#

The classical stack that drives the QPU is itself imperfect. Frequencies drift. Pulses are misshapen. A measurement that should report $0$ reports $1$. Some of this is electronics and software — familiar territory for engineers coming from classical systems.

Missing the intended entanglement

#

Two-qubit gates are usually the noisiest operations. If the intended entangled state is not produced, later interference has the wrong raw material.

A compact map:

The state itself          bit-flip, phase-flip, relaxation, leakage
The neighborhood          crosstalk, residual coupling
The control stack         pulse error, drift, timing
The readout               measurement assignment error
The algorithm's resource  spoiled entanglement and spoiled phase

5. Why we cannot copy-and-vote

#

The obvious classical repair — make three copies and take a majority — collides with two theorems of quantum mechanics.

No-cloning. An unknown quantum state cannot be copied perfectly. We cannot take $|\psi\rangle$, make $|\psi\rangle|\psi\rangle|\psi\rangle$, and vote. If we already knew $|\psi\rangle$, we would not need to copy it; we could just prepare it again.

Measurement disturbs. Reading a qubit in the computational basis generally collapses it. If we measure mid-circuit to “see whether it is still correct,” we often destroy the superposition the rest of the circuit needed.

So the repair, if it exists, must do something that sounds impossible the first time one hears it:

Learn that an error happened without learning the computational data, then undo the error.

That is the job of quantum error correction.

6. Three ways the industry responds

#

The industry does not wait for a perfect qubit. It attacks error at three levels that are easy to confuse.

Better hardware

#

Make the physical object quieter. Longer coherence times, higher-fidelity gates, better isolation, better materials, better calibration. Every platform in the hardware landscape is, in large part, an error-reduction research program.

This is necessary. It is not sufficient by itself if we want the problems people actually put on roadmaps.

Gates that are “99.9% correct” do not give a 99.9% correct answer. One wrong gate can spoil the interference. The useful number is the chance that every gate in the run was clean: $0.999^{G}$. A circuit of 10,000 gates at that fidelity is already about 1 clean run in 22,000. Today’s best two-qubit gates sit in that 99.9% class on a few platforms, and a bit worse on many others.

What we actually have in 2026 is still NISQ. The processors that run the deepest circuits have on the order of 50–160 physical qubits (IBM Heron and Nighthawk, Google Willow, Quantinuum Helios). Some headline chips advertise about a thousand physical qubits (IBM Condor, Atom Computing). Experimental logical qubits exist in the single digits to low teens — a scientific milestone, not an algorithm-scale machine. Useful circuit sizes are thousands of gates, with mitigation. Nobody has a fault-tolerant computer.

The poster problems are not that machine. They need thousands of logical qubits and billions of logical gates, running for hours or days. Without error correction, $0.999^{G}$ at that size is not rare. It is zero.

The last two rows assume those 99.9% gates sit under a surface code: many physical qubits encode one protected logical qubit, measured and repaired faster than the next error arrives. The same 99.9% gates without that machine do not factor anything and do not simulate FeMoco. They produce a spoiled distribution.

That is why quieter hardware is only the start, and why error correction is not a later optimization. It is the difference between a demonstration and a computer. See §7 for the conversion rate.

Error mitigation

#

On today’s noisy intermediate-scale machines — the NISQ era — we often cannot afford a full error-correcting code. We instead reduce the effect of noise on the answer we report:

• run the circuit many times and average,
• zero-noise extrapolation (repeat at several noise levels and extrapolate),
• probabilistic error cancellation,
• symmetry checks and post-selection,
• clever compilation that shortens the noisiest paths.

Mitigation does not turn a noisy device into a fault-tolerant computer. It tries to extract a better estimate from a device we already have. That is why it is a software-and-statistics career as much as a physics career.

Quantum error correction

#

Here we stop treating each physical qubit as the qubit the algorithm sees. We encode one logical qubit in many physical qubits, in a carefully chosen entangled pattern.

many physical qubits  →  error-correcting code  →  one logical qubit

Stabilizer measurements — “syndromes” — ask questions such as “did a bit-flip occur in this neighborhood?” without asking “what is the logical value?” If the syndrome pattern points to a likely error, a correction is applied.

Peter Shor showed in 1995 that this is possible in principle: a code can protect against both bit-flips and phase-flips. Andrew Steane gave another early construction. Modern hardware programs often aim at surface codes and related families, because they match 2D layouts and nearest-neighbor coupling.

Error correction is not a Python decorator. It is a factory that must stay on for the whole computation: encode, measure syndromes, decode classically, apply corrections — on every logical qubit, every cycle, for hours or days. A million physical qubits means a million objects to keep in step. The decoder is a real-time computer sitting next to the fridge. If it falls behind, the logical qubits die even though the code was correct on paper.

That is the scale of the error-correction problem. Hardware that is “almost perfect” still needs this machine. Hardware that is not almost perfect cannot use it: if physical errors sit above a code-dependent threshold, adding more qubits makes a larger antenna for noise.

7. Physical qubits are not logical qubits

#

A physical qubit is one object on the chip: a transmon, an ion, a photon mode, a spin. It decoheres. Gates on it fail at the rates in §6.

A logical qubit — in the error-correction sense — is a protected piece of quantum information encoded in many physical qubits. The algorithm is written in logical $|0\rangle$, $|1\rangle$, and logical gates. The code, the decoder, and a swarm of physical operations are supposed to make that logical object last for the whole job.

News headlines that say “we now have $N$ qubits” almost always mean physical qubits. RSA and FeMoco care about logical qubits.

The conversion rate is harsh. Depending on the code, the target error rate, and the quality of the underlying gates, one logical qubit can consume tens, hundreds, or thousands of physical qubits. A “million-qubit” machine might still offer a much smaller number of logical qubits.

What application developers actually program

#

There is a name collision that trips people who open an SDK.

In Qiskit, Cirq, or PennyLane you write q0, q1, q2. Those are circuit qubits — addresses in your program. The transpiler maps them onto physical qubits. They are not error-corrected logical qubits. “Logical” in the compiler means “the qubit in your circuit.” “Logical” in this article means “the qubit the surface code is protecting.”

Today (2026)
  app writes:   circuit qubits  q0, q1, q2
                    ↓ transpile + layout
  chip runs:    physical qubits + error mitigation
                    ↓ many shots, a histogram
  you receive:  a noisy estimate, not a guaranteed answer

Later (fault tolerant)
  app writes:   logical qubits and logical gates
                    ↓ QEC stack (encode, syndromes, decoder)
  chip runs:    many physical qubits, continuously repaired
                    ↓
  you receive:  the algorithm's qubits, the way a web app
                receives RAM — without picking DRAM cells

Today an application developer still talks to physical qubits, with a software accent. You write a circuit, pick a backend, and transpile. The runtime places gates on specific devices, inserts swaps because not every pair is connected, and may wrap the job in mitigation. You choose shot counts and keep circuits short. Importing a chemistry library does not give you 2,200 logical qubits.

Later the program is supposed to be written against logical qubits. The QEC stack — not the app — owns the physical objects, the syndrome cycle, and the decoder. A chemist or a cryptanalyst should no more pick a transmon than a web developer picks a DRAM cell.

That product layer does not exist in 2026. Until it does, most “quantum application” code is a circuit on noisy hardware. The two questions that get mixed in public conversation are therefore also two different developer jobs:

Until the second number is large and stable, most applications remain experiments, not replacements for classical data centers.

A rough threshold idea is enough for this article. If physical errors are rarer than some code-dependent rate, adding more physical qubits can make the logical error smaller. If physical errors are worse than the threshold, adding more qubits can make things worse: we have built a larger antenna for noise. That is why gate fidelity and coherence are not vanity metrics. They decide whether error correction helps or hurts.

§8 places these two qubits on the same stack as transistors, logic gates, chip design, and the processor.

8. From transistor to processor: where bits and qubits live

#

The words gate, circuit, and chip appear on both sides. They do not name the same layer. This section is the map. The longer stack, with platforms and components, is in the hardware article.

Read the table from the bottom up. Each row is built from the row below.

Three different uses of the word gate sit in that table. A MOSFET gate is an electrode on a transistor. A logic gate is AND or OR. A quantum gate is a pulse (physical) or an encoded operation (logical). Mixing those three is how the stack becomes mush.

How a bit moves, and how a qubit does not

#

A classical circuit is a map of space. A bit is a voltage that travels. It leaves a register, rides a wire, passes through logic gates, enters the ALU, and comes back as another voltage. The transistors stay put. The bit flows.

A quantum circuit is mostly a map of time. Superconducting qubits sit on the chip; pulses come to them. The state is rewritten in place. Trapped ions can be shuttled — the object moves, the information rides with it. After measurement the result is an ordinary classical bit, and that bit flows through ordinary electronics again.

Classical
  transistor → voltage bit → logic gate → spatial circuit → die → CPU
  the bit rides the wires

Quantum
  physical system → physical qubit → physical gate (pulse)
       → [logical gate, if error correction is on]
       → time-ordered circuit → QPU die → processor
  the qubit state is transformed; measurement returns bits

Application code today writes the middle of the quantum column: circuit qubits and a time-ordered gate list. The transpiler binds that list to physical qubits and physical gates. The logical-gate row is still almost empty as a product. That is why §7 and §6 are the same story: the algorithm lives at the top of the stack; error lives at the bottom; error correction is the missing middle.

9. What “fault tolerant” actually claims

#

Fault tolerance is a stronger claim than “we encoded a qubit.”

It means the whole procedure — gates on logical qubits, measurements, decoder, and the extra circuitry those steps require — does not introduce more error than it removes. The overhead of fighting noise must itself be protected.

That is why timelines for economically useful fault-tolerant machines remain uncertain. The science of encoding is decades old. The industrial problem is to manufacture, control, connect, measure, and decode enormous numbers of physical qubits as one coherent machine. Section 19 of the hardware article puts that scaling problem next to classical transistor scaling.

10. Where this sits in a career

#

Once “error” is a spoiled state rather than a flipped bit, several career layers stop looking exotic.

This is also why a software professional does not have to become an experimental physicist in order to work near the problem. Decoders, runtime systems, calibration software, and resource estimators are software. They happen to be software about a physical failure mode that classical ECC never had to face.

For how that maps onto 5-, 15-, and 25-year career capital, return to Quantum Computing Careers.

11. A compact definition

#

If we need one sentence:

A quantum error is any unintended change to a quantum state — especially to its amplitudes or relative phase — caused by the environment, by imperfect control, or by measurement; we address it by quieter hardware, by statistical mitigation on noisy devices, and, for large reliable computation, by encoding logical qubits in many physical qubits and correcting syndromes without reading the data.

The rest of the literature is the engineering of that sentence.

Also in this series: Learning Quantum Physics series index · Previous: Quantum Computing Careers (Part 22)

References

#

1. Peter W. Shor, “Scheme for reducing decoherence in quantum computer memory,” Physical Review A 52, R2493 (1995). https://doi.org/10.1103/PhysRevA.52.R2493. First explicit quantum code protecting against both bit-flip and phase-flip errors.
2. A. M. Steane, “Error Correcting Codes in Quantum Theory,” Physical Review Letters 77, 793 (1996). https://doi.org/10.1103/PhysRevLett.77.793.
3. John Preskill, “Quantum Computing in the NISQ era and beyond,” Quantum 2, 79 (2018). https://doi.org/10.22331/q-2018-08-06-79. Why today’s devices are noisy, and why mitigation and error correction are different projects.
4. Austin G. Fowler, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland, “Surface codes: Towards practical large-scale quantum computation,” Physical Review A 86, 032324 (2012). https://doi.org/10.1103/PhysRevA.86.032324. The code family most often cited for two-dimensional hardware.
5. Michael A. Nielsen and Isaac L. Chuang, Quantum Computation and Quantum Information, Cambridge University Press. Standard textbook treatment of quantum noise, completely positive maps, and error correction.
6. W. K. Wootters and W. H. Zurek, “A single quantum cannot be cloned,” Nature 299, 802–803 (1982). https://doi.org/10.1038/299802a0. Why classical copy-and-majority-vote is unavailable.
7. Craig Gidney, “How to factor 2048 bit RSA integers with less than a million noisy qubits,” arXiv:2505.15917 (2025). https://arxiv.org/abs/2505.15917. Resource estimate used in §6: under one million physical qubits, about a week, ~1,400–1,500 logical qubits.
8. Joonho Lee, Dominic W. Berry, Craig Gidney, William J. Huggins, Jarrod R. McClean, Nathan Wiebe, and Ryan Babbush, “Even More Efficient Quantum Computations of Chemistry Through Tensor Hypercontraction,” PRX Quantum 2, 030305 (2021). https://doi.org/10.1103/PRXQuantum.2.030305. FeMoco-scale estimate used in §6: ~2,200 logical qubits, about four million physical qubits, a few days.
9. On this site: Quantum Hardware Is Not a Smaller or Stranger Classical Computer, especially §12 decoherence and §19 logical qubits; Quantum Measurement, Randomness, and Everyday Technology; Quantum Computing Careers.

Hashtags

#

#QuantumComputing #QuantumErrorCorrection #Decoherence #LogicalQubits #NISQ #FaultTolerantQuantum #QuantumHardware #QuantumInformation #LearningQuantumPhysics #Qubits #ErrorMitigation #QuantumEngineering