Maximal sharing in the Lambda calculus with letrec

Abstract

Increasing sharing in programs is desirable to compactify the code, and to avoid duplication of reduction work at run-time, thereby speeding up execution. We show how a maximal degree of sharing can be obtained for programs expressed as terms in the lambda calculus with letrec. We introduce a notion of 'maximal compactness' for λ letrec -terms among all terms with the same infinite unfolding. Instead of defined purely syntactically, this notion is based on a graph semantics. λ letrec -terms are interpreted as first-order term graphs so that unfolding equivalence between terms is preserved and reflected through bisimilarity of the term graph interpretations. Compactness of the term graphs can then be compared via functional bisimulation.We describe practical and efficient methods for the following two problems: transforming a λ letrec -term into a maximally compact form; and deciding whether two λ letrec -terms are unfolding-equivalent. The transformation of a λ letrec -term L into maximally compact form L0 proceeds in three steps: (i) translate L into its term graph G = L ; (ii) compute the maximally shared form of G as its bisimulation collapse G0 ; (iii) read back a λ letrec -term L0 from the term graph G0 with the property L0 = G0. This guarantees that L0 and L have the same unfolding, and that L0 exhibits maximal sharing.The procedure for deciding whether two given λ letrec -terms L1 and L2 are unfolding-equivalent computes their term graph interpretations L1 and L2 , and checks whether these term graphs are bisimilar.For illustration, we also provide a readily usable implementation.

On the Relative Usefulness of Fireballs

“…Despite quadratic and quasi-linear recent algorithms [6], [37] for testing equality of terms with ES, we discovered that a linear algorithm can be obtained slightly modifying an algorithm already known quite some time before (1976! ): the Paterson-Wegman linear unification algorithm [38] (better explained in [39]).…”

Sharing Equality is Linear

“…First, the already cited quadratic one by Acca oli and Dal Lago. Second, a O(n log n) algorithm by Grabmayer and Rochel [21] (where n is the sum of the sizes of the shared terms to compare, and the input of the algorithm is a graph), obtained by a reduction to equivalence of DFAs and treating the more general case of λ-terms with letrec.…”

Modeling Terms by Graphs with Structure Constraints (Two Illustrations)

“…On this basis Jan Rochel and I developed a 'representation pipeline' from higher-order terms to deterministic finite-state automata (DFAs): (1) Terms in the λ -calculus with letrec can be represented by appropriately defined higher-order term graphs, which are first-order term graphs together with higherorder features such as a scope function, or an abstraction prefix function, that are defined on the set of vertices (see [12]); (2) higher-order term graphs are encoded as first-order term graphs (see also [12]), and (3) first-order term graphs are represented as DFAs (see [13]). In this way unfolding equivalence on terms is represented by bisimulation equivalence on term graphs (higher-order and first-order), and ultimately, by language equivalence of DFAs.…”