E-mail: howe research.att.com We give a method for proving congruence of bisimulation-like equivalences in functional programming languages. The method applies to languages that can be presented as a set of expressions together with an evaluation relation. We use this method to show that some generalizations of Abramsky's applicative bisimulation are congruences whenever evaluation can be specified by a certain natural form of structured operational semantics. One of the generalizations handles nondeterminism and diverging computations.] 1996 Academic Press, Inc. 1.

A parametric logical relation between the phrases of an Algol-like language is presented. Its definition involves the structural operational semantics of the language, but was inspired by recent denotationally-based work of O’Hearn and Reynolds on translating Algol into a predicatively polymorphic linear lambda calculus. The logical relation yields an applicative characterisation of contextual equivalence for the language and provides a useful (and complete) method for proving equivalences. Its utility is illustrated by giving simple and direct proofs of some contextual equivalences, including an interesting equivalence due to O’Hearn which hinges upon the undefinability of ‘snapback ’ operations (and which goes beyond the standard suite of ‘Meyer-Sieber ’ examples). Whilst some of the mathematical intricacies of denotational semantics are avoided, the hard work in this operational approach lies in establishing the ‘fundamental property’ for the logical relation—the proof of which makes use of a compactness property of fixpoint recursion with respect to evaluation of phrases. But once this property has been established, the logical relation provides a verification method with an attractively low mathematical overhead. 1.

In this thesis we present and analyse a set of automatic source-to-source program transformations that are suitable for incorporation in optimising compilers for lazy functional languages. These transformations improve the quality of code in many different respects, such as execution time and memory usage. The transformations presented are divided in two sets: global transformations, which are performed once (or sometimes twice) during the compilation process; and a set of local transformations, which are performed before and after each of the global transformations, so that they can simplify the code before applying the global transformations and also take advantage of them afterwards. Many of the local transformations are simple, well known, and do not have major effects on their own. They become important as they interact with each other and with global transformations, sometimes in non-obvious ways. We present how and why they improve the code, and perform extensive experiments wit...

We give a new semantics for Nuprl's constructive type theory that justifies a useful embedding of the logic of the HOL theorem prover inside Nuprl. The embedding gives Nuprl effective access to most of the large body of formalized mathematics that the HOL community has amassed over the last decade. The new semantics is dramatically simpler than the old, and gives a novel and general way of adding set-theoretic equivalence classes to untyped functional programming languages.

Co-induction is an important tool for reasoning about unbounded structures. This tutorial explains the foundations of co-induction, and shows how it justifies intuitive arguments about lazy streams, of central importance to lazy functional programmers. We explain from first principles a theory based on a new formulation of bisimilarity for functional programs, which coincides exactly with Morris-style contextual equivalence. We show how to prove properties of lazy streams by co-induction and derive Bird and Wadler's Take Lemma, a well-known proof technique for lazy streams.

ing and using (L-unif) we have that any two lambdas that are everywhere undefined are equivalent. The classic example of an everywhere undefined lambda is Bot 4 = x:app(x:app(x; x); x:app(x; x)) In f , another example of an everywhere undefined lambda is the "do-forever" loop. Do 4 = f:Yv(Dox:Do(f(x)) By the recursive definition, for any lambda ' and value v Do(')(v) \Gamma!Ø Do(')('(v)) Reasoning about Functions with Effects 21 In f , either '(v) \Gamma!Ø v 0 for some v 0 or '(v) is undefined. In the latter case the computation is undefined since the redex is undefined. In the former case, the computation reduces to Do(')(v 0 ) and on we go. The argument for undefinedness of Bot relies only on the (app) rule and will be valid in any uniform semantics. In contrast the argument for undefinedness of Do(') relies on the (fred.isdef) property of f . Functional Streams We now illustrate the use of (L-unif-sim) computation to reason about streams represented as functions ...

This note gives a new proof of the `operational extensionality' property of Abramsky's lazy lambda calculus---namely the coincidence of contextual equivalence with a co-inductively defined notion of `applicative bisimilarity'. This purely syntactic result is here proved using a logical relation (due to Plotkin) between the syntax and its denotational semantics. The proof exploits a mixed inductive/coinductive characterisation of the logical relation recently discovered by the author.

Pure type systems and computational monads are two parameterized frameworks that have proved to be quite useful in both theoretical and practical applications. We join the foundational concepts of both of these to obtain monadic type systems. Essentially, monadic type systems inherit the parameterized higher-order type structure of pure type systems and the monadic term and type structure used to capture computational effects in the theory of computational monads. We demonstrate that monadic type systems nicely characterize previous work and suggest how they can support several new theoretical and practical applications. A technical foundation for monadic type systems is laid by recasting and scaling up the main results from pure type systems (confluence, subject reduction, strong normalisation for particular classes of systems, etc.) and from operational presentations of computational monads (notions of operational equivalence based on applicative similarity, co-induction proof techni...

. We give a new semantic foundation for type theories in the lineage of Martin-Lof's "polymorphic extensional" type theory, and use it to give a model of the constructive type theory of the interactive theorem proving system Nuprl. These type theories are based on an operational semantics of an untyped programming language. We show how to integrate classical set-theoretic objects, such as functions-as-graphs and equivalence classes, into this operational framework. The new semantics is dramatically simpler than the previous ones, and enables direct reasoning about classical mathematics. A practical consequence is that it justifies a useful embedding of the logic of the HOL theorem prover that gives Nuprl effective access to most of the large body of formalized mathematics that the HOL community has amassed over the years. 1 Introduction The so-called "polymorphic extensional" type theory of Martin-Lof (Martin-Lof, 1982) has two features that set it apart from other constructive type t...

Techniques of operational semantics do not apply universally to all language varieties: techniques that work for simple functional languages may not apply to more realistic languages with features such as objects and memory effects. We focus mainly on the characterization of the so-called finite elements. The presence of finite elements in a semantics allows for an additional powerful induction mechanism. We show that in some languages a reasonable notion of finite element may be defined, but for other languages this is problematic, and we analyse the reasons for these difficulties. We develop a formal theory of language embeddings and establish a number of properties of embeddings. More complex languages are given semantics by embedding them into simpler languages. Embeddings may be used to establish more general results and avoid reproving some results. It also gives us a formal metric to describe the gap between different languages. Dimensions of the untyped programming language design space addressed here include functions, injections, pairs, objects, and memories. 1