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 lambda-letrec-terms among all terms with the same infinite
unfolding. Instead of defined purely syntactically, this notion is based on a
graph semantics. lambda-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 lambda-letrec-term into a maximally compact form; and deciding
whether two lambda-letrec-terms are unfolding-equivalent. The transformation of
a lambda-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
lambda-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 lambda-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.Comment: 18 pages, plus 19 pages appendi