Why Qubits Fail

A qubit is a real, physical thing. It can be a tiny microwave circuit, a single trapped ion (a charged atom held in place), or a neutral atom. Its two lowest energy states act as 0 and 1. Unlike a normal bit, it can be in a superposition. That means its state is a mix of 0 and 1, with a weight on each part. Each weight is an amplitude — a number that says how strongly the qubit leans toward that answer. Square it and you get the chance of seeing that answer when you measure. If these ideas are new, start with bits vs qubits and probability amplitudes.

Why should you care? Because a qubit is far more fragile than the bits in your phone. A normal bit is safe by brute force. Huge crowds of electrons push hard toward a clear "high" or "low" voltage. A little noise — random, unwanted disturbance — changes nothing.

Think of a light switch. It is either up or down, and a small bump will not flip it. A qubit is more like a spinning top balanced on a table. Its information lives in smooth, continuous numbers: the amplitudes and the relative phase. The relative phase is the angle between the 0-part and the 1-part. Every stray touch from the outside world nudges these numbers. Heat does it. So do vibration, radiation, and slightly wrong control pulses. Unlike a top, a qubit does not fall over in one clear way. It drifts a little at a time.

Engineers do not describe this damage in vague words. They use four standard numbers, and all four appear on every QPU (quantum processing unit) page on this site:

• T1 — how long before the qubit loses its energy.
• T2 — how long before the qubit loses its phase.
• Gate error — how often one operation goes wrong.
• Readout error — how often the measurement reports the wrong answer.

This chapter explains each one in plain words and walks through the math they lead to.

T1 is the energy relaxation time. It answers one simple question. Put a qubit in its higher-energy state |1⟩ and just wait. How long until it falls back down to |0⟩ on its own?

An everyday picture: a phone battery that slowly drains while it sits in a drawer. The qubit "leaks" its energy the same way. The leak follows a curve called exponential decay. After waiting a time t, the chance the qubit is still in |1⟩ is e^(-t/T1). (Here e is a fixed number, about 2.718, that shows up in any steady leak.) The battery picture breaks in one way. A battery drains a little bit at a time. A qubit either still holds its |1⟩ or has already dropped to |0⟩. The formula gives the chance of each.

Worked example. All figures here are archetype numbers. That means round numbers picked to make the math easy. They are not any company's real spec. Say T1 = 200 µs (microseconds, or millionths of a second). Your circuit leaves a qubit sitting idle for t = 100 µs.

1. Find the ratio: t / T1 = 100 / 200 = 0.5.
2. The chance it survives is e^(-0.5) ≈ 0.6065.
3. So the qubit still holds its |1⟩ only about 60.7% of the time. That is about a 39.3% chance the energy has already leaked away.

That is a lot of failure from doing nothing for a tenth of a millisecond. Most normal computer memory does not fail that much in years. Real, sourced T1 values for real devices are on our coherence T1/T2 metric page.

T2 is the dephasing time. It measures how long a qubit keeps its relative phase — the angle between its 0-part and its 1-part.

Why does phase matter if you can't see it? Two states can give the same 0/1 odds and still be very different. Take |+⟩ = (|0⟩+|1⟩)/√2 and |−⟩ = (|0⟩−|1⟩)/√2. The only difference is a plus or minus sign. Both give 50/50 results when you measure. Yet they act in opposite ways in any interference step. Interference is when amplitudes add up or cancel out, like two waves in a pool. Much of quantum computing's power lives in phase — see amplitudes and phase.

An everyday example: two clocks that slowly drift out of sync. Each clock still ticks just fine. But the agreement between them — the useful part — fades away. Noise from outside makes the qubit's phase wander at random. After a time around T2, the phase is scrambled. The clock picture stops working in one way. With clocks you can look and see the drift. With a qubit, you can't see the phase directly at all.

Two facts engineers rely on:

• Physics guarantees T2 ≤ 2·T1. Losing energy also scrambles phase. So T2 can never be more than twice T1.
• Dephasing is invisible if you measure 0 or 1 right away. The odds don't change. Only the phase does.

An error you can't see in your results is the most dangerous kind. It gets its own chapter later in this course: the phase-flip code.

Every gate is a real control pulse, like a burst of microwaves or a flash of laser light. No pulse is perfect. Gate error is the chance that one gate leaves the qubits in a slightly wrong state. Fidelity is the flip side: how often it goes right. So 99% fidelity means 1% error. Two-qubit gates, like CX, are always the worst. That is why our two-qubit fidelity page tracks them on their own.

An everyday example: a 100-step recipe where each step has a small chance of a slip. One slip is rare. But across 100 steps, slips add up.

Worked example (archetype figures again). Say each two-qubit gate has a 1% error, and your circuit uses 100 of them. Each gate succeeds 99% of the time. The chance that all 100 succeed is 0.99 multiplied by itself 100 times, written 0.99^100. Here is one way to compute it:

1. ln(0.99) ≈ −0.01005 (ln is the natural log, which turns repeated multiplying into adding).
2. 100 × (−0.01005) = −1.005
3. e^(−1.005) ≈ 0.366

So there is only about a 37% chance the circuit ran with no gate errors. Now redo it with 0.1% error per gate: 0.999^100 = e^(100 × ln 0.999) = e^(−0.10005) ≈ 0.905. That is about 90%. One more "9" of fidelity turns a mostly broken 100-gate circuit into a mostly working one. Errors pile up exponentially with gate count. That means each extra gate multiplies the risk, not just adds to it.

Last, readout error. The measuring hardware itself sometimes reports a 0 as 1, or a 1 as 0. Think of a cashier who sometimes misreads a price tag. It happens once per qubit, at the end of a run. It is measured and published on its own — see readout fidelity. How all these numbers get measured and reported is covered in fidelity, error and calibration.

Every QPU page on this site lists these four numbers for real devices. Each value comes with its source and the date it was observed. It also has a label. The label says how it was measured. It also says whether it is a company's own claim or a test by someone else. Browse the QPU index, or put two devices side by side in the comparison view.

The first thing you will notice: the numbers vary hugely. Across different kinds of hardware they can differ by factors of 10, 100, or more. A superconducting circuit and a trapped ion have very different T1 ranges. See superconducting qubits and trapped-ion qubits. Even qubits on the same chip can differ. That spread is one reason compilers care which physical qubits your circuit lands on.

To be clear about method: the 200 µs T1 and the 1% gate error in this chapter are archetype figures. We picked them for round numbers. Real, current, sourced values live on the T1/T2, two-qubit fidelity and readout fidelity pages. We never guess or fill in a number a company has not shared.

You now have the list of ways qubits fail: bit flips and energy loss, phase drift, imperfect gates, and readouts that lie. The rest of the course builds the fix, step by step:

• Modeling errors as gates — make errors exact, so you can place them and trace them in a noise-free simulator.
• The no-cloning obstacle — why the obvious fix, copying the qubit, is impossible.
• The bit-flip code and the phase-flip code — two three-qubit codes you can run from start to finish, right here.
• Stabilizers, the surface code, and the math of how many physical qubits one good qubit costs. That math drives every serious hardware roadmap.

One promise, kept all the way through: every claim is either worked out in front of you, runnable in the Lab, or sourced on a hardware page.