Reversible Recurrence Stack

• Reversible recurrence stack is a context data type that captures postponed recursive calls in invertible functions, enabling tail recursion transformation.
• It orchestrates a forward tail-recursive accumulation of context frames and a backward unwind to reconstruct original inputs, ensuring bijective computation.
• The approach is applied in reversible list reversal, language-level call-stack constructs, and processor architectures, offering efficient reversible computation.

Searching arXiv for papers on reversible recurrence stacks and related reversible recursion/stack models. A reversible recurrence stack is an explicit context data-type that converts invertible recursion into tail recursion by recording postponed recursive-call contexts as stack frames. In "Tail recursion transformation for invertible functions" (Kristensen et al., 2023), the construction is introduced for invertible functions under the observation that relaxing local reversibility to global invertibility drastically improves the situation for tail-recursion conversion. In related work, the same general concern—preserving information while unfolding and unwinding recursion—appears as a reversible producer/classical consumer split (Matos et al., 2021), as call-stack manipulation in the $\textsf{S-CORE}$ $\textsf{R-semantics}$ (Palazzo et al., 9 Jan 2025), and as a fully reversible call/return stack in the ReveR processor model (Vlasov, 2011).

1. Formal setting and the context data-type

The canonical formulation starts from an invertible function

$f : A \to B$

defined by a finite set of non-overlapping equations of two forms (Kristensen et al., 2023). Base clauses have the form

$f(p_k) = t_k$

for $k \in K$, where $p_k$ is a linear pattern of type $A$ and $t_k$ is a closed term of type $B$ with no recursive calls. Recursive clauses have the form

$f(p_i) = g_i(q_{i0}, q_{i1})$

for $\textsf{R-semantics}$0, where $\textsf{R-semantics}$1 is a pattern of type $\textsf{R-semantics}$2, $\textsf{R-semantics}$3 is the subproblem argument in which $\textsf{R-semantics}$4 may appear, $\textsf{R-semantics}$5 is the static piece with no recursive calls, and $\textsf{R-semantics}$6 is itself a well-formed and thus invertible function. Because the $\textsf{R-semantics}$7 are pairwise disjoint, the invocation sites $\textsf{R-semantics}$8 are distinguishable.

The reversible recurrence stack is the algebraic data-type that makes these postponed calls explicit. It is given by

$\textsf{R-semantics}$9

where $f : A \to B$0 denotes the empty stack and each $f : A \to B$1 records that the $f : A \to B$2-th recursive clause was taken, together with the remembered static argument and the remainder of the stack. Operationally, each constructor $f : A \to B$3 records “we saw a recursive call of the $f : A \to B$4-th clause, we must later apply $f : A \to B$5 with the second sub-pattern argument $f : A \to B$6, and then continue unwinding the remainder of the stack $f : A \to B$7” (Kristensen et al., 2023).

This construction deforests recursion into an explicit stack of postponed $f : A \to B$8-calls. A plausible implication is that the stack serves as a semantic replacement for an implicit call stack, but with the frame structure derived directly from the recursive equations rather than from a runtime control mechanism.

2. Tail-recursive forward and backward transformations

The transformed program consists of a forward tail-recursive function and a backward tail-recursive inverse:

$f : A \to B$9

The forward direction collects recursive calls into the context until a base clause is reached, while the backward direction pops the context and re-applies inverse branch functions (Kristensen et al., 2023).

For the forward pass: $\textsf{R-semantics}$02 and, equivalently, for recursive clauses,

$f(p_k) = t_k$0

No further computation occurs after the recursive call, so the transformation is tail-recursive.

For the backward pass: $\textsf{R-semantics}$03 In the $f(p_k) = t_k$1 case, $f(p_k) = t_k$2 must have arisen from some base-clause result $f(p_k) = t_k$3; since the original function is well-formed and injective on each branch, $f(p_k) = t_k$4 is uniquely invertible to the original $f(p_k) = t_k$5-form. In the framed case, the remembered static component $f(p_k) = t_k$6 selects the appropriate inverse $f(p_k) = t_k$7 and the computation proceeds by unwinding the stack.

The abstract characterization of the method emphasizes two points: calls are highlighted, and a tail-recursive inverse can be straightforwardly extracted (Kristensen et al., 2023). This suggests that the context is not merely a storage device but the central carrier of invertible control information.

3. Reversible list reversal as a worked example

The paper’s concrete example is the self-inverse recursive list reverse: $\textsf{R-semantics}$04 Here there is one recursive clause, with $f(p_k) = t_k$8, $f(p_k) = t_k$9, $k \in K$0, and $k \in K$1 (Kristensen et al., 2023).

The corresponding context data-type is: $\textsf{R-semantics}$05 The forward tail-recursive phase is $\textsf{R-semantics}$06 and the backward unwinding phase is $\textsf{R-semantics}$07 where $k \in K$2 is the inverse of the remembered $k \in K$3-application. Concretely, $k \in K$4, given $k \in K$5 and the remembered $k \in K$6, recovers $k \in K$7.

The reconstructed composite definition is $\textsf{R-semantics}$08 and the paper states that one checks by a simple induction on list length that

$k \in K$8

(Kristensen et al., 2023).

The example is significant because it isolates the mechanism of the reversible recurrence stack in a familiar recursive function: one forward pass removes recursive nesting by accumulating frames, and one backward pass reconstructs the original input by consuming those frames in reverse order.

4. Correctness, invertibility, and semantic status

The correctness argument is given as a proof sketch by structural induction on the depth of the call stack. For list reversal, the required equalities are

$k \in K$9

(Kristensen et al., 2023). In the base step, $p_k$0 and then $p_k$1 because the base clause is itself invertible. In the induction step, one assumes the claim for a smaller context and shows that one more frame reconstructs the original recursive argument by applying $p_k$2 with the remembered static value and then continuing unwinding.

In the general case, each $p_k$3 enforces the unique choice of $p_k$4, and the well-formedness condition—expressed as orthogonality of patterns—guarantees determinism of push/pop behavior and thus global invertibility (Kristensen et al., 2023). The paper’s central methodological claim is precisely that functions introduced by program transformations that preserve invertibility need only be invertible in the context in which the transformed function calls them.

This emphasis on global invertibility rather than local reversibility distinguishes the construction from standard CPS-based tail-recursion conversion, which the paper describes as deeply problematic in reversible programming because it relies on troublesome features such as higher-order functions (Kristensen et al., 2023). A related semantic distinction appears in $p_k$5: the commonly used method of reversibilization yields partial bijective functions by halting when unique reconstruction of the starting state is impossible, whereas the $p_k$6 makes all terms total bijections on an appropriate state space (Palazzo et al., 9 Jan 2025). A common misconception is therefore to treat all “reversible” stack formalisms as partial-bijection schemes; the cited work shows that total bijective operational semantics is also attainable.

5. Cost model and producer/consumer realization

For the context-based tail-recursion transformation, the depth of the $p_k$7 stack equals the recursion depth of the original function on the given argument; in the worst case, this is the same as the original recursive depth, such as $p_k$8 for a list of length $p_k$9 (Kristensen et al., 2023). Each recursive step in the forward pass pushes one small frame of size $A$0 and performs $A$1 work aside from pattern matching; the backward pass performs a matching number of pop steps, each applying one inverse call $A$2, again $A$3 per frame. Overall time and space remain $A$4 as in the original, with constant overhead for constructing and deconstructing the explicit stack and invoking the inverse functions. The paper further states that, in a real implementation, the two tail-recursive passes can be collapsed into a single loop over $A$5, eliminating additional call-stack overhead and leaving only heap-allocated context frames (Kristensen et al., 2023).

A distinct but closely related implementation pattern is the split into reversible and classical interacting threads. In "Splitting recursion schemes into reversible and classical interacting threads" (Matos et al., 2021), a simple recursive function

$A$6

is compiled into the parallel composition

$A$7

The reversible producer thread unfolds recursion depth by iterating $A$8 down to the base case, sends the depth $A$9, then rewinds via $t_k$0 and emits the arguments required by the classical consumer. The consumer receives the base-case argument, computes $t_k$1, and then computes $t_k$2 in lock-step with producer unwinding. Under the assumption $t_k$3, the producer and consumer both run in $t_k$4 time, and the producer’s ancilla overhead is $t_k$5 (Matos et al., 2021).

This split realizes a reversible recurrence stack without storing an explicit chain of full activation records. A plausible implication is that the context-stack view and the producer/consumer view are complementary: the first externalizes postponed calls as algebraic frames, while the second externalizes recursion depth and unwinding arguments as synchronized communication.

6. Language-level and processor-level realizations

At the language level, "Reversible Computation with Stacks and 'Reversible Management of Failures'" extends $t_k$6 with the constructs $t_k$7 and $t_k$8 over a distinguished variable $t_k$9, the call-stack register (Palazzo et al., 9 Jan 2025). A global configuration is

$B$0

with $B$1, so every variable carries a current value, a value-stack, and a failure-counter. The paper states the key cancellation lemma

$B$2

and from this derives that the operational semantics is a total bijection on the global configuration space. In recursive settings, attempted illegal pops do not crash the machine; instead they increment the local failure-counter, and subsequent pushes can repair the variable. The account explicitly states that there is never a hard failure, even under arbitrarily nested calls, because backward execution recovers a clean original state frame by frame.

At the processor level, ReveR provides a concrete reversible call/return stack in hardware-like form (Vlasov, 2011). Its state vector is

$B$3

with $B$4 holding an address into unified memory. A $B$5 executes a reversible exchange $B$6 followed by $B$7, and a $B$8 executes $B$9 then exchanges $f(p_i) = g_i(q_{i0}, q_{i1})$0. Procedure calls use the assembler mnemonic $f(p_i) = g_i(q_{i0}, q_{i1})$1, which pushes the old $f(p_i) = g_i(q_{i0}, q_{i1})$2 onto the stack; returns use $f(p_i) = g_i(q_{i0}, q_{i1})$3, which pops that stored $f(p_i) = g_i(q_{i0}, q_{i1})$4 and corrects it by a known offset so that the external update $f(p_i) = g_i(q_{i0}, q_{i1})$5 lands exactly one instruction past the call site. During nested or recursive invocations, the stack grows downward and shrinks back in the exact reverse order, and a single call pushes one $f(p_i) = g_i(q_{i0}, q_{i1})$6-bit word (Vlasov, 2011).

Taken together, these realizations show that a reversible recurrence stack is not confined to source-level program transformation. It can be expressed as a semantic discipline in a reversible imperative language and as an operational mechanism in a reversible processor architecture.

7. Related but distinct notions

The phrase “reverse stack” also appears in combinatorics, but there it denotes something different. In "Passing through a stack $f(p_i) = g_i(q_{i0}, q_{i1})$7 times with reversals" (Mansour et al., 2018), a permutation is repeatedly passed through a single stack, elements are popped only when the top matches the next output value, and any remaining entries are returned to the input in reverse order at the end of the pass. The resulting notion of rev-tier is the minimal number $f(p_i) = g_i(q_{i0}, q_{i1})$8 such that the permutation is sorted by $f(p_i) = g_i(q_{i0}, q_{i1})$9 reverse passes.

This is a stack-sorting model rather than a model of reversible recursion or invertible program execution. Its “reversal” refers to reversing residual stack contents between passes, not to inverting computation. The distinction matters because the reversible recurrence stack concerns preservation of information and extraction of an inverse computation, whereas reverse-pass stack sorting concerns permutation classes, separated pairs, finite bases, and generating functions (Mansour et al., 2018).

Within reversible computing proper, the core idea remains stable across the cited work: recursion is made compatible with inversion by explicitly preserving the information that an ordinary call stack would otherwise hide or erase. In the algebraic formulation, that information is stored as $\textsf{R-semantics}$00 constructors; in interacting-thread realizations, it is transmitted as depth and unwind arguments; in $\textsf{R-semantics}$01 and ReveR, it is maintained by bijective push/pop and call/return rules.