Computing without forgetting

Can a computer think without forgetting anything?

The cost of forgetting left us with a rule: wiping a bit of memory you have not read costs heat, at least k T ln 2. Everything else a computer does can, in principle, be free. So the obvious question is whether a computer can be built that never wipes anything.

Look at an ordinary logic gate. An AND gate takes two bits in and puts one bit out. If the output is 0, the inputs could have been 00, 01 or 10, and the gate has no way to say which. The difference between those three cases is simply gone. That loss is the erasure, and it is where the heat comes from. Most of the gates in a computer of the 2020s work this way: many ways in, fewer ways out.

Imagine instead a gate with as many outputs as inputs, wired so that every output pattern comes from exactly one input pattern. Nothing merges. Run it forward and you get an answer; run it backward and you get the question back. It is a shuffle, like shuffling a deck of cards, and a shuffle can always be undone. The information is retained throughout the shuffle.

Such gates were found around 1980, and they are enough to build any computation. The Toffoli gate watches two bits and flips a third only when both are 1. The Fredkin gate swaps two bits only when a third is 1. Neither ever loses anything.

Useful computations also produce intermediate results, such as the carries in addition. A reversible adder cannot just let them go, because letting go is forgetting. They are garbage: bits of no use that cannot be thrown away. You have three choices. Keep the garbage, and your memory fills. Erase it, and you pay the heat after all. Or use the trick Charles Bennett published in 1973: copy the answer out, then run the whole computation backwards. The garbage unwinds into blank bits, ready to be used again, and nothing was forgotten.

Bennett's trick. Run forward, copy the answer to a fresh cell, run backwards. The garbage returns to blank, and the only thing left over is the answer, which you wanted.

Guess first You run a calculation forward, copy the answer to a fresh blank cell, then run the whole calculation backwards. What is left?

The input you started with, plus a copy of the answer. The copy is safe because it was made by a reversible step (onto a blank cell, which costs nothing), and running backwards never touches it. Every other cell is back to blank.

Uncomputing uses extra time and memory. The computer does about twice the work, and it needs room to hold the garbage in the meantime. It pays in time and memory instead of heat. The Vigil does most of its thinking this way and pays heat only where it truly forgets. These costs depend on the circuit and on how intermediate states are stored.

What does the garbage cost?

Start with the gates. A Toffoli gate acts on three bits, so it shuffles their eight possible states, and it swaps exactly one pair of them (110 and 111). There are 40,320 ways to shuffle eight states, so 40,320 reversible functions take three bits to three bits, out of 16,777,216 functions of any kind. Feed a Toffoli a fresh 0 as its third bit and it computes AND of the first two, keeping both; feed it a 1 and it computes NAND. NAND alone can build any circuit, so Toffoli gates, given a supply of fresh bits, can build anything.

Take a real circuit. A ripple-carry adder for n-bit numbers, built from Toffoli and CNOT gates (a CNOT flips one bit when another is 1), uses four gates per bit: two Toffolis for the carry and two CNOTs for the sum. It leaves the n − 1 inner carries behind, garbage that depends on the numbers added. For a 64-bit adder:

256 gates run forward and leave 63 garbage bits.
Erase them and the floor is 1.8 × 10⁻¹⁹ joules of heat per addition at 300 K, or 1.8 × 10⁻²⁰ joules at the radiators' 30 K: 63 times the single-bit cost from The cost of forgetting.
Keep them and no heat is paid, but memory fills. A machine doing 1.0 × 10¹⁵ additions a second piles up 6.3 × 10¹⁶ garbage bits a second. A mind's whole state is 1 × 10¹⁷ bits, so that is a mind's worth of garbage every 1.6 seconds.
Uncompute them and you run 577 gates: 256 forward, 65 to copy the sum and its last carry out, and 256 back. That is 2.25 times the work, with no pile and nothing forgotten.

With JavaScript on, this is a calculator: choose an adder width, how many additions, and where the heat goes, then keep, erase or uncompute the garbage and read off the heat, the memory and the gate steps. The list above gives the numbers for a 64-bit adder.

Erasing at the floor sounds cheap: the machine above would dissipate 1.8 × 10⁻⁴ watts in erasure, whereas the switching of a 2020s gate spent 1 × 10⁻¹⁶ to 1 × 10⁻¹³ joules per switch, many orders of magnitude more than the floor. The floor matters at the Vigil's scale: a petawatt spent entirely on erasing adder garbage at 30 K caps out at 5.5 × 10³⁴ additions a second. Uncomputing removes the cap.

Can you hold less than the whole pile?

Uncomputing the simple way holds the garbage of every step until the end, so memory grows with the length of the calculation. In 1989 Bennett showed you can keep only checkpoints and recompute the rest. Cut a calculation of 1,048,576 steps into segments, those into segments again, and so on. With no erasure at all, each way of cutting costs:

Levels	Segments per level	Checkpoints held at once	Time, in plain runs
1 (keep everything)	1,048,576	1,048,576	2.0
2	1,024	2,047	4.0
4	32	125	15
20	2	21	3,325

A million checkpoints become twenty-one, at the price of thousands of times the work. Memory trades for time: either can be made small, but not both at once. The fold below shows where the table comes from.

Why can switching be nearly free?

The other half of the story is the wires. Even a reversible gate is built from switches that charge tiny capacitors, usually by connecting the full supply voltage at once. Half the energy drawn then turns into heat in the wire, whatever its resistance. Ramp the voltage up slowly instead, over a time much longer than the circuit's own charging time RC, and the heat falls in proportion: a ramp 100 times RC loses only 2.0 percent of the abrupt loss, 1,000 times RC 0.20 percent, 10,000 times RC 0.020 percent. Go twice as slowly, lose half as much. This is adiabatic switching; the energy not lost goes back to the supply when the gate switches back.

How slow is slow enough? Suppose a gate of the 2020s spent its whole energy on abrupt charging. To bring one switch down to the cost of forgetting one bit at 300 K, the ramp would have to last about 7 × 10⁴ to 7 × 10⁷ times RC. Reducing dissipation this way lowers the switching rate.

Open everything

How does reversibility get around the floor, and how does the checkpoint trick work?A counting argument, three stages of a machine, a recursion and one integral

Why a shuffle costs nothing

Take the argument from the The cost of forgetting page and run it on a gate. The second law needs the total entropy of the gate and its surroundings never to fall, and entropy counts the possibilities you cannot tell apart, $S = k\ln W$ . If the gate takes $W_\text{in}$ equally likely inputs to $W_\text{out}$ distinguishable outputs, the memory's entropy falls by $k\ln(W_\text{in}/W_\text{out})$ , and the surroundings must gain at least that much, which at temperature $T$ means heat

$Q \ge kT\ln\frac{W_\text{in}}{W_\text{out}} \qquad \text{(in general } Q \ge kT\,[H_\text{in}-H_\text{out}]\ln 2\text{, with } H \text{ in bits)}$

If the gate is a bijection, every output comes from exactly one input, so $W_\text{out}=W_\text{in}$ , the logarithm is zero, and so is the floor. AND takes four equally likely inputs to an output that is 0 three times in four, so the entropy falls from 2 bits to about 0.81, and the floor is 1.19 $kT\ln 2$ . A Toffoli gate maps eight states to eight, with floor zero.

Bennett's history tape

In 1973 Bennett considered a machine that steps through states $x_0 \to x_1 \to \dots \to x_T$ , where some steps lose information. Make each step reversible by also writing down whatever it would have lost. Call it $h_i$ ; for the adder, $h_i$ is a carry. Three stages follow:

$(x_0,\ 0,\ 0) \to (x_T,\ h_1\cdots h_T,\ 0) \to (x_T,\ h_1\cdots h_T,\ x_T) \to (x_0,\ 0,\ x_T)$

First, run forward, with the history on a tape that only grows. Every step is a bijection, so this costs no heat. Second, copy $x_T$ onto a blank register: a CNOT, also a bijection. Third, run the first stage backwards, and the tape unwinds to blank. The machine ends where it started, plus a copy of the answer, in time $2T$ plus the copy. The space is the original space plus the history, and the stored history grows with $T$ .

Bennett's checkpoints

Bennett's 1989 paper recomputes instead of remembering. He framed it as a pebble game: a pebble on a step means that step's state is held, and a pebble may be put on or taken off a step only while the step before it holds one, because a reversible step can be run either way only from the state before it.

Cut a computation of $T = k^n$ steps into $k$ segments, each segment into $k$ more, down $n$ levels. Define a procedure for level $n$ that starts from the state at the beginning of a block and adds the state at its end, leaving nothing else behind:

Run segments 1 to $k$ in turn, each by the level- $(n-1)$ procedure, starting from the checkpoint the one before it left. That is $k$ runs, and it leaves $k$ checkpoints.
Run segments $k-1$ down to 1 backwards by the same procedure in reverse, which removes their checkpoints. That is $k-1$ runs.

Only the start and the end remain. At the top level that is what the 1973 trick leaves: the input and the answer. Counting runs, the time $R(n)$ obeys

$R(n) = (2k-1)\,R(n-1), \qquad R(0)=1 \quad\Rightarrow\quad R(n) = (2k-1)^n$

against $k^n$ steps for the original, a slowdown of $\left(\frac{2k-1}{k}\right)^n$ : the last column of the table. With $T=k^n$ ,

$R = T^{\log_k(2k-1)} = T^{1+\varepsilon}, \qquad \varepsilon=\frac{\log(2-1/k)}{\log k} \approx \frac{1}{\log_2 k} \ \text{for large } k$

For $k=2$ the exponent is $\log_2 3\approx 1.585$ ; for a million segments at one level it is $1.05$ . While working on the last segment of a level, the machine holds $k-1$ checkpoints there, plus whatever the level below is holding, so at most

$n(k-1)+1 \ \text{checkpoints, each a whole machine state of size } S$

which is the third column. For fixed $k$ , $n=\log_k T$ , so the space is $O(S\log T)$ . That is Bennett's theorem: an ordinary computation taking time $T$ and space $S$ can be done reversibly in time $O(T^{1+\varepsilon})$ and space $O(S\log T)$ for any $\varepsilon>0$ , or in linear time and space $O(S\,T^{\varepsilon})$ . The constant hides the trade: $\varepsilon \approx 1/\log_2 k$ means $k \approx 2^{1/\varepsilon}$ , so the closer you push the time to linear, the faster the checkpoint count grows.

Adiabatic charging, with one integral

Charge a capacitor $C$ to voltage $V$ through a resistance $R$ . Switch the supply to $V$ at once and the capacitor ends with $\tfrac12 CV^2$ , while another $\tfrac12 CV^2$ is dissipated in $R$ , whatever the value of $R$ . Instead, ramp the supply linearly over a time $\tau\gg RC$ . The capacitor follows the supply, so the current is nearly constant:

$I \approx C\,\frac{dV}{dt} = \frac{CV}{\tau}, \qquad E_\text{diss} = \int_0^\tau I^2 R\,dt = \left(\frac{CV}{\tau}\right)^2 R\,\tau = \frac{RC}{\tau}\,CV^2$

Divided by the abrupt cost $\tfrac12 CV^2$ , that is $2RC/\tau$ , the ratio used in the numbers above. The product $E_\text{diss}\,\tau = RC\cdot CV^2$ does not depend on the ramp: halving the loss doubles the time, with no floor until something else (leakage, noise, a real erasure) takes over. To get the energy back, the supply must take it in again when the gate switches the other way. Circuits built for this use a resonant "power clock" that swings energy between a coil or resonator and the gates, like a child on a swing; whatever the swing loses per cycle is the dissipation.

Bennett's 1982 review finds the same trade in a very different machine. A Brownian computer is jostled by heat into a random walk along its computation, with a weak push forward. Its drift speed is proportional to the push, so the energy it dissipates per step goes to zero only as its speed does. The ceiling on How fast can anything think? is a different kind of limit: it counts the energy a system holds above its ground state. Dissipation measures the energy lost. A machine that returns its energy after each step can hold substantial energy while dissipating little.

Has anyone built it, and what is still argued?Billiard balls, adiabatic chips, superconducting circuits, no math

Conservative logic

Tommaso Toffoli's 1980 paper Reversible computing showed that any computation can be embedded in an invertible one. Edward Fredkin and Toffoli's 1982 paper Conservative logic turned that into a design, logic that obeys the laws physics obeys: reversibility and conservation. It showed that universal computing survives those rules, introduced the Fredkin gate, and gave the best-known picture of the field, a computer of identical balls bouncing elastically off each other and off walls.

The billiard-ball computer is a thought experiment. Bennett's 1982 review points out that it needs perfect parts and perfect isolation from thermal noise, which would eventually knock the balls off course. Keeping them on course means removing noise, and throwing out entropy is the Landauer cost. Correcting errors requires entropy removal, so residual noise causes dissipation in a real machine.

Adiabatic CMOS

In 1994 William Athas, Lars Svensson and colleagues described adiabatic switching for ordinary transistor logic, in which the energy stored on a circuit's capacitances is recycled instead of turned into heat. That is the ramp argument from the numbers stretch, applied to silicon.

Michael Frank has made the case for decades. In 2025, writing with Edwards at Vaire Computing, a company that builds adiabatic reversible chips, he pointed out that industry roadmaps projected only about a twofold gain in gate power efficiency over the next dozen years, traced that to the thermodynamics of a reliable transistor switch, and argued for adiabatic reversible CMOS powered by high-quality resonators. The unresolved engineering questions are whether resonators can be good enough, and whether the power clocks' overhead eats the savings.

Superconducting reversible logic

Superconducting circuits suit adiabatic logic, because a resonator with almost no loss is exactly what a power clock needs. In 2013 Naoki Takeuchi, Yuki Yamanashi and Nobuyuki Yoshikawa coupled an adiabatic quantum-flux-parametron (AQFP) gate to a superconducting resonator and measured its bit energy: about 1 × 10⁻²⁰ joules at 5 GHz. That is only 3.5 times the Landauer cost at 300 K, and far below any conventional gate. That comparison uses a warmer reference temperature: a superconducting chip sits a few degrees above absolute zero, where the floor is much lower, and the refrigerator costs extra.

In 2017 the same group studied a reversible version of the gate in simulation. Its junctions evolve reversibly in time, physically as well as logically, and its dissipation fell below the Landauer bound as the operating frequency was lowered: no floor, only a trade against speed. Gates that erase, or that are only partly reversible, were dominated by non-adiabatic losses, so the whole circuit has to be reversible to profit.

A measurement followed. frontier In a preprint of December 2025, published in IEEE Transactions on Applied Superconductivity in 2026, Sergey Tolpygo, Evan Golden and Vasili Semenov reported a circular shift register of Josephson vortices whose energy per bit-shift was below k T ln 2 for propagation delays up to about 0.7 ns, information circling at up to about 1.4 GHz. Information is not destroyed, so this does not contradict Landauer. A second register, built partly from devices proposed for reversible computing, did no better than about 16 times k T ln 2. As of 2026 the demonstrated device moves bits around a loop; general processing remains unshown.

Space alone

Klaus-Jörn Lange, Pierre McKenzie and Alain Tapp showed in 2000 that a reversible machine can simulate any ordinary one in the same space (at a large cost in time), answering a question Bennett had posed in 1989 and showing that his checkpoint game is not the only way to play. Their result counts space alone; when time matters too, Bennett's trade is the one this page uses.

What it means for the Vigil

The gates of a quantum computer are reversible by nature, and the Toffoli gate is a standard one in quantum programs (What a quantum computer is, and is not). The Vigil balances memory use, heat removal and computing speed. Keeping information costs memory, forgetting it costs heat (Entropy is missing information says why information and entropy are one quantity), and a slower clock buys cooler thinking. Its architecture selects a practical balance within those constraints.