Conservative logic

TL;DR — In 1982 Fredkin and Toffoli showed that universal computation does not require erasing information, and therefore does not require dissipating energy: a computer built from reversible, "conservative" primitives — idealized as billiard balls bouncing off mirrors — could in principle compute at zero energy cost per operation. This was a beautiful irrelevance when logic gates burned ~10⁸ kT per switch. Today, device energies sit within a few orders of magnitude of the Landauer limit, AI datacenters are power-bound at gigawatt scale, and startups are taping out reversible chips. The paper is no longer physics recreation; it is a live engineering roadmap.

The idea: computation as frictionless physics

The paper starts from Landauer's 1961 observation: the only fundamentally irreversible act in computing is erasing a bit, which must dissipate at least kT \ln 2 of heat (about 3 \times 10^{-21} J at room temperature — call it "one Landauer"). A NAND gate erases: two input bits become one output bit, and the lost bit's entropy has to go somewhere, namely into heat. Bennett had shown in 1973 that erasure is avoidable in principle; Fredkin and Toffoli's contribution was to make this concrete, mechanistic, and — crucially — physical.

They propose conservative logic: a logic family whose primitives conserve two things. First, information — every gate is a bijection from inputs to outputs, so you can run it backwards. Second, tokens — the number of 1s in equals the number of 1s out, so bits behave like conserved particles rather than abstract symbols. The workhorse is the Fredkin gate: three wires (c, a, b); if c = 0, a and b pass straight through; if c = 1, they swap. It's a controlled crossbar. It is its own inverse, it conserves 1s, and — with constant inputs and by ignoring some outputs — it computes AND, OR, NOT, and fan-out. One reversible primitive is universal.

The second half of the paper grounds this in mechanics: the billiard-ball model. A bit is the presence or absence of a hard sphere at a lattice site at a clock tick. Elastic collisions between balls compute the "interaction gate" (from which you build a Fredkin gate); fixed mirrors route signals. Elastic collisions dissipate nothing and lose no information — the whole machine is a Hamiltonian system, and universal computation rides on top of it for free. Computing is not something you do despite physics, paying an energy tax per step; computing is reversible physics, and the tax is a design flaw of irreversible logic.

The paper also confronts the obvious objection: reversible circuits produce "garbage" outputs needed to maintain the bijection. Fredkin and Toffoli, following Bennett, note that garbage can be uncomputed — run the circuit forward, copy the answer, run it backward — so the machine returns to a clean state without ever erasing anything. Only the bits you deliberately choose to forget cost you a Landauer each.

Why it was academic in 1982

Two reasons, one practical and one physical.

The practical one: the gap between real hardware and the Landauer limit was astronomically wide. Circa 1982, switching a logic gate cost on the order of a picojoule — roughly 10^8–10^9\,kT. Every joule of a 1982 computer's dissipation was "friction": charging capacitors through resistive channels and dumping the energy to ground, \tfrac{1}{2}CV^2 per switch, with V around 5 volts. Landauer's kT\ln 2 was eight orders of magnitude below the noise floor of the engineering problem. Building reversible hardware to save an unmeasurable fraction of the power budget made no sense; Moore's law was delivering orders of magnitude the easy way. Fredkin and Toffoli knew this — the paper is explicitly about fundamental limits, not near-term devices.

The physical one: the billiard-ball model is dynamically unstable. Hard-sphere collisions amplify positional errors exponentially — the system is chaotic — so an idealized zero-dissipation machine needs infinitely precise initial conditions or continuous error correction, which itself dissipates. Bennett and others discussed this in the years around the paper. Zero dissipation is an in-principle limit, approached asymptotically as you slow down; any finite-speed, finite-precision machine pays something. The honest reading of the paper is not "free computation" but "dissipation per operation has no floor above zero, and scales down with speed" — which is exactly the claim that matters today.

What changed

Three things converged.

The cushion is gone. Modern CMOS switching energies at the device level are in the attojoule range — roughly 10^3–10^4\,kT per transistor switch, with wires and architecture inflating the system-level number. At the accelerator level, a modern GPU delivers on the order of 10^{15} FLOP/s at several hundred watts, i.e. roughly 10^{-13} J per FLOP. The Landauer limit is no longer eight orders of magnitude below the engineering frontier at the device level; it's three or four. Dennard scaling ended around 2006; voltage stopped falling; the \tfrac{1}{2}CV^2 tax stopped shrinking on schedule. Every remaining order of magnitude is now expensive, and the last few are impossible for irreversible logic.

Energy became the binding constraint. AI inference and training are power-limited, not transistor-limited. Datacenter buildouts are negotiated in gigawatts; total-cost-of-ownership is dominated by energy and cooling. This flips the design calculus that made reversibility unattractive: trading 2–4× silicon area and lower clock speed for 10–100× lower energy per operation is a bad deal when area is the constraint and a great deal when power is.

The engineering path exists. Adiabatic CMOS — developed in the 1990s (Athas, Koller, Younis and Knight's split-level charge recovery logic, MIT's Pendulum reversible processor, later Michael Frank's 2LAL) — charges capacitors gradually through resonant "power-clocks," dissipating \sim (RC/T)\,CV^2 per switch instead of \tfrac{1}{2}CV^2, where T is the ramp time. Dissipation falls linearly as you slow down — but only if the logic is reversible, otherwise Landauer erasure and non-adiabatic shortcuts put a floor under it. This is Fredkin–Toffoli's asymptotic-zero claim, translated into transistors. In superconducting logic, adiabatic quantum-flux-parametron circuits (Takeuchi, Yoshikawa and colleagues) have demonstrated switching energies at or below kT\ln 2 per gate at 4 K in published experiments, and Bérut et al. (2012) experimentally confirmed the Landauer bound itself for single-bit erasure. And commercially: Vaire Computing is building adiabatic-reversible CMOS chips with on-chip resonant energy recovery, with early test silicon in roughly 2024–2025; my understanding is that Frank, the field's most persistent advocate, joined them from Sandia.

What a serious 2026 revival looks like

Not a general-purpose reversible CPU — that was tried (Pendulum) and the overheads are brutal for control-heavy code. The right target is exactly the workload that created the energy crisis: dense linear algebra for inference.

Architecture. A systolic MAC array in adiabatic-reversible CMOS. Multiply-accumulate is arithmetic, and arithmetic reversibilizes cheaply: carry chains and partial products can be uncomputed Bennett-style at tile boundaries, so garbage never accumulates beyond one pipeline stage. Keep the Fredkin/Toffoli gate-level discipline inside tiles; deliberately erase only the quantized outputs crossing tile boundaries, paying Landauer only where you actually discard information. Drive everything from a high-Q resonant power-clock (LC or MEMS); the resonator's quality factor sets how much of each cycle's signal energy you recycle, and is arguably the critical component — clock generation and distribution losses ate most of the theoretical gains in 1990s prototypes.

The trade. Run at, say, 100–250 MHz instead of 1–2 GHz, and spend 2–4× area on dual-rail reversible logic. Since adiabatic dissipation scales as 1/T, halving frequency halves energy per op: you are converting silicon area (cheap, still scaling) into energy efficiency (the binding constraint). At fixed throughput, a 10× slower, 10× wider reversible array with 30–100× lower energy per op wins decisively on datacenter TCO — if the resonators, EDA tools, and yield cooperate.

What to reuse from the paper. The core theorems: reversibility suffices for universality; garbage is uncomputable; dissipation has no floor and trades against speed. The token-conservation framing is also quietly useful — it's the ancestor of dual-rail and charge-recovery signaling, where "energy follows the bits."

What to replace. Everything mechanical. Billiard balls are a proof of concept, not a device; their chaos problem is solved in practice by using bistable/latching electrical logic that restores signals each cycle, paying a small, controlled dissipation for stability rather than pretending to be a perfect Hamiltonian system.

Descendants and what remains open

The paper has already been vindicated once, in a domain Fredkin and Toffoli only gestured at: quantum computing. Unitary evolution is reversible by definition, so every quantum circuit is a reversible circuit; the Toffoli and Fredkin gates are standard fixtures, and the reversible-circuit synthesis literature the paper spawned is core infrastructure for quantum compilation. Landauer's principle itself is now experimentally confirmed and central to stochastic thermodynamics and to arguments about the energetics of biological computation.

The classical-hardware vindication is the one still in progress. Open problems, honestly: resonant clock networks with high enough Q at chip scale; the area and design-complexity overhead of fully adiabatic pipelines; the absence of a mature EDA flow (synthesis, timing, verification for reversible logic is a research area, not a product); leakage currents, which impose a floor that slow adiabatic operation makes worse, not better; and whether the first commercial wins come at 300 K in CMOS or at 4 K in superconducting logic where the energy accounting is cleaner but cooling overhead is ~1000×. None of these look like physics obstacles. All of them look like the kind of engineering that gets solved when tens of gigawatts are on the table.

Where to read it

The paper: Fredkin & Toffoli, "Conservative logic," Int. J. Theoretical Physics 21, 219–253 (1982), doi:10.1007/bf01857727. It's unusually readable — half logic design, half classical mechanics, with the billiard-ball construction worked out in diagrams.

Read alongside: Landauer's "Irreversibility and heat generation in the computing process" (1961) for the limit itself; Bennett's "Logical reversibility of computation" (1973) for the uncompute trick and his 1982 IJTP review of the thermodynamics of computation (same journal volume era, including the billiard-ball stability discussion); Younis & Knight on charge-recovery logic (1990s) for the CMOS translation; and Michael Frank's surveys of reversible computing (e.g. his 2017 "Throwing computing into reverse" in IEEE Spectrum) for the modern engineering case. For the experimental closing of the loop: Bérut et al., Nature 2012, measuring Landauer's bound directly.