Correctness of Copy in Calculi with Letrec

Schmidt-Schauß, Manfred

doi:10.1007/978-3-540-73449-9_25

Cited by 6 publications

(6 citation statements)

References 15 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We use infinite trees to connect both evaluation strategies. In [SS07] a similar result was shown for a lambda calculus without seq, case, and constructors. 5.1.…”

Section: Simulation In the Call-by-need Lambda Calculussupporting

confidence: 67%

“…L name is the call-by-name variant of L LR , and L lcc is obtained from L name by encoding letrec using multi-fixpoint combinators. The calculi L LR and L name are related to each other via their infinite unfoldings, thus we introduce a calculus L tree of infinite trees (similar infinitary rewriting, see [KKSdV97,SS07]). Convergence of expressions in L LR and L name is shown to be equivalent to their translation as an infinite tree in the calculus L tree (dotted lines in the picture).…”

mentioning

confidence: 99%

See 1 more Smart Citation

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

Schmidt-Schauß

Sabel

Machkasova³

2015

Logical Methods in Computer Science

Self Cite

View full text Add to dashboard Cite

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

show abstract

“…We use infinite trees to connect both evaluation strategies. In [SS07] a similar result was shown for a lambda calculus without seq, case, and constructors. 5.1.…”

Section: Simulation In the Call-by-need Lambda Calculussupporting

confidence: 67%

mentioning

confidence: 99%

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

Schmidt-Schauß

Sabel

Machkasova³

2015

Logical Methods in Computer Science

Self Cite

View full text Add to dashboard Cite

show abstract

“…This technique was used in [SS07] to show correctness of inlining in the deterministic call-by-need lambda calculus with letrec and also in [SSSM10] to show equivalence of the call-by-need lambda calculus with letrec and the lazy lambda calculus [Abr90].…”

Section: Correctness Of Call-by-name Reductionsmentioning

confidence: 99%

A contextual semantics for concurrent Haskell with futures

Sabel

Schmidt-Schauß

2011

Proceedings of the 13th International ACM SIGPLAN Symposium on Principles and Practices of Declarative Programming

Self Cite

View full text Add to dashboard Cite

Abstract.In this paper we analyze the semantics of a higher-order functional language with concurrent threads, monadic IO and synchronizing variables as in Concurrent Haskell. To assure declarativeness of concurrent programming we extend the language by implicit, monadic, and concurrent futures. As semantic model we introduce and analyze the process calculus CHF, which represents a typed core language of Concurrent Haskell extended by concurrent futures. Evaluation in CHF is defined by a small-step reduction relation. Using contextual equivalence based on may-and should-convergence as program equivalence, we show that various transformations preserve program equivalence. We establish a context lemma easing those correctness proofs. An important result is that call-by-need and call-by-name evaluation are equivalent in CHF, since they induce the same program equivalence. Finally we show that the monad laws hold in CHF under mild restrictions on Haskell's seq-operator, which for instance justifies the use of the do-notation.

show abstract

“…In this paper we develop a unification method to compute all overlaps of left hand sides of a set of transformations rules and the reduction rules of the calculus L need which is a call-by-need lambda calculus with a letrec-construct (see [12]). We show that a custom-tailored unification algorithm can be developed that is decidable and produces a complete and finite set of unifiers for the required equations.…”

Section: Introductionmentioning

confidence: 99%

“…to compute all the overlaps of l i and s 1 , and the possible completions under reduction and transformation. This method is reminiscent of the critical pair criterion of Knuth-Bendix method [8] but has to be adapted to an asymmetric situation, to extended instantiations and to higher-order terms.In this paper we develop a unification method to compute all overlaps of left hand sides of a set of transformations rules and the reduction rules of the calculus L need which is a call-by-need lambda calculus with a letrec-construct (see [12]). We show that a custom-tailored unification algorithm can be developed that is decidable and produces a complete and finite set of unifiers for the required equations.…”

mentioning

confidence: 99%

Towards Correctness of Program Transformations Through Unification and Critical Pair Computation

Rau¹,

Schmidt-Schauß²

2010

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

Correctness of program transformations in extended lambda calculi with a contextual semantics is usually based on reasoning about the operational semantics which is a rewrite semantics. A successful approach to proving correctness is the combination of a context lemma with the computation of overlaps between program transformations and the reduction rules, and then of so-called complete sets of diagrams. The method is similar to the computation of critical pairs for the completion of term rewriting systems. We explore cases where the computation of these overlaps can be done in a first order way by variants of critical pair computation that use unification algorithms. As a case study we apply the method to a lambda calculus with recursive let-expressions and describe an effective unification algorithm to determine all overlaps of a set of transformations with all reduction rules. The unification algorithm employs many-sorted terms, the equational theory of left-commutativity modelling multi-sets, context variables of different kinds and a mechanism for compactly representing binding chains in recursive let-expressions.

show abstract

Correctness of Copy in Calculi with Letrec

Cited by 6 publications

References 15 publications

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

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

A contextual semantics for concurrent Haskell with futures

Towards Correctness of Program Transformations Through Unification and Critical Pair Computation

Contact Info

Product

Resources

About