Results 1  10
of
32
Program extraction from normalization proofs
 Typed Lambda Calculi and Applications, number 664 in Lecture Notes in Computer Science
, 1993
"... 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 machineextracted that implement variants of the wellknown normalizationbyevaluation algorithm. The case stud ..."
Abstract

Cited by 60 (5 self)
 Add to MetaCart
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 machineextracted that implement variants of the wellknown normalizationbyevaluation algorithm. The case study is used to test and compare the program extraction machineries of the three proof assistants in a nontrivial setting. 1
Strong Normalisation in the πCalculus
, 2001
"... We introduce a typed πcalculus where strong normalisation is ensured by typability. Strong normalisation is a useful property in many computational contexts, including distributed systems. In spite of its simplicity, our type discipline captures a wide class of converging namepassing interactive b ..."
Abstract

Cited by 30 (15 self)
 Add to MetaCart
We introduce a typed πcalculus where strong normalisation is ensured by typability. Strong normalisation is a useful property in many computational contexts, including distributed systems. In spite of its simplicity, our type discipline captures a wide class of converging namepassing interactive behaviour. The proof of strong normalisability combines methods from typed lcalculi and linear logic with processtheoretic reasoning. It is adaptable to systems involving state and other extensions. Strong normalisation is shown to have significant consequences, including finite axiomatisation of weak bisimilarity, a fully abstract embedding of the simplytyped lcalculus with products and sums and basic liveness in interaction.
Normalization and partial evaluation
 Applied Semantics, number 2395 in LNCS
, 2002
"... Abstract. We give an introduction to normalization by evaluation and typedirected partial evaluation. We first present normalization by evaluation for a combinatory version of Gödel System T. Then we show normalization by evaluation for typed lambda calculus with β and η conversion. Finally, we int ..."
Abstract

Cited by 17 (0 self)
 Add to MetaCart
Abstract. We give an introduction to normalization by evaluation and typedirected partial evaluation. We first present normalization by evaluation for a combinatory version of Gödel System T. Then we show normalization by evaluation for typed lambda calculus with β and η conversion. Finally, we introduce the notion of binding time, and explain the method of typedirected partial evaluation for a small PCFstyle functional programming language. We give algorithms for both callbyname and callbyvalue versions of this language.
Memoization in typedirected partial evaluation
 PROCEEDINGS OF THE 2002 ACM SIGPLAN/SIGSOFT CONFERENCE ON GENERATIVE PROGRAMMING AND COMPONENT ENGINEERING, NUMBER 2487 IN LECTURE NOTES IN COMPUTER SCIENCE
, 2002
"... We use a code generator—typedirected 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 function ..."
Abstract

Cited by 14 (6 self)
 Add to MetaCart
We use a code generator—typedirected 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 typedirected partial evaluation provides a convenient setting to obtain the normal form of their composition. However, offtheshelf typedirected 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 typedirected 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 ordersofmagnitude improvements both in time and in space for type isomorphisms.
Normalization by evaluation for λ →2
 In Functional and Logic Programming, number 2998 in LNCS
, 2004
"... Abstract. We show that the settheoretic 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 ..."
Abstract

Cited by 9 (4 self)
 Add to MetaCart
Abstract. We show that the settheoretic 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
A modular typechecking algorithm for type theory with singleton types and proof irrelevance
 IN TLCA’09, VOLUME 5608 OF LNCS
, 2009
"... ..."
Tait in one big step
 In MSFP 2006
, 2006
"... We present a Taitstyle 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 smallstep operational semantics on the one side and normalisation by evaluation on t ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
We present a Taitstyle 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 smallstep 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.
Extensional rewriting with sums
 In TLCA
, 2007
"... Abstract. Inspired by recent work on normalisation by evaluation for sums, we propose a normalising and confluent extensional rewriting theory for the simplytyped λcalculus extended with sum types. As a corollary of confluence we obtain decidability for the extensional equational theory of simply ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
Abstract. Inspired by recent work on normalisation by evaluation for sums, we propose a normalising and confluent extensional rewriting theory for the simplytyped λcalculus extended with sum types. As a corollary of confluence we obtain decidability for the extensional equational theory of simplytyped λcalculus extended with sum types. Unlike previous decidability results, which rely on advanced rewriting techniques or advanced category theory, we only use standard techniques. 1
Typed Applicative Structures and Normalization by Evaluation for System F ω
"... Abstract. We present a normalizationbyevaluation (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 alg ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Abstract. We present a normalizationbyevaluation (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.