Quantum Decoherence
Quantum decoherence is the process by which a qubit loses its fragile quantum state through unwanted interaction with its surroundings. A qubit only computes while it holds a delicate blend of possibilities called superposition, and every stray vibration, magnetic wobble, or bit of heat leaking in from the outside world corrupts that blend and collapses it into an ordinary, useless 0 or 1. Decoherence is the single biggest engineering obstacle to quantum computing, and it’s the core reason a cryptographically relevant quantum computer is so hard to build. Fighting it takes error correction, and error correction is why you need millions of physical qubits to get the few thousand reliable ones an attack on real cryptography would require.
The short version:
- A qubit is useful only while it stays “coherent,” holding a quantum superposition. Decoherence is that state leaking away as the qubit interacts with its environment.
- The amount of time a qubit survives before decoherence wrecks it is its coherence time, and on today’s leading superconducting hardware that’s roughly 100 microseconds.
- Breaking cryptography with Shor’s algorithm takes billions of sequential operations, far more than any qubit can complete before it decoheres, so raw hardware can’t do it.
- The fix is quantum error correction, which spreads one reliable “logical” qubit across many noisy physical ones and constantly repairs the damage. That overhead is why estimates for cracking RSA-2048 call for on the order of a million physical qubits or more.
- This is the “why not yet” behind the whole quantum threat timeline. Decoherence is what stands between the machines that exist and a machine that could break your encryption.
What is quantum decoherence?
Think of a coin spinning on a table. While it spins, it’s neither heads nor tails, it’s a blur of both at once, and that “both at once” is what a qubit’s superposition is like. Now picture trying to keep that coin spinning in a room where the table is being bumped, a fan is blowing, and the floor is vibrating. Every one of those disturbances nudges the coin, and pretty quickly it topples flat into a plain heads or tails. Decoherence is the environment constantly bumping the table. The qubit’s quantum blur only survives until the outside world knocks it down into an ordinary bit, and then the computation it was carrying is gone.
A quantum computer needs its qubits to stay in that spinning-coin state long enough to run a whole algorithm. The trouble is that the very things that make a qubit controllable, its sensitivity to electromagnetic fields and precise energy states, also make it exquisitely sensitive to noise. Perfect isolation would give unlimited coherence, but a qubit you can’t touch is a qubit you can’t compute with, so real hardware lives with constant leakage of its quantum state into the surrounding material, wiring, and heat.
How does decoherence work?
Decoherence happens when a qubit becomes entangled with its environment instead of staying cleanly on its own. Two flavors of it dominate on real hardware, and you don’t need any math to picture them:
- Energy loss (the T1 process). A qubit sitting in its excited state slowly “relaxes” back down to its ground state, the same way a struck tuning fork fades to silence. The characteristic time for this is called T1. When it happens mid-computation, a qubit that was supposed to hold a 1 quietly decays to a 0.
- Phase scrambling (the T2 process). This one is subtler and usually the tighter constraint. A superposition carries a precise timing relationship between its 0 and 1 parts, and low-frequency noise in the environment jitters that timing until it’s randomized. The characteristic time is called T2, and it’s typically shorter than T1. Once the phase is scrambled, the qubit still holds a 0 or a 1, but the quantum information that made it powerful is lost.
Real machines suffer both at once, plus extra headaches when you scale up, like crosstalk (an operation on one qubit disturbing its neighbors) and correlated noise (a single environmental fluctuation hitting many qubits together). Every gate operation also introduces its own small error, and two-qubit gates are the worst offenders. Add it all up and each qubit has a limited budget of trustworthy operations before decoherence and gate noise together turn its output into garbage.
What is coherence time?
Coherence time is how long a qubit holds its quantum state before decoherence ruins it, and it’s the number that decides how much computation the hardware can actually do. It’s usually reported as the two figures above, T1 (energy) and T2 (phase), and the smaller of the two sets the practical limit.
The concrete numbers matter, because they define the whole problem. On Google’s Willow superconducting processor, one of the most advanced chips publicly demonstrated, the qubits have a mean T1 of about 68 microseconds, approaching 100 microseconds, which was roughly a 5x improvement over the previous generation.
Source: Google Quantum AI, “Meet Willow, our state-of-the-art quantum chip,” December 9 2024, blog.google.
Different hardware makes a very different tradeoff, which is why no single approach has won the race:
| Hardware type | Typical coherence time | Gate speed | The tradeoff |
|---|---|---|---|
| Superconducting (Google, IBM) | Roughly 100 microseconds (Willow T1 ~68 μs) | Very fast (tens of nanoseconds) | Fast gates, short coherence |
| Trapped ion (IonQ, Quantinuum) | Seconds to minutes | Much slower (tens to hundreds of microseconds) | Long coherence, slow gates |
For trapped ions, a specially isolated single-ion qubit has held coherence for more than ten minutes, showing how much longer that modality can retain a quantum state than a superconducting one.
Source: Wang et al., “Single-qubit quantum memory exceeding ten-minute coherence time,” Nature Photonics 11, 646-650 (2017), nature.com.
Here’s the catch that connects coherence time to the whole threat. A superconducting qubit with a ~100 microsecond coherence time and gates that take tens of nanoseconds can run on the order of a few thousand operations before decoherence dominates. That’s plenty for small experiments. It’s nowhere near enough for an attack on real cryptography.
Why does decoherence matter for cryptography?
Decoherence matters for cryptography because it’s the physical wall between the quantum computers that exist and a CRQC that could actually break your keys. The reason is a mismatch between how long qubits survive and how much work the attack requires.
Shor’s algorithm, the routine that breaks RSA and elliptic-curve cryptography, is not a quick calculation. Running it against RSA-2048 takes on the order of a billion sequential quantum operations. A qubit that decoheres after a few thousand operations can’t get anywhere close. Long before the algorithm finishes, every qubit involved has toppled from its spinning-coin state into noise, and the answer dissolves. This is why qubit-count headlines can be misleading. A chip can announce thousands of physical qubits and still be completely unable to threaten cryptography, because those qubits are too noisy to run a deep computation to completion.
So the quantum threat isn’t gated by building more noisy qubits. It’s gated by beating decoherence long enough to run an enormous computation reliably, and the only known way to do that at scale is error correction. That’s the real content behind Mosca’s theorem and the quantum threat timeline: the clock runs on how fast the field can suppress errors, a much harder problem than raw qubit count.
How does error correction fight decoherence?
Quantum error correction fights decoherence by refusing to trust any single qubit. Instead of storing information in one fragile physical qubit, it spreads that information across many physical qubits to build one robust logical qubit, then continuously checks for and repairs the errors that decoherence introduces, faster than the errors accumulate. The distinction between the noisy hardware qubits and the reliable encoded ones is the whole game, and it’s covered in depth under logical versus physical qubits.
The critical property is called operating “below threshold,” which means that adding more physical qubits to a logical qubit makes it more reliable rather than less. Reaching it was an open question for decades, and in December 2024 Google demonstrated it for the first time on a surface code:
- They encoded one logical qubit in a distance-7 code built from 101 physical qubits.
- That logical qubit’s error rate came out to 0.143% per cycle of correction.
- Increasing the code’s size (its “distance”) by two suppressed the logical error rate by a factor of about 2.14 each time, the signature of being below threshold.
- The encoded logical qubit outlived its best individual physical qubit by a factor of 2.4, so the error-correcting overhead finally paid off instead of adding net noise.
Source: R. Acharya et al. (Google Quantum AI), “Quantum error correction below the surface code threshold,” Nature 638, 920-926 (2025), arXiv:2408.13687.
That result is the proof error correction works, and it also shows exactly why a CRQC is still far off. It took 101 physical qubits to make one modest logical qubit. A cryptographic attack needs thousands of logical qubits far more reliable than that, which pushes the physical-qubit count into the millions. The most-cited resource estimates make the scale concrete:
| Estimate | Physical qubits to break RSA-2048 | Time | Key assumption |
|---|---|---|---|
| Gidney & Ekerå, 2021 | ~20 million | ~8 hours | Gate error 0.1%, surface-code cycle 1 μs |
| Gidney, 2025 | Under 1 million | Under 1 week | Improved arithmetic and magic-state techniques |
Sources: C. Gidney and M. Ekerå, “How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits,” arXiv:1905.09749 (2019); C. Gidney, “How to factor 2048 bit RSA integers with less than a million noisy qubits,” arXiv:2505.15917 (2025).
Even the optimistic 2025 figure of under a million qubits sits far beyond the roughly one hundred physical qubits per logical qubit demonstrated so far, and it assumes error rates and control systems the field hasn’t reached at scale. Decoherence is what makes that overhead unavoidable, and closing the gap is the actual work between now and a machine that threatens cryptography.
Common misconceptions
- “A chip with thousands of qubits must be close to breaking encryption.” A large count of noisy physical qubits doesn’t add up to a cryptographic attack. Without error correction to fight decoherence, those qubits can’t run a deep algorithm to completion, and a CRQC is measured in reliable logical qubits, not raw physical ones.
- “Decoherence is just electrical noise you can filter out.” It’s more fundamental than that. Any interaction that lets information about the qubit leak into the environment causes it, so even perfect wiring leaves thermal, magnetic, and material sources. Isolation helps, but a qubit isolated enough to never decohere would also be impossible to control.
- “Error correction eliminates decoherence.” It manages decoherence, it doesn’t remove it. Physical qubits keep decohering constantly; error correction detects and repairs the damage faster than it piles up, at the cost of many physical qubits per logical qubit.
- “Longer coherence time alone gets us to a CRQC.” Coherence time is one factor among several. Gate fidelity, qubit count, connectivity, and the error-correction scheme all matter, and a machine can have decent coherence and still be far from fault-tolerant at cryptographic scale.
- “Quantum-advantage demonstrations prove decoherence is basically solved.” Those demos run shallow circuits chosen to finish inside the coherence budget, and often lean on error mitigation, a statistical stopgap. They don’t show the sustained, deep, fault-tolerant computation that breaking cryptography requires.
Questions people ask
Do I need physics to understand decoherence? No. The one idea that matters is that a qubit computes only while it holds a fragile quantum state, and any contact with the outside world destroys that state. Coherence time is simply how long the qubit lasts before that happens, and everything else follows from the fact that it’s short.
Why does decoherence make a quantum computer hard to build? Because useful algorithms need many operations run in sequence, and a qubit decoheres after only a limited number of them. Bridging that gap requires error correction, which multiplies the hardware you need by a large factor, so a modest logical machine demands an enormous physical one.
What is coherence time in plain terms? It’s the working lifespan of a qubit’s quantum state, usually a few tens to a few hundred microseconds on superconducting hardware and much longer on trapped ions. The shorter it is, the fewer operations you can run before the answer turns to noise.
Does a quantum computer that can break encryption exist yet? No. No machine today can hold enough qubits coherent and error-corrected long enough to run Shor’s algorithm against real key sizes. Published estimates put the requirement at roughly a million or more physical qubits, far beyond current hardware.
If decoherence is such a barrier, why worry about the quantum threat at all? Because the fix, error correction, is advancing, and migration takes years. Data harvested today under harvest-now-decrypt-later stays exposed the moment a capable machine arrives, so the safe move is to finish migrating before decoherence gets tamed at scale, not after.
Is decoherence the same as a quantum computer making mistakes? It’s the main source of those mistakes, together with imperfect gate operations. Decoherence corrupts a qubit even when it’s just sitting idle, which is why simply doing operations faster isn’t enough on its own.
Why don’t we just cool the qubits until decoherence stops? Superconducting qubits already run near absolute zero, and it helps, but it doesn’t stop decoherence, because heat is only one source. Magnetic fluctuations, material defects, and control-system noise all keep leaking the qubit’s state, and the act of controlling the qubit reintroduces coupling to the outside world.
How is a “logical” qubit different from the qubits a company advertises? Advertised counts are physical qubits, the noisy hardware units. A logical qubit is an error-corrected qubit built from many physical ones so it survives decoherence long enough to be useful. The gap between the two is enormous today, which is the heart of logical versus physical qubits.
Everything here is the map, given freely. When your team needs this translated into a migration plan built for your own systems and timeline, that’s the work I do. Request an alignment briefing.
Last verified 2026-07-09 · Maintained by Addie LaMarr, LaMarr Labs.