Results 1 
6 of
6
On generic context lemmas for lambda calculi with sharing
, 2008
"... This paper proves several generic variants of context lemmas and thus contributes to improving the tools for observational semantics of deterministic and nondeterministic higherorder calculi that use a smallstep reduction semantics. The generic (sharing) context lemmas are provided for may as we ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
This paper proves several generic variants of context lemmas and thus contributes to improving the tools for observational semantics of deterministic and nondeterministic higherorder calculi that use a smallstep reduction semantics. The generic (sharing) context lemmas are provided for may as well as two variants of mustconvergence, which hold in a broad class of extended process and extended lambda calculi, if the calculi satisfy certain natural conditions. As a guideline, the proofs of the context lemmas are valid in callbyneed calculi, in callbyvalue calculi if substitution is restricted to variablebyvariable and in process calculi like variants of the πcalculus. For calculi employing betareduction using a callbyname or callbyvalue strategy or similar reduction rules, some iuvariants of ciutheorems are obtained from our context lemmas. Our results reestablish several context lemmas already proved in the literature, and also provide some new context lemmas as well as some new variants of the ciutheorem. To make the results widely applicable, we use a higherorder abstract syntax that allows untyped calculi as well as certain simple typing schemes. The approach may lead to a unifying view of higherorder calculi, reduction, and observational equality.
On Conservativity of Concurrent Haskell
, 2011
"... Abstract. The calculus CHF models Concurrent Haskell extended by concurrent, implicit futures. It is a process calculus with concurrent threads, monadic concurrent evaluation, and includes a pure functional lambdacalculus which comprises data constructors, caseexpressions, letrecexpressions, and ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Abstract. The calculus CHF models Concurrent Haskell extended by concurrent, implicit futures. It is a process calculus with concurrent threads, monadic concurrent evaluation, and includes a pure functional lambdacalculus which comprises data constructors, caseexpressions, letrecexpressions, and Haskell’s seq. Futures can be implemented in Concurrent Haskell using the primitive unsafeInterleaveIO, which is available in most implementations of Haskell. Our main result is conservativity of CHF, that is, all equivalences of pure functional expressions are also valid in CHF. This implies that compiler optimizations and transformations from pure Haskell remain valid in Concurrent Haskell even if it is extended by futures. We also show that this is no longer valid if Concurrent Haskell is extended by the arbitrary use of unsafeInterleaveIO. 1
Extending Abramsky’s Lazy Lambda Calculus: (Non)Conservativity of Embeddings
, 2013
"... Abstract. Our motivation is the question whether the lazy lambda calculus, a pure lambda calculus with the leftmost outermost rewriting strategy, considered under observational semantics, or extensions thereof, are an adequate model for semantic equivalences in realworld purely functional programmi ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
Abstract. Our motivation is the question whether the lazy lambda calculus, a pure lambda calculus with the leftmost outermost rewriting strategy, considered under observational semantics, or extensions thereof, are an adequate model for semantic equivalences in realworld purely functional programming languages, in particular for a pure core language of Haskell. We explore several extensions of the lazy lambda calculus: addition of a seqoperator, addition of data constructors and caseexpressions, and their combination, focusing on conservativity of these extensions. In addition to untyped calculi, we study their monomorphically and polymorphically typed versions. For most of the extensions we obtain nonconservativity which we prove by providing counterexamples. However, we prove conservativity of the extension by data constructors and case in the monomorphically typed scenario. 1
Towards Correctness of Program Transformations Through Unification and Critical Pair Computation
, 2010
"... Abstract. Correctness of program transformations in extended lambdacalculi with a contextual semantics is usually based on reasoning about the operational semantics which is a rewrite semantics. A successful approach is the combination of a context lemma with the computation of overlaps between pro ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. Correctness of program transformations in extended lambdacalculi with a contextual semantics is usually based on reasoning about the operational semantics which is a rewrite semantics. A successful approach is the combination of a context lemma with the computation of overlaps between program transformations and the reduction rules, which results in socalled 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 of an application we describe a finitary and decidable unification algorithm for the combination of the equational theory of leftcommutativity modelling multisets, context variables and manysorted unification. Sets of equations are restricted to be almost linear, i.e. every variable and context variable occurs at most once, where we allow one exception: variables of a sort without ground terms may occur several times. Every context variable must have an argumentsort in the free part of the signature. We also extend the unification algorithm by the treatment of bindingchains in let and letrecenvironments and by contextclasses. This results in a unification algorithm that can be applied to all overlaps of normalorder reductions and transformations in an extended lambda calculus with letrec that we use as a case study. 1
A Finite Simulation Method in a NonDeterministic CallbyNeed Calculus with letrec, constructors and case
, 2008
"... Abstract. The paper proposes a variation of simulation for checking and proving contextual equivalence in a nondeterministic callbyneed lambdacalculus with constructors, case, seq, and a letrec with cyclic dependencies. It also proposes a novel method to prove its correctness. The calculus ’ sem ..."
Abstract
 Add to MetaCart
Abstract. The paper proposes a variation of simulation for checking and proving contextual equivalence in a nondeterministic callbyneed lambdacalculus with constructors, case, seq, and a letrec with cyclic dependencies. It also proposes a novel method to prove its correctness. The calculus ’ semantics is based on a smallstep rewrite semantics and on mayconvergence. The cyclic nature of letrec bindings, as well as nondeterminism, makes known approaches to prove that simulation implies contextual equivalence, such as Howe’s proof technique, inapplicable in this setting. The basic technique for the simulation as well as the correctness proof is called preevaluation, which computes a set of answers for every closed expression. If simulation succeeds in finite computation depth, then it is guaranteed to show contextual preorder of expressions. 1
Encoding Induction in Correctness Proofs of Program Transformations as a Termination Problem ∗
"... The diagrambased method to prove correctness of program transformations consists of computing complete set of (forking and commuting) diagrams, acting on sequences of standard reductions and program transformations. In many cases, the only missing step for proving correctness of a program transform ..."
Abstract
 Add to MetaCart
The diagrambased method to prove correctness of program transformations consists of computing complete set of (forking and commuting) diagrams, acting on sequences of standard reductions and program transformations. In many cases, the only missing step for proving correctness of a program transformation is to show the termination of the rearrangement of the sequences. Therefore we encode complete sets of diagrams as term rewriting systems and use an automated tool to show termination, which provides a further step in the automation of the inductive step in correctness proofs.