The heat is in the lost alternatives

No algorithm has a temperature

Write a computation as a function, y = f(x). The notation says which output belongs to each input. It does not say whether the function runs in silicon, a fluid, a molecular network or marks on paper. It specifies no bath temperature, switching time, friction, voltage, error rate or cooling system. An algorithm can therefore have time and space complexity while having no unique energy consumption.

A physical computer adds the missing facts. Its logical states correspond to regions of a physical state space. A transition changes voltages, positions, charges, spins or chemical populations. Heat appears when the controlled trajectory irreversibly disperses free energy into degrees of freedom that the computation no longer tracks.

Landauer’s central insight was to connect one common logical event to that physical dispersion. Resetting an unknown, equally likely bit to a known value maps two distinguishable logical states onto one. The operation is many-to-one. If the memory entropy falls by one bit while the device completes a cycle, at least a compensating entropy increase must occur elsewhere under the familiar symmetric, isothermal assumptions.[1]

The broader stochastic-thermodynamics framework relates work, entropy, measurement and feedback while preserving the details of the physical process.[2] That process dependence is why information is physically consequential without becoming a universal energy currency detached from implementation.

The floor follows uncertainty, not register width

The phrase “erase one bit” hides another variable: what was uncertain before reset. The familiar k_BT ln 2 value assumes a symmetric memory whose zero and one states are equally likely. A register already known to be zero contains no unknown logical distinction for a clear instruction to destroy, although a careless physical clear pulse may still dissipate energy. A bit that is one with probability 0.99 has binary entropy of only about 0.081 bits, so its ideal information-loss floor is correspondingly smaller than the symmetric case.

Side information changes the account again. If a reference register R predicts a target bit B, the relevant uncertainty can be expressed as the conditional entropy H(B|R). A controller that can use R may reset B with less unavoidable information loss than a controller that sees B alone. Sagawa and Ueda’s analysis makes the wider lesson explicit: measurement, memory asymmetry and erasure have distinct physical bounds, so one fixed price should not be attached to every nominal bit operation.[4]

There is no bookkeeping escape. If R was copied, protected and later reset, its cost belongs somewhere in the full cycle. Information can be moved, correlated and uncomputed; the obligation appears when the last useful record of a distinction is deliberately lost.

Erasure is not the same as touching a bit

Three operations can look similar in code while differing logically. Reading a state need not destroy it. Copying a bit into a known blank register can preserve enough information to reverse the operation. Overwriting an unknown target loses the target’s prior value unless that value is retained elsewhere. The last operation merges distinguishable histories.

Bennett showed that a general computation can be embedded in a logically reversible process. The machine records its intermediate states, copies out the desired result, then retraces the calculation to clear the workspace without a blanket reset.[5] This is why the orchard’s second controller is not fantasy at the level of computation theory.

flowchart LR
  A["The orchard that produced the<br/>same answer twice"] --> B["The heat is in the lost<br/>alternatives"]
  B --> C["A useful memory points forward"]
  C --> D["Correction is a second computation"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#7B4CD8,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

A useful memory points forward

From remembered past to predictive state

Information theory gives the distinction a compact form. Let S_t be the system’s current state, X_t the current environmental signal and X_t+1 the next signal. Mutual information, I(A;B), measures how much knowing one variable reduces uncertainty about the other.

The state’s instantaneous memory is I(S_t;X_t). Its instantaneous predictive information is I(S_t;X_t+1). The difference is information about the present that does not help with the next signal.

Still, Sivak, Bell and Crooks studied a particular class of systems driven by a stochastic external signal. Under their assumptions, including Markovian system dynamics, thermal contact and no feedback from the system to the driving signal, instantaneous dissipated work in units of k_BT equals this nonpredictive information. Summed over the protocol, total nostalgia lower-bounds total dissipation.[6]

This is stronger than the loose slogan that “prediction saves energy”, but narrower than a universal law for software. The equality concerns the physical response of the system to a changing drive. It does not allow us to count unused features in a neural network and convert them directly into joules.

Prediction requires a declared future

The glitter example calls one bit useless only because the target is the next weather signal. Change the target and the judgement can reverse. A flickering sensor bit may be useless for tomorrow’s frost yet valuable for predicting imminent sensor failure. A regime bit can be informative one step ahead and nearly useless a year ahead. Predictive information is therefore not an intrinsic label attached to a memory cell. It is a relation among a state, a selected future variable and a horizon.

Control adds a further complication. In the Still model, the external drive changes without feedback from the system. An orchard controller acts on the world. Opening a valve changes soil temperature and moisture, which changes the observations it will later receive. Once action enters the loop, the state may be valuable because it supports a good intervention, rather than only because it forecasts an uncontrolled signal. A state can have low mutual information with the raw future while retaining exactly the distinction needed to choose between two actions.

Average information can also hide asymmetric consequences. Suppose a rare pressure pattern carries little mutual information because it occurs once in a million cycles, yet missing it can rupture a vessel. Compressing it away may improve an average prediction score and reduce normal-operation storage while violating the control contract. The correct target is not maximal compression. It is the smallest state that preserves the distinctions required by the declared prediction or decision loss.

This yields a stricter design rule: state the target, horizon, action policy and consequence function before calling information “nonpredictive”. A predictive state is sufficient only relative to the future and the decision it must protect. Without that declaration, nostalgia is a suggestive statistic rather than an engineering verdict.

Correction is a second computation

The floor lives at infinite patience

The one-bit Landauer value is often drawn as a horizontal line. Real devices move through state space in finite time. Push a memory distribution rapidly from two wells into one, and it cannot remain arbitrarily close to equilibrium throughout the protocol. Additional work is dissipated.

Finite-time analyses make that intuition precise for specified dynamics and controls. Proesmans, Ehrich and Bechhoefer derived bounds for erasing a bit within a limited duration.[8] A later optical-tweezer experiment implemented optimised finite-time transport and approached a joint speed-dissipation-accuracy bound in its controlled stochastic system.[9]

Reliability manufactures its own state

A noisy device does more than calculate the intended function. It also calculates whether the calculation can be trusted. It samples, compares, votes, checks parity, records a syndrome, retries or rolls back. Those temporary distinctions eventually have to be retained, exported or erased.

This is why correction is a second computation. Lowering a switching barrier may reduce energy for a single attempted transition while increasing error probability. Redundancy then multiplies transitions. Retries extend runtime. Verification creates evidence state. Recovery resets that state for the next cycle.

Thermodynamic uncertainty relations formalise related cost-precision trade-offs for currents in specified steady-state Markov systems.[10] They are valuable boundary results, but they are not a plug-in law for every processor. Their broader lesson is safer: precision is a maintained physical property, not a free label on an output.

Count the retry loop before declaring a saving

A simple expected-cost model exposes the hidden bill. Let E_a be energy for one attempted transition, p the probability that the attempt passes verification, and E_r the energy spent detecting, recording and recovering from each failed attempt. If attempts are independent and every failure is detected before release, the expected energy per verified result is:

Take a reliable device that spends 10 arbitrary energy units per attempt, succeeds with probability 0.999 and spends 20 units after a detected failure. Its expected cost is about 10.03 units per verified result. A low-margin device spends only 2 units per attempt but succeeds with probability 0.8 and needs 40 units to diagnose, restore and retry. Its expected cost is 12.5 units. The primitive transition became five times cheaper while the verified result became more expensive.

The calculation is intentionally small. Real correction may use block codes, replicated execution, temporal voting or rollback across many dependent states. Failures can share causes, and detection itself can be wrong. Those complications strengthen the accounting requirement rather than invalidate it. The trace must include verification and recovery as part of the computation being compared.

A positive result from this calculation permits a narrow conclusion: a proposed lower-energy substrate remains favourable after its detected retry path is included. A negative result means the substrate’s primitive saving is consumed by reliability work under the stated error model. It says nothing about another code, another operating point or the cost of an undetected physical outcome.

stateDiagram-v2
  [*] --> Claim
  state "No algorithm has a temperature" as Claim
  state "A floor small enough to<br/>misunderstand" as Test
  state "The floor follows uncertainty,<br/>not register width" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Audit the information that disappears

One word, four losses

“Erasure” is too coarse for system design. A trace can lose information because the task intentionally compresses inputs, because a local module ignores correlations, because the physical process was tuned for the wrong input distribution, or because recovery state is thrown away after a fault. These losses have different remedies.

The following four-loss ledger is a practitioner synthesis. It does not claim that every entry can be added without overlap. Its purpose is to force a system designer to name the lost distinction, the boundary where it vanishes and the evidence that links it to energy.

Start with a causal boundary, not a sum

The four ledger entries are not four counters that software can increment blindly. Each requires a different evidential bridge. Required loss can sometimes be read from a reversible description of the task and the registers deliberately reset. Architectural loss needs evidence that a local operation destroys correlations still available at the wider boundary. Mismatch needs a declared physical process, its actual input distribution and a justified least-dissipative reference distribution. Recovery loss needs a failure and verification trace.

Begin by drawing one cycle from prepared input to released outcome and restored readiness. Mark every state that must be available at the beginning of the next cycle. Then ask, at each transition, whether two distinguishable histories have become one inside the chosen boundary. If a copy survives elsewhere, the distinction has moved rather than vanished. If a module discards a correlation that another module could have used, record the wider joint state before assigning architectural loss.

Next, separate the information audit from the energy measurement. The audit proposes where unavoidable or avoidable entropy production may originate. A power meter measures the complete physical implementation. Cache locality, wire capacitance, leakage, clocking and cooling can dominate even when the information ledger is unchanged. Conversely, two designs can move similar numbers of bytes while destroying different correlations. The useful experiment varies one ledger term while matching the ordinary physical confounders as closely as possible.

Finally, version the distribution and operating contract. A design optimised for yesterday’s inputs can acquire mismatch and recovery costs after a shift. A design tested at relaxed latency can lose its advantage when the service-level deadline tightens. The ledger is valid only for the boundary, distribution, speed and accuracy assumptions written beside it.

from __future__ import annotations

from dataclasses import dataclass
from math import log

BOLTZMANN = 1.380_649e-23  # joule per kelvin, exact SI value


@dataclass(frozen=True)
class CostInputs:
    temperature_k: float = 300.0
    updates_per_second: float = 500.0
    duration_hours: float = 24.0
    required_bits_per_update: float = 8192.0
    architecture_bits_per_update: float = 0.0
    mismatch_bits_per_update: float = 0.0
    recovery_bits_per_update: float = 2048.0
    measured_power_w: float | None = 0.8
    retained_current_bits: float = 2.0
    predictive_future_bits: float = 0.531

    def validate(self) -> None:
        numeric = {
            "temperature_k": self.temperature_k,
            "updates_per_second": self.updates_per_second,
            "duration_hours": self.duration_hours,
            "required_bits_per_update": self.required_bits_per_update,
            "architecture_bits_per_update": self.architecture_bits_per_update,
            "mismatch_bits_per_update": self.mismatch_bits_per_update,
            "recovery_bits_per_update": self.recovery_bits_per_update,
            "retained_current_bits": self.retained_current_bits,
            "predictive_future_bits": self.predictive_future_bits,
        }
        for name, value in numeric.items():
            if value < 0:
                raise ValueError(f"{name} must be non-negative")
        if self.temperature_k == 0:
            raise ValueError("temperature_k must be greater than zero")
        if self.predictive_future_bits > self.retained_current_bits:
            raise ValueError("predictive bits cannot exceed retained bits in this audit")
        if self.measured_power_w is not None and self.measured_power_w < 0:
            raise ValueError("measured_power_w must be non-negative")


def calculate(inputs: CostInputs) -> dict[str, float | None]:
    inputs.validate()
    per_bit_j = BOLTZMANN * inputs.temperature_k * log(2.0)
    updates = inputs.updates_per_second * inputs.duration_hours * 3600.0
    bit_equivalents = (
        inputs.required_bits_per_update
        + inputs.architecture_bits_per_update
        + inputs.mismatch_bits_per_update
        + inputs.recovery_bits_per_update
    )
    floor_j = per_bit_j * bit_equivalents * updates
    measured_j = (
        None
        if inputs.measured_power_w is None
        else inputs.measured_power_w * inputs.duration_hours * 3600.0
    )
    ratio = None if measured_j is None or floor_j == 0 else measured_j / floor_j
    nostalgia_bits = inputs.retained_current_bits - inputs.predictive_future_bits
    return {
        "landauer_per_bit_j": per_bit_j,
        "updates": updates,
        "provisional_floor_j": floor_j,
        "measured_energy_j": measured_j,
        "measured_to_floor_ratio": ratio,
        "nonpredictive_bits_per_update": nostalgia_bits,
    }


if __name__ == "__main__":
    result = calculate(CostInputs())
    for key, value in result.items():
        print(f"{key}: {value}")

What the calculator can change

The executable lab deliberately reports a screening floor rather than a predicted wattage. A large measured-to-floor ratio is normal. It means the selected information losses explain only a tiny lower-bound fraction of measured energy, so conventional device and system engineering remain the main optimisation surface. A smaller ratio would make the declared losses more decision-relevant, but it would still not prove that the implementation attains the bound.

Use the calculator comparatively. Hold temperature, update count and boundary constant, then change one supported ledger entry. If a redesign removes a large required-reset term, the result permits prioritising a reversible or state-preserving prototype. If every plausible ledger change is negligible beside measured energy, the negative result is useful: pursue data movement, voltage, utilisation or cooling before invoking information thermodynamics.

The calculator cannot discover loss terms from source code, decide whether two mutual-information quantities overlap or infer the least-dissipative prior of a physical device. Those tasks require a model or measurement outside the artefact. Its purpose is to make assumptions inspectable and prevent a zeptojoule lower bound from masquerading as a system forecast.