The main concern of this paper is the design of a noetherian and confluent normalization for LK 2 (that is, classical second order predicate logic presented as a sequent calculus). The method we present is powerful: since it allows us to recover as fragments formalisms as seemingly different as Girard's LC and Parigot's , FD ([9, 11, 27, 31]), delineates other viable systems as well, and gives means to extend the Krivine/Leivant paradigm of `programming-with-proofs' ([22, 23]) to classical logic; it is painless: since we reduce strong normalization and confluence to the same properties for linear logic (for non-additive proof nets, to be precise) using appropriate embeddings (so-called decorations); it is unifying: it organizes known solutions in a simple pattern that makes apparent the how and why of their making. A comparison of our method to that of embedding LK into LJ (intuitionistic sequent calculus) brings to the fore the latter's defects for these `deconstructi...

We study (extensions of) simply and polymorphically typed lambda calculus from a point of view of how iterative and recursive functions on inductive types are represented. The inductive types can usually be understood as initial algebras in a certain category and then recursion can be defined in terms of iteration. However, in the syntax we often have only weak initiality, which makes the definition of recursion in terms of iteration inefficient or just impossible. We propose a categorical notion of (primitive) recursion which can easily be added as computation rule to a typed lambda calculus and gives us a clear view on what the dual of recursion, corecursion, on coinductive types is. (The same notion has, independently, been proposed by [Mendler 1991].) We look at how these syntactic notions work out in the simply typed lambda calculus and the polymorphic lambda calculus. It will turn out that in the syntax, recursion can be defined in terms of corecursion and vice versa using polymo...

We consider a class of logical formalisms, in which first-order logic is extended by identifying propositions modulo a given congruence. We particularly focus on the case where this congruence is induced by a confluent and terminating rewrite system over the propositions. This extension enhances the power of first-order logic and various formalisms, including higher-order logic, can be described in this framework. We conjecture that proof normalization and logical consistency always hold over this class of formalisms, provided some minimal conditions over the rewrite system are fulfilled. We prove this conjecture for some subcases, including higher-order logic. At last, we extend these results to classical sequent calculus.

The notion of storage operator introduced in [5, 6] appears to be an important tool in the study of data types in second order #-calculus. These operators are #-terms which simulate call-by-value in the call-by-name strategy, and they can be used in order to modelize assignment instructions. The main result about storage operators is that there is a very simple second order type for them, using Godel's "not-not translation" of classical into intuitionistic logic. We give here a new and simpler proof of a strengthened version of this theorem, which contains all previous results in intuitionistic and in classical logic ([6, 7]), and gives rise to new "storage theorems". Moreover, this result has a simple and intuitive meaning, in terms of realizability.

m networks and the recent works of Thierry Coquand in type theory have been the most important sources of motivation for the ideas presented here. I wish to specially thank Roberto Amadio, who read the manuscript in a very short delay, providing many helpful comments and remarks. Many thanks also to Luc Boug'e, who accepted to be my oficial supervisor, and to the chair of the jury, Michel Cosnard, who opened to me the doors of the LIP. During these last three years in Lyon I met many wonderful people, who then become wonderful friends. Miguel, Nuria, Veronique, Patricia, Philippe, Pia, Rodrigo, Salvador, Sophie : : : with you I have shared the happiness and sadness of everyday life, those little things which make us to remember someone forever. I also would like to thank the people from "Tango de Soie", for all those funny nights at the Caf'e Moulin Joly. Thanks too to the Uruguayan research community in Computer Science (specially to Cristina Cornes and Alberto Pardo) w

In proof checkers and theorem provers (e.g. Coq [4] and ProPre [13]) recursive de nitions of functions are shown to terminate automatically.

The Calculus of Constructions (CC) ([Coquand 1985]) is a typed lambda calculus for higher order intuitionistic logic: proofs of the higher order logic are interpreted as lambda terms and formulas as types. It is also the union of Girard's system F! ([Girard 1972]), a higher order typed lambda calculus, and a first order dependent typed lambda calculus in the style of de Bruijn's Automath ([de Bruijn 1980]) or Martin-Lof's intuitionistic theory of types ([Martin-Lof 1984]). Using the impredicative coding of data types in F! , the Calculus of Constructions thus becomes a higher order language for the typing of functional programs. We shall introduce and try to explain CC by exploiting especially the first point of view, by introducing a typed lambda calculus that faithfully represent higher order predicate logic (so for this system the Curry-Howard `formulas-as-types isomorphism' is really an isomorphism.) Then we discuss some propositions that are provable in CC but not in the higher or...

Abstract. The second-order polymorphic lambda calculus, F2, was independently discovered by Girard and Reynolds. Girard additionally proved a representation theorem: every function on natural numbers that can be proved total in second-order intuitionistic propositional logic, P2, can be represented in F2. Reynolds additionally proved an abstraction theorem: for a suitable notion of logical relation, every term in F2 takes related arguments into related results. We observe that the essence of Girard’s result is a projection from P2 into F2, and that the essence of Reynolds’s result is an embedding of F2 into P2, and that the Reynolds embedding followed by the Girard projection is the identity. The Girard projection discards all first-order quantifiers, so it seems unreasonable to expect that the Girard projection followed by the Reynolds embedding should also be the identity. However, we show that in the presence of Reynolds’s parametricity property that this is indeed the case, for propositions corresponding to inductive definitions of naturals, products, sums, and fixpoint types. 1

. The Coq and ProPre systems show the automated termination of a recursive function by first constructing a tree associated with the specification of the function which satisfies a notion of terminal property and then verifying that this construction process is formally correct. However, those two steps strongly depend on inductive principles and hence Coq and ProPre can only deal with the termination proofs that are inductive. There are however many functions for which the termination proofs are non-inductive. In this article, we attempt to extend the class of functions whose proofs can be done automatically `a la Coq and ProPre to a larger class including functions whose termination proofs are not inductive. We do this by extending the terminal property notion and replacing the verification step above by one that searches for a decreasing measure which can be used to establish the termination of the function. 1 Introduction Termination is an important property in the verification ...

We investigate an automated program synthesis system based on the paradigm of programming by proofs. To automatically extract a -term that computes a recursive function given by a set of equations the system must nd a formal proof of the totality of the given function. Because of the particular logical framework, usually such approaches make it dicult to use techniques such as those in rewriting theory. We overcome this diculty for the automated system that we consider by exploiting product types. As a consequence, this would enable the incorporation of termination techniques used in other areas while still extracting programs.