A Structural Approach to Reversible Computation

Reversibility is a key issue in the interface between computation and physics, and of growing importance as miniaturization progresses towards its physical limits. Most foundational work on reversible computing to date has focussed on simulations of low-level machine models. By contrast, we develop a more structural approach. We show how high-level functional programs can be mapped compositionally (i.e. in a syntax-directed fashion) into a simple kind of automata which are immediately seen to be reversible. The size of the automaton is linear in the size of the functional term. In mathematical terms, we are building a concrete model of functional computation. This construction stems directly from ideas arising in Geometry of Interaction and Linear Logic—but can be understood without any knowledge of these topics. In fact, it serves as an excellent introduction to them. At the same time, an interesting logical delineation between reversible and irreversible forms of computation emerges from our analysis.

💡 Research Summary

The paper addresses the growing importance of reversible computation as physical limits of miniaturisation are approached. While most prior work has focused on simulating low‑level reversible machines (e.g., reversible Turing machines), this work takes a high‑level, structural perspective. The authors introduce a new computational model called a “pattern‑matching automaton”. An automaton consists of a finite set of states, distinguished initial and final states, and a finite set of transition rules of the form (q, r) → (s, q′) where r and s are terms possibly containing variables. Two crucial syntactic restrictions are imposed on the rule set: left‑linearity (each variable occurs at most once in a pattern r) and non‑ambiguity (no two rules with the same source state have unifiable patterns). These restrictions guarantee that, for any configuration (state, ground term), at most one rule applies, making the transition relation a partial function and the computation deterministic.

From any such automaton A the authors define a dual automaton Aᵒᵖ by reversing each rule and swapping pattern and result. If A satisfies the two syntactic constraints, so does Aᵒᵖ, and Aᵒᵖᵒᵖ = A. Consequently, the class of “bi‑orthogonal” automata (those whose duals are also orthogonal) enjoys step‑by‑step reversibility: every forward computation can be uniquely run backwards by using the dual automaton. This gives a very concrete, low‑level model of reversible computation.

The second major contribution is to connect this automaton model to functional programming via combinatory logic. The paper reviews ordinary combinatory logic (SK‑calculus) and then introduces Linear Combinatory Logic (LCL), a refinement that mirrors the exponential modality ‘!’ of linear logic. An LCL consists of an applicative structure (A,·), a unary “bang” operator !, and distinguished combinators B, C, I, K, D, δ, F, W satisfying a set of equations that encode linear composition, exchange, weakening, dereliction, duplication, functoriality, and contraction. By interpreting ordinary application as a·ₛb = a·!b, the authors embed the ordinary SK‑algebra into an LCL, thereby obtaining a linear version of the usual combinators.

Crucially, each linear combinator can be represented as a small pattern‑matching automaton whose transition rules respect left‑linearity and non‑ambiguity. Thus, the process of “compiling” a high‑level functional term into an automaton is syntax‑directed: the abstract syntax tree of the term is translated into a network of automata, preserving the term’s structure. The size of the resulting automaton is linear in the size of the source term, avoiding the exponential blow‑up typical of low‑level reversible simulations.

The paper also explores the logical distinction between reversible and irreversible computation. In the linear‑logic perspective, the multiplicative‑additive fragment (⊗, ⊕) corresponds to reversible operations that use each argument exactly once, while the exponential modality ‘!’ introduces copying and discarding, which are inherently irreversible. This delineation suggests a type‑theoretic way to separate reversible sub‑languages from general functional languages.

Finally, the authors prove universality: the class of bi‑orthogonal automata can simulate any partial recursive function, and conversely any such automaton can be expressed using the linear combinators. They also discuss interesting open problems, such as characterising the class of partial involutions that are representable in this framework.

In summary, the paper provides a clean, compositional bridge from high‑level functional programs to a concrete reversible automaton model, grounded in linear combinatory logic and geometry of interaction. It demonstrates that reversible computation can be achieved without low‑level encoding overhead, offers a clear logical taxonomy of reversible versus irreversible constructs, and opens avenues for reversible language design, reversible compiler construction, and low‑energy computing research.