this paper deals exclusively with intuitionistic logic (in fact, only the implicative fragment), we require succedents to be a single consequent formula. Natural deduction systems, which we choose to call N-systems, are symbolic logics generally given via introduction and elimination rules for the logical connectives which operate on the right, i.e., they manipulate the succedent formula. Examples are Gentzen's NJ and NK (Gentzen 1935). Logical deduction systems are given via left-introduction and right-introduction rules for the logical connectives. Although others have called these systems "sequent calculi", we call them L-systems to avoid confusion with other systems given in sequent style. Examples are Gentzen's LK and LJ (Gentzen 1935). In this paper we are primarily interested in L-systems. The advantage of N-systems is that they seem closer to actual reasoning, while L-systems on the other hand seem to have an easier proof theory. L-systems are often extended with a "cut" rule as part of showing that for a given L-system and N-system, the derivations of each system can be encoded in the other. For example, NK proves the same as LK + cut (Gentzen 1935). Proof Normalization. A system is consistent when it is impossible to prove false, i.e., derive absurdity from zero assumptions. A system is analytic (has the analycity property) when there is an e#ective method to decompose any conclusion sequent into simpler premise sequents from which the conclusion can be obtained by some rule in the system such that the conclusion is derivable i# the premises are derivable (Maenpaa 1993). To achieve the goals of consistency and analycity, it has been customary to consider

: We introduce a unified framework to describe, relate, compare and classify functional language implementations. The compilation process is expressed as a succession of program transformations in the common framework. At each step, different transformations model fundamental choices. A benefit of this approach is to structure and decompose the implementation process. The correctness proofs can be tackled independently for each step and amount to proving program transformations in the functional world. This approach also paves the way to formal comparisons by making it possible to estimate the complexity of individual transformations or compositions of them. Our study aims at covering the whole known design space of sequential functional languages implementations. In particular, we consider call-by-value, call-by-name and call-by-need reduction strategies as well as environment and graph-based implementations. We describe for each compilation step the diverse alternatives as program tr...

Machine translation ## -calculus interpretation ## -calculus Formally, the -calculus contains two classes of objects: terms and substitutions. Terms are written in the de Bruijn notation.

. We present a game model for classical PCF, a finite version of PCF extended by a catch/throw mechanism. This model is build from E-dialogues, a kind of two-players game defined by Lorenzen. In the E-dialogues for classical PCF, the strategies of the first player are isomorphic to the Bohm trees of the language. We define an interaction in E-dialogues and show that it models the weak-head reduction in classical PCF. The interaction is a variant of Coquand's debate and the weak-head reduction is a variant of the reduction in Krivine's Abstract Machine. We then extend E-dialogues to a kind of games similar to Hyland-Ong's games. Interaction in these games also models weak-head reduction. In the intuitionistic case (i.e. without the catch/throw mechanism), the extended E-dialogues are Hyland-Ong's games where the innocence condition on strategies is now a rule. Our model for classical PCF is different from Ong's model of Parigot's lambda-mu-calculus. His model works by adding new moves t...

a mis hermanas, Patricia y Paula, y a mi sobrino y ahijado, Nicol'as. Acknowledgements First of all, I would like to express my gratitude to my supervisor, Eike Ritter, for his wisdom, insight, uncountably many discussions, and invaluable friendship. I am indebted to my tutor, Valeria de Paiva, who also believed in me from the very beginning, encouraged me to work in this area, showed me the beauty of logic, and, above all, honoured me with her friendship. This thesis would not exist if it were not for their constant support. Thanks to my old friends, Cecilia C. Crespo, Santiago M. Peric'as, and, especially, Mat'ias Giovannini, for being always a wonderful critic of my work. Many thanks to Mathias Kegelmann for showing me the thrill of theorem proving; and to my former supervisor, Achim Jung, for introducing me to semantics.

Abstract: The Krivine machine is a simple and natural implementation of the normal weak-head reduction strategy for pure λ-terms. While its original description has remained unpublished, this machine has served as a basis for many variants, extensions and theoretical studies. In this paper, we present the Krivine machine and some well-known variants in a common framework. Our framework consists of a hierarchy of intermediate languages that are subsets of the λ-calculus. The whole implementation process (compiler + abstract machine) is described via a sequence of transformations all of which express an implementation choice. We characterize the essence of the Krivine machine and locate it in the design space of functional language implementations. We show that, even within the particular class of Krivine machines, hundreds of variants can be designed. Key-words: Krivine machine, abstract machines, program transformation, compilation, functional language implementations.

We present a simple term calculus with an explicit control of erasure and duplication of substitutions, enjoying a sound and complete correspondence with the intuitionistic fragment of Linear Logic’s proof-nets. We show the operational behaviour of the calculus and some of its fundamental properties such as confluence, preservation of strong normalisation, strong normalisation of simply-typed terms, step by step simulation of β-reduction and full composition.

. We propose abstract machines for lazy functional programming languages, based on the Krivine machine, and initially designed for eliding the creation of useless closures. We introduce the notion of super-closure, a data structure representing a list of closures in a compact way. We give four machines: the rst three of them implement call by name. They illustrate a basic issue not directly related to sharing, namely splitting, and two possible solutions to this problem. Then, we give the proofs of correctness of these machines, using a weak -calculus with explicit substitution. Finally, we propose a machine implementing call by need and claim that it is correct w.r.t. the call-by-need strategy of environment machines. However, we also show that against our naive expections, our system has many weaknesses with respect to space consumption as well as execution speed. Keywords. Abstract machines, functional programming, optimization, shared environments, explicit substitution...

Abstract. We expose a formalism that allows the expression of any theory with one or more axiom schemes using a finite number of axioms. This allows us to give finite first-order axiomatizations of arithmetic and real analysis, and a presentation of arithmetic in deduction modulo that has a finite number of rewrite rules. Overall, this formalization relies on a weak calculus of explicit substitutions to provide a simple and finite framework. 1

Calculi with explicit substitutions (ES) are widely used in different areas of computer science. Complex systems with ES were developed these last 15 years to capture the good computational behaviour of the original systems (with meta-level substitutions) they were implementing. In this paper we first survey previous work in the domain by pointing out the motivations and challenges that guided the development of such calculi. Then we use very simple technology to establish a general theory of explicit substitutions for the lambda-calculus which enjoys fundamental properties such as simulation of one-step beta-reduction, confluence on metaterms, preservation of beta-strong normalisation, strong normalisation of typed terms and full composition. The calculus also admits a natural translation into Linear Logic’s proof-nets.