Quantum Speed Limits
Landauer's principle bounds the heat of forgetting. It says nothing about speed
— how many operations a machine can rush through per second. You might think speed is purely an
engineering matter, limited only by how fast you can build things. It isn't. Quantum mechanics imposes
a fundamental ceiling on the rate of computation, set by one quantity alone:
energy. A system with more energy can change its state faster; a system with little
energy is sluggish, no matter how cleverly it is engineered. This is a completely different currency
from Landauer's — joules-per-erasure versus joules-per-tick — and reversible computing, which escapes
the first, is bound just as tightly by the second.
Two bounds on how fast a state can change
"Doing something" quantum-mechanically means evolving a state
|\psi\rangle into a distinguishable (orthogonal) state
|\psi^{\perp}\rangle — that is the elementary tick of any quantum
computation. How long must that take? Two theorems answer, from two different features of the energy:
- Mandelstam–Tamm (1945): the time to reach an orthogonal state obeys
\tau \ge \dfrac{\pi\hbar}{2\,\Delta E}, set by the energy
uncertainty \Delta E (the spread of the state's energy);
- Margolus–Levitin (1998): the time also obeys
\tau \ge \dfrac{\pi\hbar}{2\,\langle E\rangle}, set by the
mean energy \langle E\rangle above the ground state;
- both must hold, so the true limit is the tighter (larger) of the two;
- equivalently, a system of mean energy E passes through at most
\dfrac{2E}{\pi\hbar} distinguishable states per second.
The two are subtly different. Mandelstam–Tamm limits you by how spread out the energy is;
Margolus–Levitin by how much energy you have above the floor. A state can have a large mean
energy but small spread, or vice versa, so neither bound dominates the other in general — you must
respect both, and whichever is stronger wins.
The ceiling, in numbers
Take the Margolus–Levitin rate and put in one joule of energy. With
\hbar = 1.055 \times 10^{-34}\ \mathrm{J\,s},
\frac{2E}{\pi\hbar} \;=\; \frac{2 \times 1}{\pi \times 1.055 \times 10^{-34}}
\;\approx\; 6 \times 10^{33}\ \text{state changes per second}.
Six thousand billion billion billion basic operations per second, per joule of energy — and that is a
hard ceiling, independent of transistors, materials, temperature, or any future invention. It
is pure quantum kinematics: energy sets the clock rate of the universe. The graph shows the rule's
stark linearity — double the energy, double the maximum speed.
Notice what this does not depend on: not the number of parts, not the cleverness of the
algorithm, not the temperature. If you want a faster computer in this ultimate sense, your only lever
is to give it more energy.
Two orthogonal currencies
It is worth pinning down exactly how this relates to Landauer, because the two are constantly confused.
| Landauer's principle | Margolus–Levitin |
|---|
| What it bounds | heat dissipated | rate of state change |
| Charged for | each erased bit | each distinguishable tick |
| The quantity | kT\ln 2 per bit | 2E/\pi\hbar ticks/s |
| Reversible computing… | dodges it (no erasure) | cannot dodge it |
This is the crucial punchline. Reversible computing was invented to escape Landauer — and it does, by
never erasing. But it buys no exemption from the speed limit. Even a perfectly reversible, perfectly
cold, zero-dissipation computer can still only change its state at most
2E/\pi\hbar times per second. Energy-per-erasure and energy-rate-per-speed
are different taxes levied by different laws; paying off one leaves the other untouched.
A tempting escape: if one lump of energy E gives
2E/\pi\hbar ticks per second, why not divide the energy among a thousand
little processors and let them all tick in parallel? Look closely and the trick evaporates. Split
E into N parts and each part, with energy
E/N, ticks only 2(E/N)/\pi\hbar times per second
— slower by exactly the factor N. Multiply back by the
N processors and the total tick-rate is unchanged:
2E/\pi\hbar. Parallelism buys you a serial-vs-parallel trade
— many slow steps instead of few fast ones — but the total number of distinguishable state changes per
second, summed over the whole machine, is fixed by the total energy and nothing else. The speed limit
is a statement about a fixed energy budget, and slicing the budget up cannot conjure more.
The bound 2E/\pi\hbar counts transitions to
distinguishable states — a very generous notion. It is not a count of "useful instructions",
"floating-point operations", or "answers computed". A real computation reaching an orthogonal state
might have done something profound or nothing at all; the limit does not care. So do not read
10^{33} ops/s/J as "you could do
10^{33} multiplications per second per joule" — most of those state changes
would be internal shuffling, error correction, and idling. The speed limit is an
existence ceiling on raw dynamical change, not a promise of that much useful work. Treat it as
a wall no machine can pass, not a spec sheet.