Normalization-by-evaluation

This paper introduces a new recursion principle for inductive data modulo α-equivalence of bound names. It makes use of Odersky-style local names when recursing over bound names. It is formulated in an extension of Gödel's System T with names that can be tested for equality, explicitly swapped in expressions and restricted to a lexical scope. The new recursion principle is motivated by the nominal sets notion of "α-structural recursion", whose use of names and associated freshness side-conditions in recursive definitions formalizes common practice with binders. The new Nominal System T presented here provides a calculus of total functions that is shown to adequately represent α-structural recursion while avoiding the need to verify freshness side-conditions in definitions and computations. Adequacy is proved via a normalization-by-evaluation argument that makes use of a new semantics of local names in Gabbay-Pitts nominal sets.

We show that Hyland and Ong's game semantics for PCF can be presented using normalization by evaluation (nbe). We use the bijective correspondence between innocent well-bracketed strategies and PCF Böhm trees, and show how operations on PCF Böhm trees, such as composition, can be computed lazily and simply by nbe. The usual equations characteristic of games follow from the nbe construction without reference to low-level game-theoretic machinery. As an illustration, we give a Haskell program computing the application of innocent strategies.

We e xtend normalization by e v aluation (rst presented in 5]) from the pure typed-calculus to general higher type term rewriting systems. We d istinguish between computational rules and proper rewrite rules, and de ne a domain theoretic model intended to explain why n ormalization by e v aluation for the former is much m ore e cient. Normalization by evaluation is proved to be correct w.r.t. this model.

This paper describes formalizations of Tait's normalization proof for the simply typed λ-calculus in the proof assistants Minlog, Coq and Isabelle/HOL. From the formal proofs programs are machine-extracted that implement variants of the well-known normalization-by-evaluation algorithm. The case study is used to test and compare the program extraction machineries of the three proof assistants in a non-trivial setting.

The effect of a fully-premixed pilot flame on the velocity-forced flame response of a fully premixed flame in a single-nozzle lean-premixed swirl combustor operating on natural gas fuel is investigated. Measurements of the flame transfer function show that as the percent pilot is increased there is a decrease in the flame transfer function gain at all frequencies, a decrease in the frequencies at which the gain minima and maxima occurred, and a decrease in the flame transfer function phase at high frequencies. High-speed CH* chemiluminescence flame imaging is used to gain a better understanding of the mechanism(s) whereby the pilot flame affects flame dynamics and thereby the flame transfer function. Time-averaged flame images show that the location of the maximum heat release rate does not change with forcing frequency or percent pilot, although the flame extends further upstream into the inner shear layer with increasing percent pilot. Heat release rate fluctuation images show tha...

We prove the correctness of an algorithm for normalizing untyped combinator terms by evaluation. The algorithm is written in the functional programming language Haskell, and we prove that it lazily computes the combinatory Böhm tree of the term. The notion of combinatory Böhm tree is analogous to the usual notion of Böhm tree for the untyped lambda calculus. It is defined operationally by repeated head reduction of terms to head normal forms. We use formal neighbourhoods to characterize finite, partial information about data, and define a Böhm tree as a filter of such formal neighbourhoods. We also define formal topology style denotational semantics of a fragment of Haskell following Martin-Löf, and let each closed program denote a filter of formal neighbourhoods. We prove that the denotation of the output of our algorithm is the Böhm tree of the input term. The key construction in the proof is a "glueing" relation between terms and semantic neighbourhoods which is defined by induction on the latter. This relation is related to the glueing relation which was earlier used for proving the correctness of a normalization by evaluation algorithm for typed combinatory logic.

In higher-order abstract syntax, the variables and bindings of an object language are represented by variables and bindings of a meta-language. Let us consider the simply typed λ-calculus as object language and Haskell as meta-language. For concreteness, we also throw in integers and addition, but only in this section.

In these lecture notes we give an introduction to functional programming with dependent types. We use the dependently typed programming language Agda which is an extension of Martin-Löf type theory. First we show how to do simply typed functional programming in the style of Haskell and ML. Some differences between Agda’s type system and the Hindley-Milner type system of Haskell and ML are also discussed. Then we show how to use dependent types for programming and we explain the basic ideas behind type-checking dependent types. We go on to explain the Curry-Howard identification of propositions and types. This is what makes Agda a programming logic and not only a programming language. According to Curry-Howard, we identify programs and proofs, something which is possible only by requiring that all program terminate. However, at the end of these notes we present a method for encoding partial and general recursive functions as total functions using dependent types.

We present an Agda formalization of a normalization proof for simply-typed lambda terms. The normalizer consists of two coinductively defined functions in the delay monad: One is a standard evaluator of lambda terms to closures, the other a type-directed reifier from values to η-long β-normal forms. Their composition, normalization-by-evaluation, is shown to be a total function a posteriori, using a standard logical-relations argument. The normalizer is then shown to be sound and complete. The completeness proof proof is dependent on termination. We also discuss a variation on this normalizer where environments used by the evaluator contain delayed values which can be proven complete independently of termination using weak bisimilarity. This approach would be a realisation of an aim of this work to present a modular proof of normalization where termination, soundness and completeness are independent. The successful formalization serves as a proof-of-concept for coinductive programmi...

A core programming language is presented that allows structural recursion over open LF objects and contexts. The main technical tool is a coverage checking algorithm that also generates valid recursive calls. Termination of call-byvalue reduction is proven using a reducibility semantics. This establishes consistency and allows the implementation of proofs about LF specifications as well-founded recursive functions using simultaneous pattern matching.

A core programming language is presented that allows structural recursion over open LF objects and contexts. The main technical tool is a coverage checking algorithm that also generates valid recursive calls. Termination of call-byvalue reduction is proven using a reducibility semantics. This establishes consistency and allows the implementation of proofs about LF specifications as well-founded recursive functions using simultaneous pattern matching.

The decidability of equality is proved for Martin-Löf type theory with a universeá la Russell and typed betaeta-equality judgements. A corollary of this result is that the constructor for dependent function types is injective, a property which is crucial for establishing the correctness of the type-checking algorithm. The decision procedure uses normalization by evaluation, an algorithm which first interprets terms in a domain with untyped semantic elements and then extracts normal forms. The correctness of this algorithm is established using a PER-model and a logical relation between syntax and semantics. * Research partially supported by the EU coordination action TYPES (510996). † Research partially supported by VR-project Typed Lambda Calculus and Applications. sional type theories such as Coq, Agda, and Epigram, all rely on the decision algorithm for a : A using normalization: the user attempts to prove the theorem A by building a construction a, and the system checks that a is indeed a proof of A.

Dependent function types Fun A λxB (= (x : A)-> B) with η. Predicative universes Set 0 , Set 1 ,. .. . Natural numbers. We handle large eliminations (types defined by cases and recursion), in contrast to Harper & Pfenning (2005). Scales to Σ types with surjective pairing.

In this paper we develop the language theory underpinning the logical framework PLF. This language features lambda abstraction with patterns and application via pattern-matching. Reductions are allowed in patterns. The framework is particularly suited as a metalanguage for encoding rewriting logics and logical systems where proof terms have a special syntactic constraints, as in term rewriting systems, and rule-based languages. PLF is a conservative extension of the well-known Edinburgh Logical Framework LF. Because of sophisticated pattern matching facilities PLF is suitable for verification and manipulation of HXML documents.

We study monadic translations of the call-by-name (cbn) and the call-by-value (cbv) fragments of the classical sequent calculus λµμ by Curien and Herbelin and give modular and syntactic proofs of strong normalization. The target of the translations is a new metalanguage for classical logic, named monadic λµ. It is a monadic reworking of Parigot's λµ-calculus, where the monadic binding is confined to commands, thus integrating the monad with the classical features. Also its µ-reduction rule is replaced by one expressing the interaction between monadic binding and µ-abstraction. Our monadic translations produce very tight simulations of the respective fragments of λµμ inside monadic λµ, with reduction steps of λµμ being translated in 1-1 fashion, except for β-steps which require two steps. The monad of monadic λµ can be instantiated to the continuations monad so as to ensure strict simulation of monadic λµ inside simply-typed λ-calculus with βand η-reduction. Through strict simulation, strong normalization of simply-typed λ-calculus is inherited to monadic λµ and then to cbn and cbv λµμ, thus reproving in an elementary syntactical way strong normalization for these fragments of λµμ and establishing it for our new calculus. These results extend to second-order logic, with polymorphic λ-calculus as target, giving new strong normalization results for classical second-order logic in sequent calculus style. CPS translations of cbn and cbv λµμ with the strict simulation property are obtained by composing our monadic translations with the continuations-monad instantiation. In an appendix to the article we investigate several refinements of the continuations-monad instantiation in order to obtain in a modular way improvements of the CPS translations enjoying extra properties like simulation by cbv β-reduction or reduction of administrative redexes at compile time. † The first and fourth author have been financed by FEDER funds through "Programa Operacional Factores de Competitividade-COMPETE" and by Portuguese funds through FCT-"Fundação para a Ciência e a Tecnologia", within the project PEst-C/MAT/UI0013/2011. ‡ The second author thanks the Centro de Matemática of Universidade do Minho for funding research visits to the first and fourth author. § The third author has been supported by the Kyoto University Foundation for an extended research visit to the second author.

This paper revisits the results of Barendregt and Ghilezan [3] and generalizes them for classical logic. Instead of λ-calculus, we use here λµ-calculus as the basic term calculus. We consider two extensionally equivalent type assignment systems for λµ-calculus, one corresponding to classical natural deduction, and the other to classical sequent calculus. Their relations and normalisation properties are investigated. As a consequence a short proof of Cut elimination theorem is obtained.

This paper revisits the results of Barendregt and Ghilezan [3] and generalizes them for classical logic. Instead of λ-calculus, we use here λµ-calculus as the basic term calculus. We consider two extensionally equivalent type assignment systems for λµ-calculus, one corresponding to classical natural deduction, and the other to classical sequent calculus. Their relations and normalisation properties are investigated. As a consequence a short proof of Cut elimination theorem is obtained.

Normalization of muscle activity has been commonly used to determine the amount of force exerted by a muscle. The most widely used reference point for normalization is the maximum voluntary contraction (MVC). However, MVCs are often subjective, and potentially limited by sensation of pain in injured individuals. The objective of the current study was to develop a normalization technique that predicts an electromyographic (EMG) reference point from sub-maximal exertions. Regression equations predicting maximum exerted trunk moments were developed from anthropometric measurements of 120 subjects. In addition, 20 subjects performed sub-maximal and maximal exertions to determine the necessary characteristic exertions needed for normalization purposes. For most of the trunk muscles, a highly linear relationship was found between EMG muscle activity and trunk moment exerted. This analysis determined that an EMG-moment reference point can be obtained via a set of sub-maximal exertions in combination with a predicted maximal exertion (expected maximum contraction or EMC) based upon anthropometric measurements. This normalization technique overcomes the limitations of the subjective nature for the MVC method providing a viable assessment method of individuals with a low back injury or those unwilling to exert an MVC as well as could be extended to other joints/muscles.

1 Introduction In this paper we solve the decision problem for sim-ply typed lambda calculus with categorical coprod-uct (strong disjoint sum) types. While this calculus is both natural and simple, the decision problem is a long-standing thorny issue in the subject. Our solu-tion ...

We present an abstract machine and a reduction semantics for the lambdacalculus extended with control operators that give access to delimited continuations in the CPS hierarchy. The abstract machine is derived from an evaluator in continuationpassing style (CPS); the reduction semantics (i.e., a small-step operational semantics with an explicit representation of evaluation contexts) is constructed from the abstract machine; and the control operators are the shift and reset family.

We study monadic translations of the call-by-name (cbn) and the call-by-value (cbv) fragments of the classical sequent calculus λµμ by Curien and Herbelin and give modular and syntactic proofs of strong normalization. The target of the translations is a new meta-language for classical logic, named monadic λµ. It is a monadic reworking of Parigot's λµ-calculus, where the monadic binding is confined to commands, thus integrating the monad with the classical features. Also its µ-reduction rule is replaced by one expressing the interaction between monadic binding and µ-abstraction.

We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive which is recognized by Agda's termination checker. Using Agda as an interactive theorem prover we establish that our normalization function precisely identifies βη-equivalent terms and hence can be used to decide βηequality. An interesting feature of this approach is that it is clear from the construction that βη-equality is primitive recursive.

We present direct proofs of termination of evaluation for typed delimited-control operators shift and reset using a variant of Tait's method with context-based reducibility predicates. We address both call by value and call by name, and for each reduction strategy we consider a type-and-effect systemà la Danvy and Filinski as well as a system with a fixed answer type. The call-by-value type-andeffect system we present is a refinement of Danvy and Filinski's original type system, whereas the call-by-name type-and-effect system is new. From the normalization proofs, we extract call-by-value and call-by-name evaluators in continuation-passing style with two layers of continuations; by construction, these evaluators are instances of normalization by evaluation.

We present a context-based approach to proving termination of evaluation in reduction semantics (i.e., a form of operational semantics with explicit representation of reduction contexts), using Tait-style reducibility predicates defined on both terms and contexts. We consider the simply typed lambda calculus as well as its extension with abortive control operators for first-class continuations under the call-by-value and the call-by-name evaluation strategies. For each of the proofs we present its computational content that takes the form of an evaluator in continuation-passing style and is an instance of normalization by evaluation.

The CIL compiler for core Standard ML compiles whole programs using a novel typed intermediate language (TIL) with intersection and union types and flow labels on both terms and types. The CIL term representation duplicates portions of the program where intersection types are introduced and union types are eliminated. This duplication makes it easier to represent type information and to introduce customized data representations. However, duplication incurs compile-time space costs that are potentially much greater than are incurred in TILs employing type-level abstraction or quantification. In this paper, we present empirical data on the compile-time space costs of using CIL as an intermediate language. The data shows that these costs can be made tractable by using sufficiently fine-grained flow analyses together with standard hash-consing techniques. The data also suggests that non-duplicating formulations of intersection (and union) types would not achieve significantly better space complexity.

Typed A-calculi have been objects of theoretical study for many years. Recently, it has been shown that all the inductively defined types (including numbers, booleans, lists, and trees, as well as more complex structures like typed terms and proofs) can be represented in higher-order A-calculi with no built-in types or type constructors. This raises the possibility of designing practical programming languages based on pure typed A-calculi.

We formulate principles of induction and recursion for a variant of lambda calculus in its original syntax
(i.e., with only one sort of names for both bound and free variables) in which -conversion is based
upon name swapping as in nominal abstract syntax. The principles allow to work modulo -conversion
and implement the Barendregt variable convention. We derive them from the simple structural induction
principle on concrete terms and work out applications to some fundamental meta-theoretical results, such
as the substitution lemma for -conversion and the lemma on substitution composition. The whole work is
implemented in Agda.

Plotkin, in his seminal article Call-by-name, call-by-value and the -calculus, formalized evaluation strategies and simulations using op- erational semantics and continuations. In particular, he showed how call-by-name evaluation could be simulated under call-by-value eval- uation and vice versa. Since Algol 60, however, call-by-name is both implemented and simulated with thunks rather than with continua- tions. We recast this folk theorem in Plotkin's setting, and show that thunks, even though they are simpler than continuations, are sucient for establishing all the correctness properties of Plotkin's call-by-name simulation. Furthermore, we establish a new relationship between Plotkin's two continuation-based simulationsCn andCv ,b yderiving Cn as the com- position of our thunk-based simulationT and ofC+ v | an extension of

We formalize two proofs of weak head normalization for the simply typed lambdacalculus in first-order minimal logic: one for normal-order reduction, and one for applicative-order reduction in the object language. Subsequently we use Kreisel's modified realizability to extract evaluation algorithms from the proofs, following Berger; the proofs are based on Tait-style reducibility predicates, and hence the extracted algorithms are instances of (weak head) normalization by evaluation, as already identified by Coquand and Dybjer.

We prove the correctness of an algorithm for normalizing untyped combinator terms by evaluation. The algorithm is written in the functional programming language Haskell, and we prove that it lazily computes the combinatory Böhm tree of the term. The notion of combinatory Böhm tree is analogous to the usual notion of Böhm tree for the untyped lambda calculus. It is defined operationally by repeated head reduction of terms to head normal forms. We use formal neighbourhoods to characterize finite, partial information about data, and define a Böhm tree as a filter of such formal neighbourhoods. We also define formal topology style denotational semantics of a fragment of Haskell following Martin-Löf, and let each closed program denote a filter of formal neighbourhoods. We prove that the denotation of the output of our algorithm is the Böhm tree of the input term. The key construction in the proof is a "glueing" relation between terms and semantic neighbourhoods which is defined by induction on the latter. This relation is related to the glueing relation which was earlier used for proving the correctness of a normalization by evaluation algorithm for typed combinatory logic.

Robin Milner coined the slogan well typed programs cannot go wrong, advertising the power of types in functional languages like ML and Haskell to catch runtime errors. Nowadays, we can and should go further: dependently typed programming exploits the power of very expressive type systems to deliver stronger guarantees but also additional support for software development, using types to guide the development process. This is witnessed by a recent surge of language proposals with the goal to harness the power of dependent types, e.g. Haskell with GADTs [84,, Agda [90], Coq [18], Ωmega [88], Concoqtion [83], Guru [89], Ynot [77], Epigram [68]

Summary Robin Milner coined the slogan well typed programs cannot go wrong, advertising the power of types in functional languages like ML and Haskell to catch runtime errors. Nowadays, we can and should go further: dependently typed programming exploits the power of very expressive type systems to deliver stronger guarantees but also additional support for software development, using types to guide the development process. This is witnessed by a recent surge of language proposals with the goal to harness the power of ...

Summary Robin Milner coined the slogan well typed programs cannot go wrong, advertising the power of types in functional languages like ML and Haskell to catch runtime errors. Nowadays, we can and should go further: dependently typed programming exploits the power of very expressive type systems to deliver stronger guarantees but also additional support for software development, using types to guide the development process.

We construct a logical framework supporting datatypes that mix binding and computation, implemented as a universe in the dependently typed programming language Agda 2. We represent binding pronominally, using well-scoped de Bruijn indices, so that types can be used to reason about the scoping of variables. We equip our universe with datatype-generic implementations of weakening, substitution, exchange, contraction, and subordination-based strengthening, so that programmers need not reimplement these operations for each individual language they define. In our mixed, pronominal setting, weakening and substitution hold only under some conditions on types, but we show that these conditions can be discharged automatically in many cases. Finally, we program a variety of standard difficult test cases from the literature, such as normalization-by-evaluation for the untyped λ-calculus, demonstrating that we can express detailed invariants about variable usage in a program's type while still writing clean and clear code.