Diff — Reversible Computing

{{infobox

| title = Reversible Computing

| subject = The physics of computing without waste — and the thermodynamic floor under every chip ever made

| span = 1867 Maxwell's demon → 1961 Landauer's principle → 2024 the first VC-backed reversible-computing startup

| the limit = Erasing one bit costs ≥ kT·ln2 ≈ 2.9×10⁻²¹ joules at room temperature — the floor under Moore's law

| the loophole = Don't erase. Reversible logic keeps the information, so the computation can be run backwards and the energy returned

| key figures = Rolf Landauer · Charles Bennett · Edward Fredkin · Tommaso Toffoli · Leó Szilárd · Maxwell's demon

| who builds it = Vaire Computing (first VC-backed RC startup, 2021) · AQFP superconducting logic (Japan) · quantum computers (reversibility is mandatory)

| related = [[Biological Computing]] · [[History of Physics]] · [[History of Mathematics]]

| image = rev-landauer.jpg

| caption = Rolf Landauer, the IBM physicist who proved that erasing a bit must dissipate heat — that "information is physical" (AIP Emilio Segrè Visual Archives, with permission).

}}

Every computer you have ever used wastes nearly all of its energy. Not through bad engineering — through physics. When a processor computes, it *forgets*: AND gates take two bits in and give one out, and the information that was in the second input is gone, destroyed, nowhere. And in 1961, an IBM physicist named **Rolf Landauer** proved that destroying information has a mandatory price: every erased bit must release a minimum of **kT·ln2** of heat into the world — about **2.9 × 10⁻²¹ joules** at room temperature, a quantity so small it took fifty-one years to measure, and so fundamental that no engineer will ever design a chip that goes below it.[[cite: Landauer, R., "Irreversibility and heat generation in the computing process," *IBM Journal of Research and Development* 5 (1961)]]

That number — the **Landauer limit** — is the invisible floor under all of computing. Today's chips sit roughly a hundred thousand times above it. Which means, mathematically, that there is room for computers a hundred thousand times more efficient than anything we have — *if* we learn to compute without forgetting. That is **reversible computing**: the field built on the loophole Landauer himself left open. If you never erase, you never pay.

The story runs from a Victorian physicist's imaginary demon to a London startup betting that the future of the data center is a chip that runs its arithmetic backwards. Along the way it explains why quantum computers are reversible by necessity, why the world's most efficient computer is a kilogram-and-a-half of warm wet tissue — and why the end of Moore's law might not be the end of anything.

## The demon in the box

The argument starts in 1867, with a thought experiment that haunted physics for 115 years. **James Clerk Maxwell** — the same Maxwell whose equations unified light and electromagnetism — imagined a tiny intelligent creature stationed at a trapdoor between two chambers of gas. The creature — later named **Maxwell's demon** by Kelvin — watches individual molecules approach, opens the door only for the fast ones heading left and the slow ones heading right, and thus sorts hot from cold *without doing any work*. A temperature difference appears from nothing; a second engine could run on it; and the second law of thermodynamics — the one law with no appeal — appears to be broken by a clever doorman with good eyesight.[[cite: Maxwell, letter to Tait (1867); *Theory of Heat* (1871)]]

[[File:rev-demon.png|right|300px|Maxwell's demon at his trapdoor — the thought experiment that took 115 years to defeat, defeated not by catching him cheating but by pricing his memory (public domain).]]

For sixty years nobody could say exactly where the demon cheated. In **1929**, the Hungarian physicist **Leó Szilárd** — the same Szilárd who would later invent the nuclear chain reaction at a London traffic light — reduced the demon to its essence: a single molecule in a box. The demon learns which side the molecule is on (one bit of information), slips in a partition, and extracts kT·ln2 of work as the molecule pushes the partition. Szilárd's engine made the first precise link between **one bit of information and a quantity of energy**.[[cite: Szilárd, L., "On the decrease of entropy in a thermodynamic system by the intervention of intelligent beings," *Zeitschrift für Physik* 53 (1929)]]

[[File:rev-szilard.jpg|left|280px|Leó Szilárd — who reduced the demon to a single molecule and a single bit in 1929, founding information thermodynamics decades before it had a name (U.S. Department of Energy, public domain).]]

The final answer took until **1982** — and it was not what anyone expected. For decades the guess was that the demon's *measurement* must cost energy (Leon Brillouin argued the demon needs light to see). **Charles Bennett** proved otherwise: measurement can in principle be done reversibly and free. The demon pays not when it *learns* where the molecule is — but when it **forgets**. To repeat the trick, the demon must erase the bit recording the last molecule's position, and that erasure dumps exactly kT·ln2 of heat — precisely the work just extracted. The second law is saved not by physics catching the demon, but by bookkeeping: **memory is physical, and forgetting has a price.**[[cite: Bennett, C. H., "The thermodynamics of computation — a review," *International Journal of Theoretical Physics* 21 (1982)]]

```fact The demon, resolved

The demon doesn't cheat the second law — he *finances* it. Every cycle ends with a bit in his memory that must be erased, and erasing it costs exactly the kT·ln2 he just won. Maxwell's demon is the world's first illustration that **information has a thermodynamic price tag**.

```

## The limit

Rolf Landauer spent his career at IBM — the company that more than any other was turning computation into a physical industry — and he was the first to ask the obvious-but-unasked question: what does computation *cost*, in energy, at the level of physics? Not the power supply's cost, not the fan's — the *irreducible* cost of the computation itself.

His 1961 answer: almost everything a computer does is free — **except erasure.** Reading, copying, computing — all can in principle be done with arbitrarily little dissipation. But when a logic operation is *logically irreversible* — when two inputs produce one output and the information about what those inputs were is destroyed (a NAND gate destroys two bits' worth) — the lost information has to go somewhere, and thermodynamics says it goes out as heat. Minimum price per erased bit: **kT·ln2**.[[cite: Landauer, R., *IBM J. Res. Dev.* 5, 183 (1961)]]

[[File:rev-landauer.jpg|right|300px|Rolf Landauer at IBM — "information is physical" was his slogan, and his 1961 paper proved it by pricing erasure (AIP Emilio Segrè Visual Archives, with permission).]]

```fact The Landauer bound, in numbers

**E ≥ k·T·ln 2** ≈ **2.87 × 10⁻²¹ joules** per erased bit at 300 K — about **0.018 eV**.

A modern CPU dissipates roughly **10⁻¹⁷ to 10⁻¹⁴ joules** per bit-level operation — a hundred thousand to ten million times the floor. The gap between those numbers is the entire argument for reversible computing.

```

For a sense of how strange this result was: von Neumann had earlier guessed the minimum cost of computation was *billions* of times higher than Landauer's figure — and even Landauer faced decades of "but surely it can't apply to real machines." It can and does. In **2012**, Antoine Bérut and colleagues at École Normale Supérieure de Lyon finally measured it directly: a single microscopic bead in a double-well optical trap is a one-bit memory (left well = 0, right = 1). Erase it — collapse it to one well regardless of where it started — and the heat released, for slow enough erasure, saturates precisely at kT·ln2. Fifty-one years after the prediction, the Landauer bound was *measured*, not just derived.[[cite: Bérut, A. et al., "Experimental verification of Landauer's principle linking information and thermodynamics," *Nature* 483 (2012)]] Single-electron experiments confirmed it again shortly after.[[cite: Koski, J. V. et al., "Experimental realization of a Szilárd engine with a single electron," *PNAS* 111 (2014) — the same group's Szilárd engine ran the demon for real]]

Landauer's own summary became the field's motto: **"Information is physical."** Bits are not abstractions floating free of matter. They live in voltages, spins, molecules — and the laws that govern matter govern them.

## Bennett's trick

If erasure is what costs, the obvious question follows: can you compute *without erasing*? In **1973**, Charles Bennett — an IBM colleague of Landauer's who would spend his career at the intersection of computation and physics — proved the answer is yes, completely.

His argument is beautiful. A computation is irreversible because it throws information away — the inputs to a NAND gate, the intermediate steps, the scratch work. But what if you *don't* throw it away? Keep the garbage: run the computation forward storing every intermediate result, copy the final answer out, then **run the whole computation backwards**, un-computing every intermediate step and returning all the stored information to its initial state. Nothing was ever erased — the garbage was de-computed rather than deleted — so no Landauer tax is ever paid. The only cost is the input you chose to write and the output you chose to keep: the actual *point* of the computation.[[cite: Bennett, C. H., "Logical reversibility of computation," *IBM Journal of Research and Development* 17 (1973)]]

[[File:rev-bennett.jpg|right|300px|Charles Bennett at IBM — the man who proved any computation can be made reversible, and who solved Maxwell's demon by pricing the demon's memory (IBM Research, CC BY-SA 2.0).]]

The price of the trick is **space**: you need to store the intermediate history while you uncompute, so reversible computation trades energy for memory — you can save arbitrarily much dissipation by spending arbitrarily much bookkeeping. In practice there are clever trade-offs (compute in sections, checkpoint, uncompute within each) that keep the memory overhead manageable. But the theorem stands and is the foundation of the whole field: **logically, any computation can be done reversibly.** There is no theoretical barrier. Only engineering.

## The gates

Theory needed hardware. In **1982**, Edward Fredkin and Tommaso Toffoli — the two names now welded to the field's basic building blocks — published *Conservative Logic*, showing you could compute anything using gates that were *reversible by construction*.[[cite: Fredkin, E. & Toffoli, T., "Conservative logic," *International Journal of Theoretical Physics* 21 (1982)]]

[[File:rev-toffoli.png|right|300px|The Fredkin–Toffoli billiard-ball model — reversible computation as elastic collisions: balls bounce through gates, nothing is destroyed, and the whole machine could be run backwards (vectorized by Д.Ильин, CC0).]]

Their idea was gloriously concrete: the **billiard-ball model**. Imagine computing with billiard balls on a frictionless table — a ball in a lane is a 1, no ball is a 0; gates are mirrors and collision paths; two balls colliding and bouncing off is a logic operation. Elastic collisions are perfectly reversible: film the machine, play the film backwards, and the physics is still legal. A computer built of such collisions would dissipate nothing in principle — the energy in the balls is never lost, just rearranged.

The practical descendants are two gates every reversible-computing student meets:

- **The Toffoli gate** (CCNOT) — 3 inputs, 3 outputs; the third output flips only if both controls are 1. Reversible because inputs pass through to outputs, so you always know what you started with — and universal: any function computable at all is computable with Toffolis.

- **The Fredkin gate** (CSWAP) — 3×3; swaps two inputs controlled by a third. Also universal, and *conservative*: the number of 1s in equals the number of 1s out — the billiard-ball ideal made logic.

[[File:rev-fredkin.png|right|300px|The Fredkin gate — a controlled swap: inputs are shuffled, never destroyed, so the computation is reversible by construction (Bender2k14, CC BY-SA 3.0).]]

The deep point: **a reversible circuit is a bijection** — every output maps to exactly one input, so you can always run it backwards. Ordinary gates destroy information by construction (2 inputs → 1 output can't be undone). Reversible gates keep it — and that, it turned out, is exactly what the laws of physics require at the thermodynamic limit.

## Adiabatic electronics

Reversible logic is necessary but not sufficient: you also need a way to move charge that doesn't throw energy away. This is where **adiabatic computing** enters — the engineering discipline of getting energy *back*.

In ordinary CMOS, every time a node charges or discharges you dissipate roughly ½CV² — the energy is dumped to ground and gone. The adiabatic insight: if instead of switching the power rail on and off you **ramp it slowly** — charge the node gradually through a resonant circuit — the dissipation scales with *how slowly* you go. Charge slowly enough and, in principle, the energy isn't dissipated at all: it flows back into the resonator and is **recycled for the next cycle**. The word *adiabatic* comes straight from thermodynamics — a change made slowly enough to stay near equilibrium, losing almost nothing.[[cite: Younis, S. & Knight, T., "Practical implementation of charge recovering asymptotically zero power CMOS," *Proceedings of the 1993 Symposium on Integrated Systems* (1993); Athas, W. et al., energy-recovery CMOS work at MIT/USC through the 1990s]]

The 1990s saw the first serious circuits: **energy-recovery CMOS** — charge-recovery logic families like Younis and Knight's, and William Athas's work at MIT and USC — demonstrably beating the CV² floor on the bench.[[cite: Athas, W. et al., "Low-power digital systems based on adiabatic-switching principles," *IEEE Trans. VLSI* (1994)]] But there was always a catch: the slow-ramping clock needed **resonators** — inductors and tank circuits big enough to store and return the energy — and on-die resonators were the missing piece of the stack. The field idled for two decades waiting for the enabling technology. It is not a coincidence that Vaire Computing — the first serious startup — was founded right after the resonator problem was finally cracked.

## Why now — the thermal wall

The timing is no accident. The reason reversible computing spent fifty years as a beautiful theory and is now a startup pitch is that Moore's law hit the wall Landauer predicted — just from the other direction.

For decades, **Dennard scaling** — the rule that shrinking transistors also shrank their power draw — let chips get faster and cooler together. It ended around **2006**: transistors got so small they leaked, and the energy-per-transistor stopped falling. Since then, chips get faster only by burning more watts — and the watts become heat. The **thermal wall** is now the limiter on the entire industry: GPUs throttle, data centers are built around rivers for cooling, and AI training runs cost megawatt-days.

[[File:rev-heatsink.jpg|right|300px|A CPU on its heatsink — the thermal wall made metal. Modern chips sit ~10⁵–10⁷× above the Landauer floor, and the whole industry pays the bill (walknboston, CC BY 2.0).]]

Meanwhile the numbers got loud. Data centers now draw on the order of **1–2% of global electricity** and rising; a frontier AI training run consumes tens of gigawatt-hours — a small town's annual budget to teach a model to write a sonnet.[[cite: IEA data-centre estimates (2024); AI training energy figures are order-of-magnitude and flagged as such]] Against that backdrop, Landauer's number stops looking like a curiosity and starts looking like a map: there's a hundred-thousand-fold gap between where we are and where physics allows us to be.

```fact The honest version of the promise

The "negligible energy" claim for reversible computing is real physics — but the gap between theory and a shipping chip is enormous. The Landauer limit is the floor; today's chips are ~10⁵–10⁷× above it. Reversible engineering has closed *some* of that gap in lab prototypes, not data centers. Flag the difference: the *physics* is proven; the *product* is still being built.

```

## Quantum's hidden requirement

There is a field where reversibility is not optional — it's the architecture. **Quantum computation is inherently reversible**, because quantum mechanics is: the laws of physics at the small scale are unitary, and every unitary transformation is reversible. Run a quantum gate, and in principle you can always run it backwards — the information was never destroyed, only transformed.

This is why the reversible-computing gates are not a curiosity in the quantum world — they are the *textbook gates*. The Toffoli is quantum's CCNOT. The Fredkin is its CSWAP. Quantum-circuit diagrams are reversible-circuit diagrams; when quantum engineers write an algorithm, they are, literally, drawing reversible circuits. Bennett's uncomputation trick is load-bearing in real quantum software: intermediate "ancilla" qubits must be un-computed back to |0⟩ precisely because you can't just erase them mid-computation — an orphaned garbage qubit stays entangled and corrupts the answer. The 1973 paper that founded reversible computing is now standard quantum-engineering practice.[[cite: Bennett's uncomputation is standard practice in quantum algorithm design — see any QC textbook's treatment of ancilla management]]

The two fields are converging in hardware too. **Adiabatic quantum-flux-parametron (AQFP)** logic — superconducting circuits that ramp energy slowly through Josephson junctions — is a real, fabricated, near-Landauer-limit technology developed at NTT and Yokohama National University, operating millimeters from the quantum computing it resembles.[[cite: Takeuchi, N., Ozawa, Y., Yoshikawa, N. et al., AQFP logic demonstrations — *Superconductor Science and Technology* and related venues (2010s–2020s)]]

## Who's actually building it

Honest coverage, flagged as such: the industry is real but young.

**Vaire Computing** — London and Seattle, founded 2021 by serial entrepreneur Rodolfo Rosini and Cambridge reversible-computing researcher **Hannah Earley** — is the first VC-backed reversible-computing startup, and by its own measure the first serious attempt to commercialize the field. They raised **$4.5M** in seed funding in mid-2024, with a cap table worth noting: **Tom Knight** — the MIT pioneer who *co-invented* modern reversible computing in the 1990s — invested, as did **Andrew Sloss**, one of the original ARM processor designers; the legendary reversible-computing researcher **Mike Frank** joined as Senior Scientist.[[cite: TechCrunch, "Vaire Computing raises $4.5M for 'reversible computing' moonshot" (July 2024); Seedcamp and 7percent Ventures announcements]]

Their stated goal: silicon chips that recover rather than dissipate the switching energy — "near-zero-energy" compute, extending effective Moore's law by decades past the thermal wall. The honest status: they are at **proof-of-concept stage** — working on the first chip, years from shipping product — but they have assembled, by the industry's own account, the highest concentration of reversible-computing talent in the world.[[cite: Vaire statements — proof-of-concept stage, per TechCrunch and company announcements]]

**AQFP** — the superconducting side is further along in one sense: real fabricated chips, real demonstrations at the edge of the Landauer limit, decades of NTT/Yokohama work — but superconducting logic needs cryogenics, which trades the thermal-wall problem for a refrigeration problem. It lives in a different niche.

**The rest of the field** is still largely academic — MIT, USC, Cambridge, Sandia — plus the quantum-computing industry, which builds reversible circuits by necessity and doesn't call them that. The honest summary: the physics is sixty years proven, the engineering is twenty years old, and the commercial industry is about four.

## ALB's bijective engine — reversible computing in a BASIC

Everything so far has been physics and startups. Here is the part where it gets personal — because one of the places reversible computing is *actually implemented, today, in shipping compiler code* is this very language.

**AdaLogic BASIC's FASM backend ships a compiler-enforced reversible-computation block** — called, in the source, the **Bijective Engine / Reversible State Forge**. It is, as far as we know, the only BASIC dialect — and one of very few languages at any level — that makes bijective computation a first-class, syntax-checked construct rather than a library convention.

### The syntax

Inside a **REVERSIBLE** block, only reversible statements are legal. The language offers exactly eight reversible primitives, and the compiler knows each one's inverse by construction:

```alb

REVERSIBLE

    REVADD x, 5        -- add;          inverse: REVSUB

    REVSUB x, 3        -- subtract;     inverse: REVADD

    REVXOR x, mask     -- bitwise XOR;  self-inverse

    REVROL x, 4        -- rotate left;  inverse: REVROR

    REVROR x, 2        -- rotate right; inverse: REVROL

    REVNOT x           -- bitwise NOT;  self-inverse

    REVNEG x           -- negate;       self-inverse (two's complement)

    REVSWAP a, b       -- swap;         self-inverse

END REVERSIBLE

```

The eight ops are not arbitrary — they are *the complete instruction-level version of conservative logic*. Each one is a bijection on its target's bit pattern: every output determines its input uniquely, which is precisely the Fredkin–Toffoli requirement stated one layer lower, in machine instructions rather than logic gates. The AST literally annotates them that way — `AST_Rev_Add_Stmt` carries the comment *"Inverse: AST_Rev_Sub_Stmt,"* `AST_Rev_Xor_Stmt` is marked *"Self-inverse,"* `AST_Rev_Neg_Stmt` *"Self-inverse in two's-complement space."* The inverse map is part of the language definition.[[cite: ALB source, `src/COMPILER/ast.ads` — the AST node kinds for the Reversible State Forge, each annotated with its mathematical inverse: [github.com/rockyoliver454/AdaLogic-BASIC-ALB-Programming-Language](https://github.com/rockyoliver454/AdaLogic-BASIC-ALB-Programming-Language)]]

### The compiler enforces it

The interesting half is not the ops — it's the **enforcement**. The compiler treats the block as a bijective proof obligation:

- `REV` ops outside a `REVERSIBLE` block → compile error: *"REV operation requires REVERSIBLE block."*

- A non-reversible statement inside → compile error: *"non-reversible statement inside REVERSIBLE."*

- Targets must be declared scalar variables — *"REV target must be declared scalar variable."*

- `REVSWAP` on the 16-bit backend requires both operands to share storage width.

- The block is only legal on backends that can honor it: `-t fasm`, `-t fasm16`, or `-t c` — anything else fails with *"REVERSIBLE requires -t fasm, -t fasm16, or -t c."*[[cite: ALB source, `src/albt.adb` — the `AST_Reversible_Block` walker, Reversible_Depth tracking, and the three enforcement errors]]

In other words: the compiler *proves* your block is reversible at compile time, the same way it proves types match. You cannot accidentally write an irreversible step inside it — the language will not let you. That is the programming-model half of Bennett's theorem turned into a syntax rule: **logically irreversible operations are a compile error in this scope.**

### What it emits

On the FASM backend the block lowers to direct x86-64 — `Emit_Rev_Add` emits `add qword [x], rax`-style memory ops dispatched by operand width (byte/word/dword/qword), with the emitted section bracketed by `; --- ALB REVERSIBLE BLOCK START/END ---` markers in the assembly. The rotate ops (`Emit_Rev_Rol`/`Emit_Rev_Ror`) emit the real `rol`/`ror` instructions with count masking; `REVSWAP` lowers to a three-move exchange through scratch registers. On FASM16 the same ops lower to 16-bit equivalents for the retro targets; on the C backend the emitter produces the equivalent C with an `ALB_REV_Tmp` staging variable.[[cite: ALB source, `src/EMITTER/emit_native_fasm.adb` — the `Emit_Rev_*` inverse-emitter family, procedures ~3308–3589, each documented with its inverse]]

### Where it sits in the theory

Honest placement — this is the *logical* half of the theory, exactly as this article defined it. A REVERSIBLE block guarantees what Landauer and Bennett's framework needs first: **the computation is logically reversible** — information is never destroyed inside the block, so it could in principle be run backwards by applying each op's inverse in reverse order. That is Bennett's 1973 theorem made into syntax.

The thermodynamic half — the actual energy savings — still requires the hardware to be doing the recycling; a REVERSIBLE block compiled to an ordinary x86 CPU doesn't magically reduce your power bill, because the CPU still dissipates at its usual ~10⁵×-above-floor rate. What ALB's block gives you is the *program-level guarantee* — the same one the quantum world gets by necessity, delivered here by a BASIC compiler that simply refuses to let you erase. When (or if) adiabatic hardware arrives, a language that can express bijective computation natively is already speaking its instruction set.

```fact Why this matters beyond ALB

Most languages treat reversibility as a library pattern or a discipline. ALB makes it a **compile-time-enforced contract** — the compiler is the proof checker. It's the same philosophical move as type systems: don't trust the programmer to be careful, make the machine check it. The Reversible State Forge is, to our knowledge, the first instance of that move applied to bijective computation in a BASIC-family language.

```

And there is a symmetry worth noting in this wiki's own terms: this article opened by asking whether a computer could run backwards. ALB's answer is *yes — as long as the compiler makes it impossible to write anything that can't be.* The REVERSIBLE block is the same bet Landauer made in 1961, written into a language: if you never erase, you never pay.

## The honest skeptics

Every revolution deserves its devil's advocate, and reversible computing has real ones:

- **Leakage.** The adiabatic pitch assumes you can slow-charge circuits without loss — but modern transistors leak current whether you clock them or not. At the slow speeds where adiabatic wins, leakage can eat the savings.

- **The resonator tax.** Recycling energy needs resonators — inductors that are physically large, hard to put on-die, and the actual reason the field sat dormant for two decades.

- **Memory vs. compute.** Bennett's trick works for the compute; but real workloads erase plenty anyway — every cache eviction, every overwritten register. The limit applies to *erasure*, and computing isn't only arithmetic.

- **Speed.** Slower = cheaper in adiabatic logic — but the market pays for fast. The efficiency win and the performance win pull in opposite directions.

- **The floor isn't the wall.** Landauer's bound is ~10⁷× below today's practice — you could improve a hundredfold and still be nowhere near it, which cuts both ways: huge headroom, but also huge room to fail short.

None of this disproves the physics. All of it explains why, sixty years on, reversible computing is still a moonshot rather than a product.

## What might happen

Flagged as extrapolation, clearly:

- **Near-term** — energy-recovery in pieces: adiabatic clocking and charge-recovery subcircuits inside otherwise-conventional chips, shaving the thermal wall rather than breaking it. Vaire's pitch is effectively this.

- **Medium-term** — dedicated reversible accelerators for the workloads where the math is reversible anyway: cryptographic hashing, AI inference, scientific simulation. The same reason GPUs won AI — a specialized substrate for a specific kind of math.

- **The far target** — computing at ~kT per operation: the efficiency regime where *biology already lives*. A neuron fires on the order of the Landauer bound's own energy scale. The most efficient computer in the known universe is a human brain, and it runs at about the speed and the energy of the physics limit. If reversible computing ever reaches its floor, it will be doing the one thing wetware already does: **computing at the edge of thermodynamics.** The two articles meet there.

```quote

Information is physical.

— Rolf Landauer

```

## The last word

The history of computing has been a history of fighting the second law — and losing, beautifully, by orders of magnitude. Every chip ever built threw away the energy the math didn't strictly need. Landauer's limit says that was never necessary: the floor is not zero, but it is *nearly* zero, and the only thing standing between us and a hundred-thousand-fold improvement is sixty years of engineering we are just now beginning.

The demon is still at his trapdoor. For a century and a half he watched molecules, and for sixty years engineers have been building machines that pay his price. Reversible computing is the bet that we can finally outsmart him — not by defeating the second law, but by refusing to write the checks it cashes.

## Quiz

- [ ] 1 — What process — and only that process — carries the Landauer tax?

- [ ] 2 — What did Bennett prove about how Maxwell's demon pays for his violation of the second law?

- [ ] 3 — What is a Toffoli gate, and why is it reversible by construction?

- [ ] 4 — What does "adiabatic" mean in this context — and what does the slow ramp buy you?

- [ ] 5 — Name the first VC-backed reversible-computing startup, and name one famous computer-architecture name on its team.

```hide Show answers — click to check yourself

1 — **Erasure** — deleting a bit dissipates ≥ kT·ln2. Reading, computing, copying are all (in principle) free.

2 — **Erasure of his memory** — the measurement is free; *forgetting* the last molecule's position is what pays the second-law debt.

3 — **A 3-input controlled-NOT (CCNOT)** — the third output flips only if both controls are 1; reversible because all inputs pass through, so you can always undo it.

4 — **Slow, near-equilibrium change** — ramping charge gradually lets energy recycle back to the resonator instead of dissipating as heat.

5 — **Vaire Computing** (London/Seattle, 2021) — and on the team: Tom Knight (RC pioneer, investor), Andrew Sloss (ARM designer), or Mike Frank (leading RC researcher).

```

## Notes

1. The Landauer bound is a *minimum* — real erasures can and do cost more; the bound is the floor, not the typical value.

2. Bérut 2012 was the first *direct* experimental verification of the bound at the single-bit level; Koski 2014 confirmed with a single electron and built a working Szilárd engine.

3. Vaire Computing's specifications and claims (funding, team, "near-zero-energy") are the company's and investors' own statements, flagged as such — no product has shipped.

4. The "million-times headroom" figure is order-of-magnitude: the gap between typical modern dissipation (~10⁻¹⁷–10⁻¹⁴ J) and the bound (~10⁻²¹ J) is quoted as 10⁴–10⁷ depending on the comparison.

5. The demon is usually attributed to Maxwell's 1867 letter to Tait; Kelvin named him "demon." Szilárd 1929 reduced him to one molecule.

6. The AQFP claims reflect published demonstrations; superconducting logic requires cryogenic operation — the efficiency win and the cooling cost are separate ledgers.

## References

- Landauer, R., "Irreversibility and heat generation in the computing process," *IBM Journal of Research and Development* 5 (1961).

- Bennett, C. H., "Logical reversibility of computation," *IBM Journal of Research and Development* 17 (1973).

- Bennett, C. H., "The thermodynamics of computation — a review," *International Journal of Theoretical Physics* 21 (1982).

- Fredkin, E. & Toffoli, T., "Conservative logic," *International Journal of Theoretical Physics* 21 (1982).

- Szilárd, L., *Zeitschrift für Physik* 53 (1929).

- Bérut, A. et al., "Experimental verification of Landauer's principle…," *Nature* 483 (2012).

- Koski, J. V. et al., "Experimental realization of a Szilárd engine with a single electron," *PNAS* 111 (2014).

- Younis, S. & Knight, T., "Practical implementation of charge recovering asymptotically zero power CMOS" (1993).

- TechCrunch, "Vaire Computing raises $4.5M for 'reversible computing' moonshot" (July 2024).

[[Category:Computing]]

[[Category:Science]]

[[Category:Physics]]