Michel Parigot

Proofs of Strong Normalisation for Second Order Classical Natural Deduction

We give two proofs of strong normalisation for second order classical natural deduction . The first one is an adaptation of the method of reducibility candidates introduced in [9] for second order intuitionistic natural deduction; the extension to the classical case requires in particular a simplification of the notion of reducibility candidate. The second one is a reduction to the intuitionistic case, using a Kolmogorov translation.

Strong normalization for second order classical natural deduction

The strong normalization theorem for second-order classical natural deduction is proved. The method used is an adaptation of the one of reducibility candidates introduced in a thesis by J.Y. Girard (Univ. Paris 7, 1972) for second-order intuitionistic natural deduction. The extension to the classical case requires, in particular, a simplification of the notion of reducibility candidates.<<ETX>>

Classical Proofs as Programs

We present an extension of the correspondence between intuitionistic proofs and functional programs to classical proofs, and more precisely to second order classical proofs. The advantage of classical logic in this context is that it allows to model imperative features of programming languages too (cf [5]). But there is an intrinsic difficulty with classical logic which lies in certain non-determinism of its computational interpretations. The use of a natural deduction system removes a part of this non determinism by fixing the inputs to the left of the sequents (cf [10] and [11]). However a conflict remains between the confluence of the computation mechanism and the uniqueness of the representation of data (for instance the uniqueness of the representation of the natural number 1). In this paper we develop the solution to this problem proposed in [11]: we show how to extract the intuitionistic representation of a data from a classical one using an “output” operator, while keeping a confluent computation mechanism. This result allows to extend in a sound way the proofs-as-programs paradigm to classical proofs in a framework where all the usual theoretical properties of intuitionistic proofs still hold.

Recursive programming with proofs

There has been a lot of work based on the paradigm “proofs as programs”, leading to sophisticated realizations (see e.g. [2,4, 133). An expected benefit is the development of correct programs, but, so far, no programming language in current use came from these works. The difficulty is the apparent distance between proofs and programs: the proofs are often complicated and the extracted programs have not always the expected behaviour (in terms of complexity, for instance). The proofs are not only programs, but also contain conceptual parts explaining why the result is what it is. One needs, therefore, to distinguish in the proofs the algorithmic content from the conceptual content. The distinction can be done at different levels: The logical operators. The propositional connectives have an algorithmic content, whereas the quantifiers can be considered as having only a conceptual role (the universal quantifier indicates a degree of generality). ~ The dejnition of the objects. The iterative and recursive definitions of the data types do not have the same algorithmic content (they correspond to different access to the data). The proofs themsehes. There are, for instance, different ways of doing proofs by induction; termination proofs often require computations which are not really necessary to compute the result. The choices made at each of these levels are crucial for the design of a programming language based on proofs. We explain in the remaining part of this introductory section the particular choices we have made to construct an experimental language called PROPRE (for PROgrammation avec des PREuves).

Programming with Proofs: A Second Order Type Theory

We discuss the possibility to construct a programming language in which we can program by proofs, in order to ensure program correctness. The logical framework we use is presented in [13].

Free Deduction: An Analysis of Computations in Classical Logic

Cut-elimination is a central tool in proof-theory, but also a way of computing with proofs used for constructing new functional languages. As such it depends on the properties of the deduction system in which proofs are written.

On the representation of data in lambda-calculus

We analyse the algorithmic properties of programs induced by the choice of the representation of data in lambda-calculus. From a logical point of view there are two canonical ways of defining the data types: the iterative one and the recursive one. Both define the same mathematical object, but we show that they have a completely different algorithmic content. The essential of the difference appears in the operational properties of two programs: the predecessor and the addition on the type of unary natural numbers (for the type of lists this would be the programs cdr and append). The results we prove in this paper state a fundamental duality between the iterative and recursive representation of data in lambda-calculus.

A logical approach of Petri net languages

Abstract For languages recognized by finite automata we dispose of two formalisms: regular expressions (Kleene, 1956) and logical formulas (Buchi, 1960). In the case of Petri net languages there is no formalism like regular expressions. In this paper we give a Buchi-like theorem which characterizes Petri net languages in terms of second-order logical formulas. This characterization has two advantages: (1) It situates exactly the power of Petri nets with respect to finite automata; roughly speaking, Petri nets are finite automata plus the ability of testing if a string of parenthesis is well formed (in this paper ‘parenthesis’ always means the usual one sort of parentheses). (2) Given a language, it enables us to easily prove that it is a Petri net language. In addition we prove that Petri net languages and deadlock languages coincide.

A Proof Calculus Which Reduces Syntactic Bureaucracy

In usual proof systems, like the sequent calculus, only a very limited way of combining proofs is available through the tree structure. We present in this paper a logic-independent proof calculus, where proofs can be freely composed by connectives, and prove its basic properties. The main advantage of this proof calculus is that it allows to avoid certain types of syntactic bureaucracy inherent to all usual proof systems, in particular the sequent calculus. Proofs in this system closely reflect their atomic flow, which traces the behaviour of atoms through structural rules. The general definition is illustrated by the standard deep-inference system for propositional logic, for which there are known rewriting techniques that achieve cut elimination based only on the information in atomic flows.

A quasipolynomial cut-elimination procedure in deep inference via atomic flows and threshold formulae

Jeřabek showed in 2008 that cuts in propositional-logic deepinference proofs can be eliminated in quasipolynomial time. The proof is an indirect one relying on a result of Atserias, Galesi and Pudlak about monotone sequent calculus and a correspondence between this system and cut-free deep-inference proofs. In this paper we give a direct proof of Jeřabeks result: we give a quasipolynomial-time cut-elimination procedure in propositional-logic deep inference. The main new ingredient is the use of a computational trace of deep-inference proofs called atomic flows, which are both very simple (they trace only structural rules and forget logical rules) and strong enough to faithfully represent the cutelimination procedure.