How fast can anything think?

What is the fastest a thing can change?

Think of a thought as a sequence of changes. A switch flips, a charge moves, a spin turns over. Each step takes the machine from one state to a different one.

Quantum physics puts a floor under how long that takes, and the floor depends on energy. Every state has an energy, and a system with more energy wiggles faster. A state is like a spinning dial: to become a different state, the dial has to turn far enough that the new reading can be told apart from the old one for certain. The more energy the dial has, the faster it spins, and the sooner that happens.

Picture two clocks. One has a slow second hand, the other a fast one. Ask each how soon its hand points somewhere clearly different from where it started. The fast one wins, always. In quantum physics the "speed of the hand" is the energy. A system holding no spare energy at all does not change, and one holding a lot can change very quickly.

Guess first You have a fixed amount of energy to spend on speed. Does the top speed depend on how big the computer is, or only on the energy?

Only on the energy. Size does not appear in the limit. Two computers with the same energy to spend have the same ceiling, one the size of a grain of sand and one the size of a room. Doubling the energy doubles the ceiling.

The resulting bound is proportional to energy. The maximum rate uses a fixed conversion factor built from Planck's constant.

Pour a kilogram of anything into this, convert every atom of it into energy by Einstein's rule, and spend all of it on computing. The ceiling comes out at 5.4 × 10⁵⁰ steps a second. Seth Lloyd, who worked this out in 2000, called a machine like that the ultimate laptop.

That number is hard to feel, so compare it. The first exascale supercomputer of the 2020s did about 1.1 × 10¹⁸ arithmetic operations a second. The ultimate laptop is 4.9 × 10³² times faster, and it is one kilogram.

The bound is established, but no one knows how to build such a computer, and the Vigil does not attempt it. Converting a kilogram into energy does not provide the containment, logic or readout needed for a working processor. The bound describes a physical limit without supplying an engineering design.

The limit applies to transitions between distinguishable states. Whether each of those changes is an operation, in the sense of a useful step of a calculation, is something physicists still argue about frontier. The edge, at the bottom of the page, says exactly how.

How many steps does energy buy?

In words: the top speed is proportional to energy. Spend more energy, take more steps a second. In symbols, with E the energy above the system's quietest state:

steps per second ≤ 2E / (π ħ)

E is the energy, in joules, that the computer holds beyond its ground state.
ħ is the reduced Planck constant.
The 2/π is the part that falls out of the proof. The fold below shows where it comes from.

Put a joule in and the answer is 6.0 × 10³³ steps a second. This is the Margolus-Levitin bound, after the two physicists who proved it in 1998. Equivalently, one step takes at least 1.7 × 10⁻³⁴ seconds when you hold one joule.

For a mass you add Einstein's rule, E = mc². One kilogram holds 9.0 × 10¹⁶ joules of rest energy, and that is how the ceiling of 5.4 × 10⁵⁰ steps a second arises. One step then lasts 1.8 × 10⁻⁵¹ seconds, which is 3.4 × 10⁻⁸ of the Planck time, the smallest tick physics has a name for.

An older, rougher version is Bremermann's limit. Hans Bremermann argued in 1962 that a kilogram can process at most c²/h bits a second, which comes to 1.4 × 10⁵⁰. That is exactly four times smaller than Lloyd's number: the two differ only in the constant. Bremermann reached his by a looser use of the energy-time uncertainty relation, which drew criticism. Lloyd's constant comes out of a proof, the one in the fold below, and it is the one this site uses.

What the Vigil's power buys, treating each second of its output as the energy that sits in the computer:

Energy	Most steps a second
One joule	6.0 × 10³³
One second of the Vigil's first petawatt (1 × 10¹⁵ J)	6.0 × 10⁴⁸
One second of the plan's goal for the Vigil (1 × 10²⁰ J)	6.0 × 10⁵³
One kilogram, all of it	5.4 × 10⁵⁰
A year of the Vigil's first petawatt, as mass (351,126 kg)	1.9 × 10⁵⁶

A mind holds 1 × 10¹⁷ bits. With one petawatt-second of energy, the ceiling would let it be updated 6.0 × 10³¹ times a second, whole, every bit.

The Margolus-Levitin ceiling on log axes: the most operations per second a given energy can drive grows in a straight line with the energy. Nothing can sit above the line.

With JavaScript on, this is a calculator: pick an energy and it shows the most steps a second, the shortest step, and how it compares with a mind, an exaflop machine and the Landauer bill. The table above gives the same numbers for five amounts of energy.

Does the ceiling come free of the cost of forgetting?

No, and that is why this topic leans on The cost of forgetting. Suppose the ultimate laptop erased one bit at every step into 300 K surroundings. At 2.9 × 10⁻²¹ joules a bit, the heat would flow at 1.6 × 10³⁰ watts, which would burn through the kilogram's whole energy in 5.8 × 10⁻¹⁴ seconds.

So a machine that runs near the speed ceiling cannot also forget at that pace. It has to compute almost entirely without erasing, which is the subject of Computing without forgetting. Speed and cheapness together need reversible logic.

Two more limits press on the same machine. Light is too slow for it: in one step light travels 5.5 × 10⁻⁴³ metres. Even across a ten-centimetre cube, 1.8 × 10⁴¹ steps happen in the time a signal makes one trip. Such a machine cannot be one thinker. It must be an enormous number of very small ones, and that is the story of Big minds are slow minds. And a machine this energetic needs room for its memory, which is the story of How much can a region remember?. The limiting case of both is a black hole, the last page of this strand: The ultimate computer is a black hole.

Open everything

Where does 2E / πħ come from?The two speed limits, derived: complex exponentials and one clever inequality

What "a step" means here

The bound is about a state changing into a state that can be told apart from it with certainty, which means orthogonal. Only orthogonal states can be distinguished without any chance of error, and a bit flip is a change between two of them.

Start in a state $|\psi_0\rangle$ and let it evolve under a time-independent Hamiltonian $H$ . Write the state in terms of energy eigenstates, $|\psi_0\rangle = \sum_n c_n |E_n\rangle$ , with probabilities $p_n = |c_n|^2$ . Measure energy from the ground level, so every $E_n \ge 0$ . The overlap with the starting state at time $t$ is

$S(t) = \langle \psi_0 | \psi_t \rangle = \sum_n p_n \, e^{-iE_n t/\hbar}$

The state has become orthogonal when $S(t) = 0$ . Let $\tau$ be the first such time. Two bounds on $\tau$ are known, and each uses a different property of the energy distribution: its mean $E = \sum p_n E_n$ , or its spread $\Delta E$ .

The smallest case: a two-level system

Take two levels, at energies 0 and $E_1$ , in an equal superposition $(|0\rangle + |1\rangle)/\sqrt 2$ . The mean energy is $E = E_1/2$ and the spread is $\Delta E = E_1/2$ as well. The overlap is

$S(t) = \tfrac12\left(1 + e^{-iE_1 t/\hbar}\right)$

It vanishes exactly when $E_1 t/\hbar = \pi$ , so

$\tau = \frac{\pi\hbar}{E_1} = \frac{\pi\hbar}{2E}$

That is a flip of a single qubit, and it equals the Margolus-Levitin limit exactly. No other two-level state does better, and the next sections show that nothing can.

The Margolus-Levitin bound

The proof rests on one inequality, true for every $x \ge 0$ :

$\cos x \;\ge\; 1 - \frac{2}{\pi}\left(x + \sin x\right)$

It holds with equality at $x = 0$ and $x = \pi$ . To see that it holds everywhere else, call the difference $f(x) = \cos x - 1 + \tfrac{2}{\pi}(x + \sin x)$ . Its slope, written with half-angles, is

$f'(x) = \frac{2}{\pi}(1 + \cos x) - \sin x = 2\cos\frac{x}{2}\left(\frac{2}{\pi}\cos\frac{x}{2} - \sin\frac{x}{2}\right)$

On $0 \le x \le \pi$ the slope is positive until $\tan(x/2) = 2/\pi$ and negative after, so $f$ climbs from zero and comes back down to zero at $\pi$ , never dipping below. Past $\pi$ , $x + \sin x$ only grows (its slope is $1 + \cos x \ge 0$ ), so the right-hand side sits at or below $-1$ , and no cosine is smaller than that. The inequality bounds the cosine from below and becomes an equality at a half-turn.

Take the real part of $S(t)$ , apply the inequality term by term with $x = E_n t/\hbar$ , and use $E_n \ge 0$ :

$\operatorname{Re} S(t) = \sum_n p_n \cos\frac{E_n t}{\hbar} \;\ge\; 1 - \frac{2}{\pi}\left(\frac{E\,t}{\hbar} - \operatorname{Im} S(t)\right)$

The sine term sums to $-\operatorname{Im} S$ . At $t = \tau$ , $S = 0$ , so both its real and imaginary parts vanish:

$0 \;\ge\; 1 - \frac{2E\tau}{\pi\hbar} \quad\Longrightarrow\quad \tau \;\ge\; \frac{\pi\hbar}{2E}$

A bound on the time between orthogonal states is a bound on their rate: no more than $1/\tau \le 2E/\pi\hbar$ such steps a second. That is the number in the table above.

Only the mean energy above the ground state, $E$ , appears, and the inequality is used exactly once. Nothing depends on how many levels there are, how they are spaced, or what the system is made of. The bound therefore makes no reference to the size of the system, which answers the question in the story.

The Mandelstam-Tamm bound

The older bound, from 1945, uses the spread of the energy. Let $A = |\psi_0\rangle\langle\psi_0|$ be the projector onto the starting state, so $\langle A \rangle = P(t) = |S(t)|^2$ . Two facts do the work:

Its rate of change obeys $\dot P = \tfrac{i}{\hbar}\langle [H, A]\rangle$ .
The Robertson uncertainty relation gives $\Delta E \cdot \Delta A \ge \tfrac12 |\langle [H,A]\rangle|$ , and since $A^2 = A$ , $\Delta A = \sqrt{P(1-P)}$ .

Together they give $|\dot P| \le (2\Delta E/\hbar)\sqrt{P(1-P)}$ . Write $P = \cos^2\theta$ ; then the bound turns into $|\dot\theta| \le \Delta E/\hbar$ . The angle $\theta$ is a distance in the space of states, and $\Delta E/\hbar$ is the greatest speed at which a state can move through it. Going from $\theta = 0$ to the orthogonal state at $\theta = \pi/2$ takes at least

$\tau \;\ge\; \frac{\pi\hbar}{2\,\Delta E}$

Which bound wins?

Both hold at once, so $\tau \ge \max\!\left(\pi\hbar/2E,\; \pi\hbar/2\Delta E\right)$ . Each can be the tighter one.

Put a tiny probability $p$ on a high level $E_1$ and the rest on the ground. Then $E \approx pE_1$ but $\Delta E \approx \sqrt p\,E_1$ , which is much larger. The Margolus-Levitin bound is the stricter. This is the state of a computer holding little energy in total.
A state concentrated tightly around a high energy has a small $\Delta E$ next to $E$ , and the Mandelstam-Tamm bound is the stricter.

For the two-level state above both are equal, and the flip is as fast as nature allows.

Many steps in a row run at half the pace

The two-level flip is special in one way: after a step it is back where it started, so it only ever visits two states. A computation wants to pass through a long chain of states, each different from all the ones before. Margolus and Levitin asked how fast that can go. For a system that runs round a cycle of $N$ mutually orthogonal states at a steady rate, they found the time per step is at least

$\tau_N \;\ge\; \frac{N-1}{N}\,\frac{\pi\hbar}{E}$

For $N = 2$ this is the flip again, $\pi\hbar/2E$ . For a long chain the time per step tends to $\pi\hbar/E$ , twice as long, and they showed that this long-run rate, $E/\pi\hbar$ or 3.0 × 10³³ steps a second per joule, can be approached by an ordinary large system. That is the figure their own paper quotes. Lloyd's ceiling counts the simplest step, the flip of one bit (a NOT, or the controlled flips that build every logic gate), which is the two-state case; gates that cycle through more states run at up to half that rate. Either way the ceiling stands: no step is faster than $\pi\hbar/2E$ .

From one state to a whole computer

A computer is a collection of parts, and the energy adds: if each part $i$ carries energy $E_i$ , the parts can together make at most $\sum_i 2E_i/\pi\hbar = 2E/\pi\hbar$ steps a second. This is the sense in which the bound is about energy alone: it does not matter how the energy is shared out. Give a thousand gates a thousandth of the energy each and each runs a thousand times slower, so the total count of steps a second is unchanged. Serial or parallel, the budget is the same.

Insert $E = mc^2$ , with $2/\pi\hbar = 4/h$ , and you get Lloyd's $4mc^2/h$ steps a second. Bremermann's $mc^2/h$ is the same expression with the factor 4 missing.

Is it a real limit on computers, and what counts as an operation?The unified bound, open systems, and a loophole in the word step

The unified bound is tight

Margolus and Levitin, and Mandelstam and Tamm, each found a bound; Lev Levitin and Tommaso Toffoli asked in 2009 what happens when you use both. They proved that the two together give the exact picture. If the spread of energy $\Delta E$ equals the mean $E$ , as in the two-level flip above, some states reach the bound exactly. Otherwise no state reaches it, but for any pair of values $\Delta E$ and $E$ a family of states gets as close as you like. They present this as the fundamental quantum limit on the rate of operation of any information-processing system. Because the bound is tight, the formula is the exact limit and not a loose estimate.

The machine needs to be entangled

Vittorio Giovannetti, Seth Lloyd and Lorenzo Maccone looked in 2003 at a machine whose energy is divided among many parts, and asked how fast the state of the whole machine can move to a distinguishable one. If the parts are unentangled, it cannot reach the speed its total energy allows: entanglement is needed for the ultimate evolution speed. This does not take back the sum over gates in the fold above. Counted as Lloyd counts, as the total number of flips made by all the parts, a crowd of small independent processors still meets the ceiling. What the unentangled crowd cannot do is move its joint state as fast as one entangled object with the same energy. To reach the ceiling with a single thread of change, the whole machine stepping as one, the parts must be entangled.

A real computer is an open system

The proofs above assume a closed system whose evolution is exactly unitary. Real hardware leaks into its surroundings, dumps heat, and corrects errors. Several teams extended the speed limits to that case in 2013: Adolfo del Campo and colleagues derived a time-energy uncertainty relation for open systems whose evolution is completely positive and trace preserving. Marcelo Taddei and colleagues derived an attainable bound for noisy processes, tied to the quantum Fisher information. The 2017 review by Sebastian Deffner and Steve Campbell collects the field, from the uncertainty principle to optimal quantum control. These bounds replace the energy with quantities that depend on the noise, so open-system speed limits form a family whose applicable member depends on the environment. frontier

What counts as an operation?

The speed limit counts something exact: transitions between orthogonal states. Levitin and Toffoli's abstract says that such a transition "can be taken as the elementary step" of a computation. Relating that transition to useful computation requires further assumptions.

First, a useful step of a calculation, such as adding two numbers, takes many flips in a row, and a long chain of states already runs at half the two-state pace (the fold above). The ceiling counts changes of state. Useful steps a second can only be fewer, and the ceiling does not say how many fewer: that depends on the program and the hardware.

Second, Stephen Jordan showed in 2017 that energy considerations alone give no upper bound on computational speed. He built time-independent Hamiltonians where the computational clock speed grows arbitrarily large relative to $E$ and $\Delta E$ as the number of steps grows, and concluded that further assumptions, such as limits to information density and the speed of information transmission, are needed to bound computational speed. The theorem still bounds state evolution. A bound on program execution speed requires additional constraints.

The Vigil's computing speed faces several constraints. Energy limits state evolution. Information density gives the second (How much can a region remember?), and the speed of light gives the third (Big minds are slow minds). Together these constraints describe aspects of computing speed; none alone determines how fast a useful calculation runs. frontier