Simulation in the Call-by-Need Lambda-Calculus with Letrec, Case, Constructors, and Seq

Abstract

Abstract. This paper shows equivalence of several versions of applicative similarity and contextual approximation, and hence also of applicative bisimilarity and contextual equivalence, in LR, the deterministic call-by-need lambda calculus with letrec extended by data constructors, case-expressions and Haskell's seq-operator. LR models an untyped version of the core language of Haskell. The use of bisimilarities simplifies equivalence proofs in calculi and opens a way for more convenient correctness proofs for program transformations.The proof is by a fully abstract and surjective transfer into a call-by-name calculus, which is an extension of Abramsky's lazy lambda calculus. In the latter calculus equivalence of our similarities and contextual approximation can be shown by Howe's method. Similarity is transferred back to LR on the basis of an inductively defined similarity.The translation from the call-by-need letrec calculus into the extended call-by-name lambda calculus is the composition of two translations. The first translation replaces the call-by-need strategy by a call-by-name strategy and its correctness is shown by exploiting infinite trees which emerge by unfolding the letrec expressions. The second translation encodes letrec-expressions by using multi-fixpoint combinators and its correctness is shown syntactically by comparing reductions of both calculi.A further result of this paper is an isomorphism between the mentioned calculi, which is also an identity on letrec-free expressions. ACM CCS: [Theory

Improvements in a functional core language with call-by-need operational semantics

“…Here we can built upon a detailed analysis of reduction lengths (performed in [20] in the context of a strictness analysis); the method of using diagrams to compute and join overlappings between reductions and transformations which we developed and applied in several works [7,20,13,14] to show correctness of program transformations; and correctness of inlining (or common subexpression elimination) via infinite expressions (unfolding the letrecs) established in [19]. We prefer analyzing reductions in LR, due to the success of the diagram method in LR.…”

“…We also recall several results from previous investigations: from [20] we reuse a counting theorem for reduction lengths and correctness of several program transformations. From [19] we reuse correctness of copying arbitrary expressions.…”

“…If diagram (18), (19), or (17) is applied, then rln(t) = rln(s) − 1 and Theorem 3.2 shows that rln(r) = rln(t). Applying the induction hypothesis to r shows rln mo (r) = rln(s) − 1.…”

Alpha-renaming of higher-order meta-expressions

“…both letrec-environments are non-empty and the let-variables of the inner environment are distinct from all variables occurring in the outer environment. An example where a non-empty context constraint is required is the following reduction rule from the calculus L need [18] which copies an abstraction into a needed position in a letrec-environment: While for ground expressions, α-renaming is a well-known task, our se ing is di erent. We want to apply α-renaming to the meta-expressions of LRSX, which of course cannot be computed for meta-variables until they are instantiated and become concrete expressions.…”

“…ese constructs are required to model typical small-step reduction rules of callby-need program calculi where reduction strategies are expressed by using an appropriate class of evaluation contexts (see e.g. [2,1,19,18]). …”