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. 1

Abstract. We use a code generator—type-directed partial evaluation— to verify conversions between isomorphic types, or more precisely to verify that a composite function is the identity function at some complicated type. A typed functional language such as ML provides a natural support to express the functions and type-directed partial evaluation provides a convenient setting to obtain the normal form of their composition. However, off-the-shelf type-directed partial evaluation turns out to yield gigantic normal forms. We identify that this gigantism is due to redundancies, and that these redundancies originate in the handling of sums, which uses delimited continuations. We successfully eliminate these redundancies by extending type-directed partial evaluation with memoization capabilities. The result only works for pure functional programs, but it provides an unexpected use of code generation and it yields orders-of-magnitude improvements both in time and in space for type isomorphisms. 1

A purely syntactic and untyped variant of Normalization by Evaluation for the λ-calculus...

Abstract. We show that the set-theoretic semantics for λ →2 is complete by inverting evaluation using decision trees. This leads to an implementation of normalization by evaluation which is witnessed by the source of part of this paper being a literate Haskell script. We show the correctness of our implementation using logical relations. 1

We present a Tait-style proof to show that a simple functional normaliser for a combinatory version of System T terminates. The main interest in our construction is methodological, it is an alternative to the usual small-step operational semantics on the one side and normalisation by evaluation on the other. Our work is motivated by our goal to verify implementations of Type Theory such as Epigram. Keywords: Normalisation,Strong Computability 1.

We present a semantical proof of existence of normal forms for system F including j-equality. A reduction-free normalisation function can be obtained from this. The proof uses the method of glueing (a variant of) the term model along the global sections functor, carried out in the internal language of a category of presheaves. As a by-product we obtain an semantical explanation of higherorder abstract syntax. The paper extends a previous one (Altenkirch, Hofmann, and Streicher 1996) in which a combinatory version of system F has been treated. 1 Introduction In this paper we give a semantical proof of reduction-free normalisation for F fij , a version of Girard's system F with full fij-equality for both kinds of abstraction. This generalises the semantical normalisation algorithms for simply-typed systems (Berger and Schwichtenberg 1991; Coquand and Dybjer 1996; Altenkirch, Hofmann, and Streicher 1995) to polymorphism. As in those approaches we do not prove strong normalisation but co...

Abstract. A general version of the fundamental theorem for System F is presented which can be instantiated to obtain proofs of weak β- and βη-normalization and normalization by evaluation. 1 Introduction and Related Work Dependently typed lambda-calculi have been successfully used as proof languages in proof assistants like Agda [Nor07], Coq [INR07], LEGO [Pol94], and NuPrl [Ct86]. Since types may depend on values in these type theories, checking equality of types, which is crucial for type and, thus, proof checking, is non-trivial for these

Abstract. We present a normalization-by-evaluation (NbE) algorithm for System F ω with βη-equality, the simplest impredicative type theory with computation on the type level. Values are kept abstract and requirements on values are kept to a minimum, allowing many different implementations of the algorithm. The algorithm is verified through a general model construction using typed applicative structures, called type and object structures. Both soundness and completeness of NbE are conceived as an instance of a single fundamental theorem.

We implement type-directed partial evaluation in the pure functional programming language Haskell, using type classes. 1

We develop the type theory of the Normalisation by Evaluation (NbE) algorithm for the λ-calculus in the simply-typed case. In particular, we show that the algorithm computes long β(η)-normal forms by means of Plotkin’s call-by-name and callby-value β-evaluation semantics. This is noteworthy (i) as the algorithm decides full βη-equality and (ii) as the algorithm so-far only has been presented in modeltheoretic terms. To showcase the effective means of the algorithm, we provide an environment machine implementation of the semantics: the NbE Machine. We also analyse the semantics and the environment machine in terms of strategies on the λ-calculus and subsequently address the untyped case. The proof burden is slight. 1