> ## Content Index
> Fetch the complete content index at: https://tuguidragos.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Why your qubits forget: decoherence in plain words
- URL: https://tuguidragos.com/why-your-qubits-forget-decoherence-in-plain-words/
- Published: 2026-09-13T13:45:32.000Z
- Updated: 2026-09-13T17:34:37.000Z
- Description: T1 is the qubit falling down, T2 is the phase slipping away. The two clocks that decide how long your circuit gets to run.
- Author: Tugui Dragos
- Tags: Quantum Computing, Decoherence, Hardware, Quantum Mechanics, Learning in Public

In [the last post](https://tuguidragos.com/i-ran-a-bell-state-on-real-ibm-quantum-hardware/), just over one percent of my shots came back as outcomes that were supposed to be impossible, and I blamed three culprits. Gate errors, readout errors, and a third one I waved at and promised to come back to: decoherence. The qubits forget. They do not hold their state while you compute, and on a long enough circuit, that forgetting is what kills you.

This is the post where I come back to it, because decoherence is the deepest reason today's quantum computers are hard, and it is usually buried under intimidating jargon. T1, T2, dephasing, relaxation. It is simpler than it sounds. A qubit is a delicate thing trying to hold information in a noisy universe, and it loses. Here is how, in plain words, with the two numbers that measure the loss.

## A qubit is not a sealed box

The mental model that fixed this for me: a classical bit is rugged. It is a voltage, high or low, sitting in a chip designed to keep it exactly where you put it, indefinitely. You can set a bit and walk away for a year. A qubit is the opposite of rugged. It is a fragile quantum state, a particular superposition with a particular phase, held in a single physical system that the rest of the universe keeps poking at. Every stray bit of heat, every vibration, every faint electromagnetic whisper from the environment nudges it. And those nudges leak the qubit's information out into the surroundings, where you can never get it back.

That leaking is decoherence. The qubit starts in the crisp state you prepared, and over time it blurs into its environment, until the careful superposition you built is just gone, replaced by noise. The qubit has forgotten what it was. The disturbances are not exotic, which is part of what makes them so hard to escape: stray heat, faint magnetic fields, tiny vibrations through the apparatus, even the control electronics you use to manipulate the qubit can jostle it. Anything that carries energy and can couple to the qubit is a potential source of forgetting, and the universe is full of such things. And this is not a manufacturing defect that better engineering fully removes. It is the fundamental tension at the heart of quantum hardware: to compute with a qubit you must touch it, but anything that can touch it can also disturb it, including the universe. There are two distinct ways a qubit forgets, and each has a number.

## T1: the qubit falls down

The first way is the simplest. A qubit in the excited state, |1⟩, is holding energy, and energy likes to escape. Left alone, the qubit tends to relax back down to |0⟩, the ground state, dumping its energy into the environment, the same way a hot cup of coffee cools toward room temperature. This is called relaxation, and the number that measures it is T1.

T1 is a time. It is, roughly, how long the qubit takes to lose its energy, and the decay is exponential. The probability that an excited qubit is still excited after a time t follows e to the minus t over T1.

```python
import numpy as np
T1 = 100e-6   # 100 microseconds, a plausible figure for today's hardware

for t_us in [0, 10, 50, 100, 200]:
    t = t_us * 1e-6
    print(f"t = {t_us:3d} us   P(still excited) = {np.exp(-t/T1):.3f}")

```

Run it. At time zero the qubit is certainly still up, probability one. After fifty microseconds it is down to about sixty percent. After one hundred microseconds, exactly one T1, it has dropped to 0.368, which is one over e, the defining mark of exponential decay. After two hundred it is down near thirteen percent. The qubit is sliding down toward |0⟩ the whole time, and T1 tells you how fast. A bigger T1 is better, because it means the qubit holds its energy longer before falling. On current machines T1 is measured in tens to a couple of hundred microseconds, which sounds like a comfortable amount of time until you realise how long a circuit actually takes.

## T2: the qubit loses its phase

The second way is subtler and, for quantum, often worse. Remember from [the phase post](https://tuguidragos.com/relative-phase-the-invisible-engine-of-quantum/) that the interesting information in a qubit lives in its relative phase, the angle between the parts of a superposition. T2 measures how long that phase survives.

This kind of forgetting is called dephasing, and it does not require the qubit to lose any energy at all. It just requires the phase to drift. The environment nudges the qubit's phase a little this way, a little that way, randomly, and over time the precise angle you set blurs into noise. The magnitude can be perfectly intact, the qubit still equally |0⟩ and |1⟩, but the relative phase, the thing the next gate was supposed to read, is scrambled. And since the entire computation lives in those phases, as the phase post argued, losing the phase is losing the calculation. T2 is the time over which a superposition stays coherent, holding its phase, before the environment washes it out.

Here is the part that matters most. T2 is usually shorter than T1, sometimes much shorter, and it can never be more than twice T1\. So phase, the very thing quantum computing runs on, is typically the first thing to go. The qubit can still be holding its energy, not yet fallen to |0⟩, while the delicate phase relationship that made it useful has already dissolved. That is why dephasing is the quieter, deadlier problem. It destroys the resource you actually compute with, and it does it faster.

## What these numbers look like on real hardware

To make this concrete instead of abstract, today's superconducting qubits, tiny electrical circuits that only work when very cold, have T1 and T2 values measured in the tens to low hundreds of microseconds. Good devices push past a hundred, the very best further, but that is the ballpark, and crucially T2 usually trails T1\. These are not secret. When you connect to a real backend, its reported T1 and T2 for every qubit sit right there in the device properties, alongside the gate and readout error rates from [the hardware post](https://tuguidragos.com/i-ran-a-bell-state-on-real-ibm-quantum-hardware/). Reading them is the first thing a thoughtful person does before running, because they tell you your time budget.

And you can turn that budget into a gate count. If each layer of gates takes some time, and your phase survives for about T2, then you can fit roughly T2 divided by the gate time worth of layers before the phase is mostly gone.

```python
import numpy as np
T2 = 70e-6          # 70 microseconds, the dephasing time
gate_time = 0.2e-6  # time per gate layer, illustrative

layers = T2 / gate_time
print(f"layers until coherence drops to ~37%: {layers:.0f}")   # ~350

for depth in [50, 200, 350, 700]:
    coherence = np.exp(-(depth * gate_time) / T2)
    print(f"depth {depth:4d}  ->  phase coherence {coherence:.3f}")

```

Run it. With these illustrative numbers you get roughly three hundred and fifty layers before the phase coherence falls to that telltale 0.368, one over e. A shallow circuit of fifty layers keeps most of its phase, around eighty seven percent. By three hundred and fifty layers you are at the one over e mark, more than sixty percent of your phase gone. Past that the circuit is mostly noise. This single calculation, your device's T2 divided by its gate time, gives you a hard ceiling on useful circuit depth, and it is why the algorithm posts later will care so much about keeping gate counts down. The budget is real, it is a number, and you can compute it before you waste a run.

## Why these machines live in the cold

This is also why, if you have seen a photo of a quantum computer, it is that gold chandelier hanging inside a tank. That tank is a dilution refrigerator, and the qubits sit at the very bottom, cooled to around a hundredth of a degree above absolute zero, colder than the depths of space. The cold is not decoration and it is not about speed. It is a direct weapon against decoherence.

Heat is motion, and motion is exactly the kind of random environmental nudging that scrambles a qubit's state and phase. The warmer the surroundings, the faster the qubit forgets, because there is more thermal energy buzzing around to disturb it. Cooling the chip to nearly absolute zero quiets that thermal noise to almost nothing, which is what buys those tens to hundreds of microseconds of coherence in the first place. At room temperature the qubits would forget so fast you could not do anything with them at all, and the superconducting circuits they are built from would not superconduct in the first place. So the absurd refrigeration is the price of admission: to get even the short coherence times today's hardware has, you must first take the qubits to one of the coldest places in the known universe and hold them there. The cold does not make the qubits good. It makes them barely good enough to compute with before they forget, and that is the whole reason the machine looks like science fiction.

## Why this makes depth the enemy

Now connect it to the thing that has been lurking since [the pipeline post](https://tuguidragos.com/running-a-quantum-job-like-an-automation-pipeline/). Every gate takes time to execute. A real gate is a physical pulse lasting some tens or hundreds of nanoseconds, and a circuit is a sequence of these, layer after layer. So a deeper circuit takes longer to run, and the longer it runs, the more T1 and T2 have eaten into your qubits before you ever measure. Depth is time, and time is decoherence.

```python
import numpy as np
gate_time = 0.2e-6   # 200 nanoseconds per layer, illustrative
T1 = 100e-6

for depth in [1, 10, 100, 500]:
    elapsed = depth * gate_time
    print(f"depth {depth:4d}  ->  {elapsed*1e6:5.1f} us elapsed  ->  survival {np.exp(-elapsed/T1):.3f}")

```

Run it. A circuit one layer deep finishes almost instantly and the qubits barely decay, survival near one. A hundred layers takes twenty microseconds and you are already losing a meaningful chunk. Five hundred layers, at this gate speed, takes a full T1, and your qubits have decayed to that same 0.368, more than sixty percent of the information gone before you read the answer. This is exactly why the Bell state from last post, just two gates, came back mostly intact, while a deep circuit on the same machine would come back as mush. The math does not care how deep your circuit is. The physics cares enormously, because every layer is more time on the decay curve. Shallow circuits finish before the qubits forget. Deep ones do not.

## So what do you actually do

You design around it, the same way you design around any unforgiving constraint. You keep circuits shallow, minimising the number of gate layers so the whole thing finishes well inside the coherence time. You favour fewer two qubit gates, since those are both the noisiest and often the slowest. You let the transpiler optimise depth for you, which is part of what it is doing when it rewrites your circuit. And the whole research frontier of error correction exists precisely to fight this: to build a logical qubit that stays coherent far longer than any of its physical parts, by spreading the information across many qubits so that the environment cannot corrupt it faster than the system can repair it.

That last idea is worth a moment, because it is the long game the whole field is betting on. The trick of error correction is that you never rely on a single fragile qubit to remember anything. You encode one robust logical qubit across many noisy physical ones, in a clever pattern, and you keep checking the pattern for damage and repairing it on the fly, faster than the decoherence can accumulate. No single physical qubit lasts, but the logical qubit they collectively represent can, in principle, last indefinitely, the way a message protected by enough redundancy survives a noisy channel. The catch is the cost: it can take many physical qubits, sometimes a great many, to protect one logical qubit well, which is exactly why the qubit counts on today's machines, in the hundreds, are nowhere near enough for large scale error corrected computation. The next post takes up that honest accounting. For now, the working rule is simple and physical. Your qubits are on a timer from the moment you prepare them. Finish before it runs out.

## A quick test before you move on

Close this and answer in your own words.

What is the difference between T1 and T2, in plain terms? If you cannot say something like T1 is the qubit falling from |1⟩ to |0⟩ and T2 is the phase blurring away, reread the two sections, because that distinction is the heart of this.

Why is dephasing, T2, often the more dangerous of the two for quantum computation? If your answer does not mention that the computation lives in the relative phase, revisit the phase post and the T2 section together.

And why does a deeper circuit suffer more from decoherence? If more gates means more time means more decay is not roughly your answer, reread the section on depth.

## Where I am learning it

Free. The physics of T1 and T2 is covered well in the IBM Quantum learning materials and in any solid quantum hardware introduction, and the exponential decay is one of those ideas that becomes obvious the moment you plot it, which is why the few lines above were worth more to me than paragraphs of description. If you have access to a real backend, its reported T1 and T2 values are right there in the device properties, and comparing them to your circuit's runtime turns this whole post from abstract into a number you can act on. As always, I keep the decay curves as NumPy I can rerun, because forgetting that I have only read about does not land like forgetting I have watched fall off a curve.

## The fragile thing in the cold

A classical bit will sit in a chip for years without complaint. A qubit, by its nature, cannot. It is a delicate quantum state held in a real physical object that the universe will not stop disturbing, and from the moment you create it, it is already beginning to forget. T1 measures how fast it falls, T2 how fast it loses the phase, and a circuit is a race to finish before both numbers run out.

That fragility is not a flaw someone forgot to fix. It is the deep cost of working with quantum information at all, the reason these machines live in dilution refrigerators colder than deep space, the reason depth is dangerous, and the reason error correction is the whole ballgame for the next decade. Your qubits forget. Understanding exactly how is the difference between being surprised by the noise and designing around it.