Reversible Computation with Stacks and "Reversible Management of Failures"

This work examines approaches to making computational models reversible. Broadly speaking, transforming a computational model into a reversible one, i.e. reversibilizing it, means extending its operational semantics conservatively in a way that each term of the model is interpretable as a bijection. We recall that the most common strategy to reversibilize a computational model yields operational semantics that halts computations whenever a computational state cannot be uniquely determined from its successor state, thereby allowing terms to be interpreted as partial bijective functions. We are interested in reversible computational models whose terms can be interpreted as total bijective functions. This is essential for studying aspects of computational complexity related to reversible computational models. We introduce SCORE, a language designed for manipulating variables and stacks. Notably, common reversibilization strategies naturally lead to interpreting the functions for stack manipulation as partial bijections. According to our interests, we demonstrate how to interpret SCORE in a state space where, using a proof-assistant, we certify that stack operations are total bijections. It follows that all SCORE terms can be interpreted as total bijections.

💡 Research Summary

The paper addresses a fundamental limitation in existing reversible computation frameworks: most reversible‑by‑construction approaches only guarantee partial injectivity, aborting execution when a state cannot be uniquely recovered from its successor. This partiality hampers the study of reversible models from a complexity‑theoretic perspective, where total bijections are required. To overcome this, the authors distinguish two notions of reversibilization. “PIF‑reversibilization” (Partial Injective Functions) allows aborts and typically relies on runtime assertions to enforce that forward and backward executions agree. The Janus language exemplifies this approach, using a guard‑assert pair to synchronize the two directions of an if‑then‑else construct. While expressive, PIF‑reversibilization yields only partial functions.

In contrast, “TIF‑reversibilization” (Total Injective Functions) refines the underlying state space so that every instruction is defined for every possible state and has a unique inverse. The reversible imperative language SRL (State‑Rich Language) is a canonical instance: variables range over the integers ℤ, and the primitive operations INC and DEC are exact inverses. The FOR‑loop iterates |v| times, executing the body forward when v>0 and backward (the inverse program) when v<0, guaranteeing termination and totality without any asserts.

Building on SRL, the authors introduce SCORE (the paper’s name is stylized as S‑CORE), extending SRL with stack manipulation primitives PUSH and POP. Naïvely, POP on an empty stack would be undefined, breaking totality. To resolve this, each variable x is represented as a triple (current value v, history stack s, auxiliary metadata). PUSH pushes the current value onto s and resets v to 0; POP pops the top element of s and restores it as the new current value. By carefully designing the auxiliary component, the authors ensure that POP is always defined, even when the logical stack appears empty, effectively providing a “virtual” element that guarantees invertibility.

The core technical contribution is a machine‑checked proof, carried out in the Coq‑based proof assistant Coq/Rocq, that the push and pop functions form a mutual isomorphism on a suitably enriched three‑dimensional domain. The proof scripts are publicly released, demonstrating that the operational semantics of SCORE can be interpreted as a total bijection.

To illustrate the gradual refinement from a naïve reversible semantics to a fully total one, the paper defines three big‑step semantics:

• N‑semantics (Naïve) – the simplest interpretation where PUSH inserts the current value into the stack and resets it, while POP extracts the head of the stack. This semantics aborts on empty stacks, thus only yielding partial injectivity.

• A‑semantics (Assert‑based) – aligns with PIF‑reversibilization. It augments N‑semantics with runtime assertions that prevent illegal POPs, thereby preserving reversibility at the cost of added programmer‑written checks.

• R‑semantics (Total) – embodies TIF‑reversibilization. By extending the state space as described, PUSH and POP become total, mutually inverse operations. Consequently, every SCORE program terminates and its denotation is a total injective function from the initial state to the final state.

The authors also relate their construction to the “Injectivisation process” introduced by Glück and Yokoyama, which pairs a function f with an auxiliary output g to make the combined mapping invertible. In SCORE, the stack itself plays the role of the auxiliary output, ensuring that each stack operation can be uniquely reversed.

Finally, the paper contrasts SCORE with R‑CORE, another minimal reversible language that follows the PIF approach and relies on asserts for handling tree‑like data structures. SCORE’s assert‑free, TIF‑based design makes it a more suitable platform for investigating the computational complexity of reversible models, as all programs denote total bijections. The work thus contributes both a concrete reversible language with provably total semantics and a methodological blueprint for turning otherwise non‑reversible primitives into fully reversible ones through state‑space enrichment and formal verification.