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.

A quantum error is damage to the qubit state. The amplitudes change, or the phase changes, or both. A bit flip from 0 to 1 is only one kind of that damage. Error mitigation reduces the effect of noise on today’s machines. Error correction adds extra qubits so one logical qubit can keep its state when some physical qubits fail.

In Quantum Computing Careers one layer of the stack is error correction. This article explains that layer.

Every computer makes mistakes. The questions here are:

What is damaged? Why so easily? What can we do without destroying the computation?

1. A classical error is usually a flipped bit

#

In classical hardware the physical thing is usually a voltage. That voltage can be many numbers — 0.3 V, 1.4 V, 3.7 V, 4.9 V. We do not treat each number as a different piece of information. We pick two ranges and give them two names: 0 and 1. That name is the bit.

Designers then leave a margin, so ordinary noise does not flip the name. 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 a small wiggle in the voltage does not change the bit.

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

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

Parity bits, checksums, RAID, ECC memory, and TCP rest on two facts:

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 damaged state

#

A qubit is also a name we put on a physical thing. In the usual 0/1 pair used for computing — the computational basis — that physical thing is a quantum 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: the device that should be $|0\rangle$ is now closer to $|1\rangle$. It can also be small: $\alpha$ and $\beta$ look almost the same, but the phase the algorithm needed is gone. That small change is still a failure.

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

The hardware article explains why quantum machines cannot use the §1 trick: absorb noise in the voltage margin.

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

#

As in §1, the voltage is physical; 0 and 1 are only names for two voltage ranges.

A qubit uses the same idea with a different physical thing. Two chosen quantum states get the names $|0\rangle$ and $|1\rangle$. The qubit can also sit between those two names (a superposition). The physical thing is the quantum state of a real object: 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. Everything around the device is a large, warm, noisy environment.

Unwanted interaction with that environment is decoherence. Heat, stray fields, vibration, neighboring qubits, and noise on control lines change $|\psi\rangle$ so it no longer interferes as the algorithm needs. See §12 of the hardware article.

The problem:

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.

So “error” here is not a software bug we patch later. It is a physical process. It starts as soon as the photon, electron, ion, or circuit that holds the qubit exists.

4. The main kinds of error

#

These names are models. Real devices mix them.

Bit-flip

#

The qubit that should stay $|0\rangle$ becomes $|1\rangle$. $|1\rangle$ can also become $|0\rangle$. This is like an $X$ gate we did not ask for. An $X$ gate is the quantum NOT: it swaps $|0\rangle$ and $|1\rangle$. Classical gate vs quantum gate: §7 of the hardware article.

Phase-flip

#

The sizes of $|0\rangle$ and $|1\rangle$ can stay the same, but the relative sign between them changes. This is like a $Z$ gate we did not ask for. A $Z$ gate leaves $|0\rangle$ as it is and multiplies $|1\rangle$ by $-1$. Interference is then wrong.

Combined (depolarizing) noise

#

Bit-flip and phase-flip can happen together. A common model replaces the intended state, with some probability, by a mixed state that no longer interferes. The model says both kinds of damage must be handled.

Amplitude damping and energy relaxation

#

The device falls toward its ground state. A superconducting qubit that should stay in $|1\rangle$ decays toward $|0\rangle$.

Leakage

#

We treat a qubit as two levels. Real systems have more. A pulse that is too strong, or a photon lost the wrong way, can send the system out of those two levels. Two-level error correction may not see that.

Crosstalk

#

A pulse meant for qubit 3 disturbs qubit 4. On large machines this is a systems problem.

Control, calibration, and measurement error

#

The classical stack that drives the QPU is imperfect. Frequencies drift. Pulses are misshapen. A measurement that should report $0$ reports $1$. Some of this is electronics and software.

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 starting state.

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  damaged entanglement and damaged phase

5. Why we cannot copy-and-vote

#

The classical repair — make three copies and take a majority — fails for two reasons.

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 must do this:

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.

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 program.

This is necessary. It is not enough for the problems on industry 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.

One gate is clean with probability $0.999$. If each gate fails on its own, multiply once per gate. For $G$ gates the chance is $0.999^{G}$.

A circuit of 10,000 gates at that fidelity is about 1 clean run in 22,000, because $1 / 0.0000452 \approx 22{,}100$. Today’s best two-qubit gates sit in that 99.9% class on a few platforms, and worse on many others.

What we have in 2026 is still NISQ: noisy intermediate-scale quantum machines. The processors that run the deepest circuits have about 50–160 physical qubits (IBM Heron and Nighthawk, Google Willow, Quantinuum Helios). Some chips advertise about a thousand physical qubits (IBM Condor, Atom Computing). Experimental logical qubits exist in the single digits to low teens. That is a research result, not an algorithm-scale machine. Useful circuits are thousands of gates, with mitigation. Nobody has a fault-tolerant computer.

The jobs people name 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 zero.

The last two rows assume those 99.9% gates sit under a surface code — a common error-correcting code for 2D chips. Many physical qubits encode one logical qubit. They are measured and repaired faster than the next error arrives. The same 99.9% gates without that machine do not factor RSA and do not simulate FeMoco. They produce a damaged set of answers.

Quieter hardware is only the start. Error correction is the difference between a demonstration and a computer. Conversion rate: §7.

Error mitigation

#

On today’s NISQ machines we often cannot afford a full error-correcting code. We reduce the effect of noise on the answer:

• 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,
• compile so the noisiest paths are shorter.

Mitigation does not make a fault-tolerant computer. It tries to get a better estimate from the device we have. This is software and statistics as much as physics.

Quantum error correction

#

We stop treating each physical qubit as the qubit the algorithm sees. We encode one logical qubit in many physical qubits.

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 a code can protect against both bit-flips and phase-flips. Andrew Steane gave another early construction. Modern hardware often aims at surface codes, because they match 2D layouts and nearest-neighbor coupling.

Error correction 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 next to the fridge. If it falls behind, the logical qubits die even if the code is correct on paper.

Hardware that is “almost perfect” still needs this. If physical errors sit above a code threshold, adding more qubits collects more noise.

7. Physical qubits are not logical qubits

#

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

A logical qubit is a protected piece of quantum information encoded in many physical qubits. The algorithm uses logical $|0\rangle$, $|1\rangle$, and logical gates. The code, the decoder, and many physical operations must keep that logical qubit alive 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 gate quality, one logical qubit can use tens, hundreds, or thousands of physical qubits. A “million-qubit” machine may still have far fewer logical qubits.

What application developers actually program

#

The same word “logical” means two things.

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. In the compiler, “logical” means the qubit in your circuit. In this article, “logical” 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. You write a circuit, pick a backend, and transpile. The runtime places gates on devices, inserts swaps because not every pair is connected, and may add mitigation. You choose shot counts and keep circuits short. A chemistry library does not give you 2,200 logical qubits.

Later the program is written against logical qubits. The QEC stack — not the app — owns the physical objects, the syndrome cycle, and the decoder. A chemist should not pick a transmon, just as a web developer does not pick a DRAM cell.

That product layer does not exist in 2026. Until it does, most “quantum application” code is a circuit on noisy hardware. Two different jobs:

Until the second number is large and stable, most applications remain experiments.

If physical errors are rarer than a code-dependent rate, more physical qubits can make the logical error smaller. If they are worse than the threshold, more qubits make things worse: more noise. Gate fidelity and coherence decide whether error correction helps or hurts.

§8 puts 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. 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.

The word gate has three uses 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 makes the stack confusing.

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 maps that list to physical qubits and physical gates. The logical-gate row is still almost empty as a product. §7 and §6 are the same story: the algorithm is at the top of the stack; error is 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 — does not add more error than it removes. The work of fighting noise must itself be protected.

Timelines for useful fault-tolerant machines are still uncertain. The science of encoding is decades old. The industrial problem is to manufacture, control, connect, measure, and decode many physical qubits as one machine. Section 19 of the hardware article puts that next to classical transistor scaling.

10. Where this sits in a career

#

Once “error” means a damaged state, not only a flipped bit, the career layers below are easier to see.

A software professional does not have to become an experimental physicist to work near this problem. Decoders, runtime systems, calibration software, and resource estimators are software. They are software about a physical failure that classical ECC did not have.

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

11. A compact definition

#

A quantum error is any change we did not want in a quantum state — especially in its amplitudes or relative phase. The cause can be the environment, imperfect control, or measurement. We respond in three ways: quieter hardware, statistical mitigation on noisy devices, and — for large reliable computation — encoding logical qubits in many physical qubits and correcting syndromes without reading the data.

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

12. Terms for revision

#

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; Before the Equations: A Mental Map of Quantum Mechanics Vocabulary; Quantum Measurement, Randomness, and Everyday Technology; Quantum Computing Careers.

Hashtags

#

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