Results 1 
4 of
4
Complexity of strongly normalising λterms via nonidempotent intersection types
"... We present a typing system for the λcalculus, with nonidempotent intersection types. As it is the case in (some) systems with idempotent intersections, a λterm is typable if and only if it is strongly normalising. Nonidempotency brings some further information into typing trees, such as a bound o ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We present a typing system for the λcalculus, with nonidempotent intersection types. As it is the case in (some) systems with idempotent intersections, a λterm is typable if and only if it is strongly normalising. Nonidempotency brings some further information into typing trees, such as a bound on the longest βreduction sequence reducing a term to its normal form. We actually present these results in Klop’s extension of λcalculus, where the bound that is read in the typing tree of a term is refined into an exact measure of the longest reduction sequence. This complexity result is, for longest reduction sequences, the counterpart of de Carvalho’s result for linear headreduction sequences.
Strong Normalisation of CutElimination that Simulates βReduction
"... This paper is concerned with strong normalisation of cutelimination for a standard intuitionistic sequent calculus. The cutelimination procedure is based on a rewrite system for proofterms with cutpermutation rules allowing the simulation of βreduction. Strong normalisation of the typed terms i ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
This paper is concerned with strong normalisation of cutelimination for a standard intuitionistic sequent calculus. The cutelimination procedure is based on a rewrite system for proofterms with cutpermutation rules allowing the simulation of βreduction. Strong normalisation of the typed terms is inferred from that of the simplytyped λcalculus, using the notions of safe and minimal reductions as well as a simulation in NederpeltKlop’s λIcalculus. It is also shown that the typefree terms enjoy the preservation of strong normalisation (PSN) property with respect to βreduction in an isomorphic image of the typefree λcalculus.
Proving Strong Normalisation via Nondeterministic Translations into Klop’s Extended λCalculus
"... In this paper we present strong normalisation proofs using a technique of nondeterministic translations into Klop’s extended λcalculus. We first illustrate the technique by showing strong normalisation of a typed calculus that corresponds to natural deduction with general elimination rules. Then w ..."
Abstract
 Add to MetaCart
In this paper we present strong normalisation proofs using a technique of nondeterministic translations into Klop’s extended λcalculus. We first illustrate the technique by showing strong normalisation of a typed calculus that corresponds to natural deduction with general elimination rules. Then we study its explicit substitution version, the typefree calculus of which does not satisfy PSN with respect to reduction of the original calculus; nevertheless it is shown that typed terms are strongly normalising with respect to reduction of the explicit substitution calculus. In the same framework we prove strong normalisation of Sørensen and Urzyczyn’s cutelimination system in intuitionistic sequent calculus.
Intersection types and Resource control in λcalculus
"... The λcalculus is a programming model based on functions. Its Turingcompleteness comes from the freedom given to function constructions and function applications, but the λcalculus thereby lacks some notions of control that are useful and natural both in programming and in mathematics. Typing syst ..."
Abstract
 Add to MetaCart
The λcalculus is a programming model based on functions. Its Turingcompleteness comes from the freedom given to function constructions and function applications, but the λcalculus thereby lacks some notions of control that are useful and natural both in programming and in mathematics. Typing systems provide such control, for instance by allowing the application of a fonction f, of “type ” A → B, to an argument e only if the latter is indeed of “type ” A. Basic typing systems will thus forbid a function to be applied to itself f(f), but they can be extended using intersection types: if f is of type (A → B)∩A (i.e. both of type A → B and of type A), then the above application makes sense. On the other hand, we introduced in [KL07] a version of λcalculus with an explicit control of resources. An explicit component of this control is the duplication operator, which specifies the point in a program (and in its running) where some data (or more generally a term) needs to be duplicated. From this phenomenon come complexity issues, both in time and in space, and nontermination.