Expressibility in the Lambda Calculus with Letrec

We investigate the relationship between finite terms in lambda-letrec, the lambda calculus with letrec, and the infinite lambda terms they express. As there are easy examples of lambda-terms that, intuitively, are not unfoldings of terms in lambda-letrec, we consider the question: How can those infinite lambda terms be characterised that are lamda-letrec-expressible in the sense that they can be obtained as infinite unfoldings of terms in lambda-letrec? For ‘observing’ infinite lambda-terms through repeated ’experiments’ carried out at the head of the term we introduce two rewrite systems (with rewrite relations) -reg-> and -reg+-> that decompose the term, and produce ‘generated subterms’ in two notions. Thereby the sort of the step can be observed as well as its target, a generated subterm. In both systems there are four sorts of decomposition steps: -lambda-> steps (decomposing a lambda-abstraction), -@0> and -@1> steps (decomposing an application into its function and argument), and respectively, -del-> steps (delimiting the scope of an abstraction, for -reg->), and -S-> (delimiting of scopes, for -reg+->). These steps take place on infinite lambda-terms furnished with a leading prefix of abstractions for gathering previously encountered lambda-abstractions and keeping the generated subterms closed. We call an infinite lambda-term ‘regular’/‘strongly regular’ if its set of -reg-> -reachable / -reg-> -reachable generated subterms is finite. Furthermore, we analyse the binding structure of lambda-terms with the concept of ‘binding-capturing chain’. Using these concepts, we answer the question above by providing two characterisations of lambda-letrec-expressibility. For all infinite lambda-terms M, the following statements are equivalent: (i) M is lambda-letrec-expressible; (ii) M is strongly regular; (iii) M is regular, and it only has finite binding-capturing chains.

💡 Research Summary

The paper investigates which infinite λ‑terms can be obtained as the infinite unfoldings of finite λ‑letrec expressions, i.e., which infinite terms are “λ‑letrec‑expressible”. The authors begin by formalising λ‑letrec, an extension of the λ‑calculus that allows recursive let‑bindings, and by observing that not every infinite λ‑term can be generated by such a finite syntax. To analyse infinite terms systematically they introduce two rewrite systems, denoted –reg→ and –reg+→. Both systems work on infinite λ‑terms that are prefixed by a (possibly empty) sequence of λ‑abstractions; this prefix records all abstractions that have been encountered so far and guarantees that every generated subterm remains closed.

In –reg→ there are four kinds of decomposition steps: –λ→ (decompose a λ‑abstraction), –@0→ and –@1→ (decompose an application into its function and argument), and –del→ (delimit the scope of the most recent abstraction). The –reg+→ system replaces the –del→ step by a more general –S→ step that can delimit scopes in a flexible way, allowing a finer control of the binding structure during decomposition. By repeatedly applying these steps one obtains a set of “generated subterms”.

An infinite λ‑term is called regular if the set of –reg→‑reachable generated subterms is finite, and strongly regular if the set of –reg+→‑reachable generated subterms is finite. Strong regularity is a stricter condition because the –reg+→ system distinguishes more subtle scope delimitations.

To capture the influence of variable binding on expressibility the authors introduce the notion of a binding‑capturing chain. A chain is a sequence of abstractions where each abstraction captures a variable bound by a preceding abstraction. If such a chain can be extended indefinitely, the term exhibits an unbounded nesting of scopes that cannot be simulated by a finite let‑rec definition.

The main result is a triple equivalence for any infinite λ‑term M:

1. M is λ‑letrec‑expressible – there exists a finite λ‑letrec term whose infinite unfolding yields M.
2. M is strongly regular – the –reg+→ system generates only finitely many distinct subterms from M.
3. M is regular and all its binding‑capturing chains are finite – the –reg→ system yields a finite set of subterms and the binding structure does not contain infinite chains.

The proof proceeds in three directions. (i) ⇒ (ii) is shown by observing that any finite λ‑letrec term unfolds into a finite graph of let‑bindings; the corresponding –reg+→ decomposition can only produce finitely many distinct subterms, establishing strong regularity. (ii) ⇒ (iii) follows because strong regularity implies regularity, and the finiteness of –reg+→ subterms forces every binding‑capturing chain to be bounded; otherwise the –S→ steps would generate infinitely many distinct contexts. (iii) ⇒ (i) is the most constructive part: given a regular term with only finite chains, one can extract a finite set of generated subterms and encode the binding relationships among them as a finite system of let‑rec equations. This system, when unfolded, reproduces the original infinite term.

Thus the paper provides a complete characterisation of the infinite λ‑terms that can be expressed by λ‑letrec: they are exactly the strongly regular terms, or equivalently the regular terms without infinite binding‑capturing chains.

Beyond the theoretical classification, the work offers practical tools for functional‑programming language implementations and program analysis. The rewrite systems –reg→ and –reg+→ give a mechanised way to test whether a given infinite λ‑term is λ‑letrec‑expressible by checking finiteness of the generated subterm sets. The binding‑capturing chain analysis supplies a structural criterion that can be incorporated into static analysis tools to detect non‑letrec‑expressible recursion patterns. Consequently, the results can guide compiler optimisations, transformation of infinite data structures (such as streams or infinite trees) into finite let‑rec definitions, and the design of languages that aim to balance expressive power with tractable reasoning about infinite behaviours.