Programming Techniques for Reversible Comparison Sorts

Abstract

A common approach to reversible programming is to reversibly simulate an irreversible program with the desired functionality, which in general puts additional pressure on the computational resources (time, space.) If the same running time is required, ensuring a minimal space overhead is a significant programming challenge.

We introduce criteria for the optimality of reversible simulation: A reversible simulation is faithful if it incurs no asymptotic time overhead and bounds the space overhead (the garbage) by some function g(n), and hygienic if g is (asymptotically) optimal for faithful simulation.

We demonstrate the programming techniques used to develop faithful and hygienic reversible simulations of several well-known comparison sorts, e.g. insertion sort and quicksort, using representations of permutations in both the output and intermediate additional space required.

A Converting Between Permutation Representations

Factorial Representation to Rank. Procedure decfac2rank takes a decreasing factorial representation d[], its length n, and zero-cleared rank as arguments, and returns the lexicographic rank (in rank) of the decreasing factorial representation, with d[] zero-cleared (n is preserved):

Direct to Factorial Representation. Procedure perm2decfac is based on an irreversible unranking algorithm by Bonet [4]. The procedure converts from the direct permutation p[] of length n to decreasing factorial representation d[] using an intermediate tree data structure (here in the form of the array t[] which is initially and finally zero cleared). The key idea of the algorithm is to use the tree t[] to perform the count of how many elements in p[i+1..n-1] are smaller than p[i] in a logarithmic number of updates:

We use syntactic sugar in the expressions: the power operator **, which we assume to run in constant time for powers of two (e.g. as realized by left rotation), and the function log2_ceil(n), which evaluates to $\lceil \log _2 n \rceil$. Executable versions are available at topps.diku.dk/pirc/sorts.

The tree t[] has root t[1] and the left and right children of node t[ i ] are t[2i ] and t[ $2i+1$ ] for any $i~(\ge 1)$. The call to make_tree (code not shown) at line 23 sets each node in the tree to two to the power of its height (how many times it is visited.) make_tree reversibly simulates the irreversible codelet [4]:

Rank to Direct Representation. The implementations decfac2rank and perm2decfac above are reversible and in particular garbage-free, so each procedure can cover conversion in both directions. For instance, the inverse invocation uncall decfac2rank(d,n,r) converts the rank r to the length n factorial representation d[] (initially zero-cleared), clearing r in the process. Further, we can implement the remaining conversions between permutation and rank by subsequent calls to perm2decfac and decfac2rank.