Rolf Landauer (??, ????) proved that logically irreversible computation – erasing one bit of information – requires dissipating at least kT ln 2 joules of energy as heat (k is Boltzmann's constant, T is temperature in Kelvin).

The implication: information loss is physically costly. A computation that discards bits generates heat. A computation that preserves all information (bijective, reversible) can in principle be performed with zero energy dissipation. This is not merely philosophical: it is the theoretical lower bound on computation energy, and it is why reversible computing is a hardware research topic. Bennett (??, a) extended Landauer's result, showing that any computation can be made logically reversible at the cost of additional space (ancilla bits).

For the pipeline tool, Landauer's principle gives physical grounding to the [BROKEN LINK: *Design Implications for the Pipeline Tool]. A red indicator (irreversible step) marks a point where, in principle, information is destroyed – not just computationally inconvenient to recover, but physically gone from the system's entropy budget. This is the physical manifestation of the [BROKEN LINK: *Hashing as Projection] that hash functions perform.

The Toffoli gate (Tommaso Toffoli) (??, a) is a universal reversible logic gate. It takes three bits (a, b, c) as input and outputs (a, b, c XOR (a AND b)). The output uniquely determines the input (the gate is its own inverse applied twice). Any classical computation can be expressed as a circuit of Toffoli gates.

Reversible circuits are circuits composed entirely of invertible gates. They compute a bijection on their input space. The ancilla bits (extra scratch bits initialized to zero) carry the information that would otherwise be discarded.

The pattern transfers directly to the pipeline tool's design space. A "garbage output" ancilla corresponds to carrying intermediate results alongside the primary value – the tool already does this by showing intermediate values. If every step in the pipeline retained its full intermediate state, the pipeline would be reversible in the Toffoli sense.

Corruption – flipping a bit, changing a digit – is normally irreversible. The corrupted value does not carry enough information to recover the original. Error-correcting codes change this by adding redundancy before the corruption occurs, making the corruption itself reversible.

A Hamming(7,4) code encodes 4 data bits into 7 bits by adding 3 parity bits. The parity bits are the encoding analog of Toffoli ancilla bits – extra information that makes an otherwise irreversible operation reversible.

(-> "4111111111111111"
    hamming              ;; add parity bits        ← injection (green)
    corrupt-1-bit        ;; flip one bit            ← REVERSIBLE (with parity!)
    hamming/decode)      ;; correct the flip        ← recovers original

The decode step computes a syndrome – a parity check that identifies which bit was flipped. The syndrome is the inverse function's input: it tells you exactly what to undo.

Without the checksum, corruption is a [BROKEN LINK: *Irreversible: Shuffle (Random Permutation)] like shuffle. With it, single-bit corruption is a round-trip. This is the only case in the pipeline model where damage itself is reversible – not just the encoding, but the corruption.

The same structure appears in RAID (parity stripe recovers a failed disk), TCP (checksums detect corruption, retransmission recovers it), and git (SHA-1 detects corruption, reflog recovers the object).

All quantum gates are unitary operators: they are bijections on the Hilbert space of quantum states. Unitarity preserves the inner product, which means quantum information is never destroyed during gate operations. The composition of unitary operators is unitary.

Measurement is the exception: projecting a quantum state onto a basis collapses the superposition irreversibly. Measurement is the only irreversible operation in quantum computation.

The pipeline analogy: quantum gates are the bijective transform steps; quantum measurement is the hash or projection step that collapses the intermediate representation. After measurement, the pipeline cannot be run backward. Before measurement, every step is in principle reversible.

A Clojure model of unitary gates on a two-element state vector makes the bijection/projection distinction concrete. The Pauli-X gate (bit flip) is its own inverse. The Hadamard gate maps basis states to superpositions and back – composing it with itself recovers the input. Measurement collapses the superposition: the pipeline turns red.

;; Pauli-X (NOT gate): |0⟩ ↔ |1⟩.  Self-inverse (involution).
(defn pauli-x [[a b]] [b a])

(-> [1.0 0.0]               ; |0⟩
    pauli-x                  ;;=> [0.0 1.0]  -- |1⟩
    pauli-x)                 ;;=> [1.0 0.0]  -- |0⟩ recovered

;; Hadamard gate: bijection on amplitudes.
;; H·H = I -- applying Hadamard twice recovers the original state.
(def inv-sqrt2 (/ 1.0 (Math/sqrt 2)))

(defn hadamard [[a b]]
  [(* inv-sqrt2 (+ a b))
   (* inv-sqrt2 (- a b))])

(-> [1.0 0.0]               ; |0⟩
    hadamard                 ;;=> [0.707 0.707]  -- superposition
    hadamard)                ;;=> [1.0 0.0]      -- |0⟩ recovered

;; Measurement: project to basis state.  Irreversible -- collapses the
;; superposition.  The pipeline turns red here.
(defn measure [[a b]]
  (if (> (* a a) (rand)) [1.0 0.0] [0.0 1.0]))

(-> [1.0 0.0]
    hadamard                 ; green -- bijective
    measure                  ; RED -- projection, information destroyed
    hadamard)                ; still runs, but original is unrecoverable

The Toffoli gate (??, a) extends this to three bits and is also self-inverse: (a, b, c) → (a, b, c ⊕ (a ∧ b)). Applied twice, the XOR cancels and the original state is recovered. The pipeline tool's xor 0x42 codec is a simplified version of this pattern.

Janus (Lutz and Derby, 1986; rediscovered by Yokoyama and Glück) (??, a) is a programming language where every statement has a defined inverse statement. Assignment is replaced by augmented assignment (x += e, invertible as x -= e). Conditionals require both a forward condition and an assertion that holds at the exit (needed to reverse the branch). Loops require an invariant that distinguishes the entry and exit states.

A Janus program is guaranteed to be invertible: the language's syntax enforces it. The inverse program is mechanically derived. This is the strongest version of the pipeline tool's reversibility guarantee: not an annotation or indicator, but a structural property enforced by the type system.

The encode tool's pipeline is not written in Janus, but the Janus model clarifies what full reversibility would require: every step must carry enough information in its output to reconstruct its input. Steps that use external state (a secret key, a random nonce, a timestamp) cannot satisfy this without also threading that state through the pipeline.

Glück and Yokoyama state the general principle (??, a): every reversible step carries enough in its output to reconstruct its input; where a step does not, forcing reversibility stores the missing information in ancilla or garbage. The Toffoli ancilla bit and the Janus threaded state are the same mechanism. Injectivity can be enforced as a language-level property rather than checked after the fact (??, a): a language admitting only injective definitions makes irreversible steps unwritable. The [BROKEN LINK: *Design Implications for the Pipeline Tool] specialize this principle to a user interface – per-step invertibility classification propagated through the chain – not a claim that the chain is a well-behaved lens.

A Janus-style codec in Clojure makes the structural guarantee concrete. Augmented assignment (x += k) has a mechanically-derived inverse (x -= k): the encode and decode functions are mirror images, and the round-trip property is provable by inspection.

;; Janus-style augmented-assignment codec.
;; x += k is invertible as x -= k -- the key `k` must travel with the value.
(defn janus-add-encode
  "Augmented assignment: add key to each char code."
  [k s]
  (apply str (map #(char (+ (int %) k)) s)))

(defn janus-add-decode
  "Mechanical inverse: subtract the same key."
  [k s]
  (apply str (map #(char (- (int %) k)) s)))

(-> "HELLO"
    (janus-add-encode 3)     ;;=> "KHOOR"  -- Caesar shift by 3
    (janus-add-decode 3))    ;;=> "HELLO"  -- exact recovery

The round-trip holds iff the key k is available at decode time. This is the ancilla requirement from Toffoli: the key is the extra information that makes the step reversible. In the pipeline tool, the XOR codec (xor 0x42) is exactly this pattern – self-inverse only because the key is hardcoded. A parameterized XOR would need to thread the key alongside the value, which is the v2 contract requirement.