Memoryless computation: new results, constructions, and extensions

In this paper, we are interested in memoryless computation, a modern paradigm to compute functions which generalises the famous XOR swap algorithm to exchange the contents of two variables without using a buffer. This uses a combinatorial framework for procedural programming languages, where programs are only allowed to update one variable at a time. We first consider programs which do not have any memory. We prove that any function of $n$ variables can be computed this way in only $4n-3$ variable updates. We then derive the exact number of instructions required to compute any manipulation of variables. This shows that combining variables, instead of simply moving them around, not only allows for memoryless programs, but also yields shorter programs. Second, we show that allowing programs to use memory is also incorporated in the memoryless computation framework. We then quantify the gains obtained by using memory: this leads to shorter programs and allows us to use only binary instructions, which is not sufficient in general when no memory is used.

💡 Research Summary

**
The paper investigates a computational model called memoryless computation (MC), in which a program may update only one register at a time and is not allowed to use any auxiliary storage. The authors formalize this model using a finite alphabet A of size q (≥ 2) and n registers, each holding an element of A. An instruction is defined as a transformation of Aⁿ that changes at most one coordinate non‑trivially; such instructions can be written in update form y_i ← g_i(y). Two basic types of instructions are highlighted: transpositions (u, v) that swap two states differing in a single coordinate, and the assignment (e₀ → e₁) that maps the all‑zero state to a unit vector.

Section 2 proves universality: any transformation f : Aⁿ → Aⁿ can be realized by a sequence of the above instructions. By ordering all qⁿ states according to a Gray code, consecutive states differ in exactly one coordinate, so the corresponding transpositions generate the full symmetric group Sym(Aⁿ). Adding the rank‑(qⁿ − 1) assignment yields a generating set for the entire transformation monoid, establishing Theorem 1. This shows that memoryless programs can compute any function, albeit with potentially long programs.

Section 3 introduces procedural complexity L(f), the minimal length of a program that computes f. The authors focus on transpositions (a, b) and prove Proposition 1: the complexity of swapping two states equals 2·d − 1, where d is their Hamming distance. The proof constructs a chain of intermediate states differing in a single coordinate, yielding an upper bound of 2d − 1, and shows that any shorter program would violate bijectivity, giving a matching lower bound. Consequently, the worst‑case complexity of any permutation in Sym(Aⁿ) is 2ⁿ − 1, independent of the alphabet size. This result refines earlier upper bounds and connects the problem to combinatorial representations of coordinate functions.

Section 4 studies manipulations of variables, i.e., permutations of the register indices. For a mapping φ : {1,…,n} → {1,…,n}, the induced transformation f(x₁,…,x_n) = (x_{φ(1)},…,x_{φ(n)}) is examined. The authors derive exact instruction counts for arbitrary φ and demonstrate that combining variables (using algebraic operations) can lead to shorter programs than merely moving them. In particular, any manipulation can be performed with at most 4n − 3 updates, improving on the naïve 2n − 1 bound for simple swaps. The XOR‑swap example (three instructions) is generalized to arbitrary permutations, showing that memoryless computation yields compact in‑place algorithms for a wide class of data‑reordering tasks.

Section 5 extends the model by allowing a small number of extra registers (temporary memory). The key insight is that with one additional register, every instruction can be binary: it involves only two registers at a time, regardless of the original alphabet size. This binary restriction is impossible in the strict memoryless setting for non‑binary alphabets. Moreover, the presence of temporary memory reduces the total number of required updates, often dramatically below the 4n − 3 bound. The authors quantify these gains and provide constructions that achieve the optimal trade‑off between memory usage and program length.

Overall, the paper blends combinatorial group theory, Gray‑code constructions, and procedural complexity analysis to establish tight bounds for memoryless computation. It shows that any function can be realized with a linear‑size program, that the hardest permutations require exactly 2ⁿ − 1 updates, and that variable manipulations admit a universal 4n − 3 upper bound. By introducing limited memory, the authors further demonstrate that binary instruction sets become sufficient and that program lengths can be reduced, offering practical guidance for hardware designers seeking in‑place, low‑overhead algorithms. The results both deepen the theoretical understanding of MC and suggest concrete avenues for efficient implementation in register‑constrained or parallel architectures.