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. A voltage that should be 0.0 V can wander to 0.02 V and still read as 0. A voltage that should be 1.0 V can sag to 0.97 V and still read as 1.

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 qubit is a chosen pair of states of a physical object — an electrical circuit at millikelvin temperatures, an ion in a vacuum, a photon in a waveguide, 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 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 large, reliable computations. Gates that are “99.9% correct” still fail often enough to wreck a circuit with thousands of operations.

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 continuous machine: physical qubits, repeated measurements, a classical decoder deciding what happened, and feedback — all faster than the next error arrives.

7. Physical qubits are not logical qubits

#

News headlines that say “we now have $N$ qubits” almost always mean physical qubits. The algorithm cares about logical qubits: protected degrees of freedom that survive long enough to finish the circuit.

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.

Two different questions therefore get mixed in public conversation:

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

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

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