Strong Normalization Result Research Articles

Characterisation of Normalisation Properties for λμ using Strict Negated Intersection Types

We show characterisation results for normalisation, head-normalisation, and strong normalisation for λ μ using intersection types. We reach these results for a strict notion of type assignment for λ μ that is the natural restriction of the domain-based system of van Bakel et al. (2011) for λ μ by limiting the type inclusion relation to just intersection elimination. We show that this system respects β μ-equality, by showing both soundness and completeness results. We then define a notion of reduction on derivations that corresponds to cut-elimination, and show that this is strongly normalisable. We use this strong normalisation result to show an approximation result, and through that a characterisation of head-normalisation. Using the approximation result, we show that there is a very strong relation between the system of van Bakel et al. (2011) and ours. We then introduce a notion of type assignment that eliminates ω as an assignable type, and show, using the strong normalisation result for derivation reduction, that all terms typeable in this system are strongly normalisable as well, and show that all strongly normalisable terms are typeable. We conclude by adding type variables to our system, and show that system essentially is that of van Bakel (2010b).

Lolliproc

While many type systems based on the intuitionistic fragment of linear logic have been proposed, applications in programming languages of the full power of linear logic - including double-negation elimination - have remained elusive. Meanwhile, linearity has been used in many type systems for concurrent programs - e.g., session types - which suggests applicability to the problems of concurrent programming, but the ways in which linearity has interacted with concurrency primitives in lambda calculi have remained somewhat ad-hoc. In this paper we connect classical linear logic and concurrent functional programming in the language Lolliproc, which provides simple primitives for concurrency that have a direct logical interpretation and that combine to provide the functionality of session types. Lolliproc features a simple process calculus "under the hood" but hides the machinery of processes from programmers. We illustrate Lolliproc by example and prove soundness, strong normalization, and confluence results, which, among other things, guarantees freedom from deadlocks and race conditions.

Strong normalization results by translation

We prove the strong normalization of full classical natural deduction (i.e. with conjunction, disjunction and permutative conversions) by using a translation into the simply typed λ μ -calculus. We also extend Mendler’s result on recursive equations to this system.

On strong normalization and type inference in the intersection type discipline

We introduce a new unification procedure for the type inference problem in the intersection type discipline. It is well known that type inference in this case should succeed exactly for the strongly normalizing expressions. We give a proof for the strong normalization result in the intersection type discipline, which we obtain by putting together some well-known results and proof techniques. Our proof uses a variant of Klop’s extended λ -calculus, for which it is shown that strong normalization is equivalent to weak normalization. This is proved here by means of a finiteness of developments theorem, obtained following de Vrijer’s combinatory technique. The main property of this extended calculus is uniformity, i.e. weak and strong normalizabilities coincide. The strong normalizability result is therefore a consequence of the fact, first established by Coppo and Dezani (for the λ -calculus) that typability implies weak normalizability. We then show that the unification process which is the basis for type inference exactly corresponds to reduction in the extended λ -calculus. Finally we show that our notion of unification allows us to compute a principal typing for any typable λ -expression.

The heart of intersection type assignment: Normalisation proofs revisited

This paper gives a new proof for the approximation theorem and the characterisation of normalisability using intersection types for a system with ‘ w and a ≤ -relation that is contra-variant over arrow types. The technique applied is to define reduction on derivations and to show a strong normalisation result for this reduction. From this result, the characterisation of strong normalisation and the approximation result will follow easily; the latter, in its turn, will lead to the characterisation of (head) normalisability.

Arithmetical Proofs of Strong Normalization Results for Symmetric -calculi

We give arithmetical proofs of the strong normalization of two symmetric -calculi corresponding to classical logic. The first one is the -calculus introduced by Curien & Herbelin. It is derived via...

Cut-Elimination in the Strict Intersection Type Assignment System is Strongly Normalizing

This paper defines reduction on derivations (cut-elimination) in the Strict Intersection Type Assignment System of an earlier paper and shows a strong normalization result for this reduction. Using this result, new proofs are given for the approximation theorem and the characterization of normalizability of terms using intersection types.

A New Machine-checked Proof of Strong Normalisation for Display Logic

We use a deep embedding of the display calculus for relation algebras δRA in the logical framework Isabelle/HOL to formalise a new, machine-checked, proof of strong normalisation and cut-elimination for δRA which does not use measures on the size of derivations. Our formalisation generalises easily to other display calculi and can serve as a basis for formalised proofs of strong normalisation for the classical and intuitionistic versions of a vast range of substructural logics like the Lambek calculus, linear logic, relevant logic, BCK-logic, and their modal extensions. We believe this is the first full formalisation of a strong normalisation result for a sequent system using a logical framework.

Strongly Normalising Cut-Elimination with Strict Intersection Types

This paper defines reduction on derivations in the strict intersection type assignment system of [2], by generalising cutelimination, and shows a strong normalisation result for this reduction. Using this result, new proofs are given for the approximation theorem and the characterisation of normalisability using intersection types.

Modularity of strong normalization in the algebraic-λ-cube

In this paper we present the algebraic-λ-cube, an extension of Barendregt's λ-cube with first- and higher-order algebraic rewriting. We show that strong normalization is a modular property of all the systems in the algebraic-λ-cube, provided that the first-order rewrite rules are non-duplicating and the higher-order rules satisfy the general schema of Jouannaud and Okada. We also prove that local confluence is a modular property of all the systems in the algebraic-λ-cube, provided that the higher-order rules do not introduce critical pairs. This property and the strong normalization result imply the modularity of confluence.

Normal Forms and Conservative Extension Properties for Query Languages over Collection Types

Strong normalization results are obtained for a general language for collection types. An induced normal form for sets and bags is then used to show that the class of functions whose input has height (that is, the maximal depth of nestings of sets/bags/lists in the complex object) at mostiand output has height at mostodefinable in a nested relational query language withoutpowersetoperator isindependentof the height of intermediate expressions used. Our proof holds regardless of whether the language is used for querying sets, bags, or lists, even in the presence of variant types. Moreover, the normal forms are useful in a general approach to query optimization. Paredaens and Van Gucht (ACM Trans on Database Systems17, No.?1 (1992), 65–93), proved a similar result for the special case wheni=o=1. Their result is complemented by Hull and Su (J. Comput. Systems Sci.43(1991), 219–261) who demonstrated the failure of independence when powerset operator is present andi=o=1. The theorem of Hull and Su was generalized to alliandoby Grumbach and Vianu (in“Proceedings of the 3rd International Conference on Database Theory,” Lecture Notes in Computer Science, Vol.?470, Springer-Verlag, Berlin, 1990). Our result generalizes Paredaens and Van Gucht's to alliando, providing a counterpart to the theorem of Grumbach and Vianu.

A strong normalization result for classical logic

In this paper we give a strong normalization proof for a set of reduction rules for classical logic. These reductions, more general than the ones usually considered in literature, are inspired to the reductions of Felleisen's lambda calculus with continuations.

Strong normalisation for the linear term calculus

AbstractWe prove a strong normalisation result for the linear term calculus of Benton, Bierman, Hyland and de Paiva. Rather than prove the result from first principles, we give a translation of linear terms into terms in the second-order polymorphic lambda calculus (λ2) which allows the result to be proved by appealing to the well-known strong normalisation property of λ2. An interesting feature of the translation is that it makes use of the λ2 coding of a coinductive datatype as the translation of the !-types (exponentials) of the linear calculus.

Combinatory reduction systems: introduction and survey

Combinatory reduction systems, or CRSs for short, were designed to combine the usual first-order format of term rewriting with the presence of bound variables as in pure λ-calculus and various typed λ-calculi. Bound variables are also present in many other rewrite systems, such as systems with simplification rules for proof normalization. The original idea of CRSs is due to Aczel, who introduced a restricted class of CRSs and, under the assumption of orthogonality, proved confluence. Orthogonality means that the rules are nonambiguous (no overlap leading to a critical pair) and left-linear (no global comparison of terms necessary). We introduce the class of orthogonal CRSs, illustrated with many examples, discuss its expressive power and give an outline of a short proof of confluence. This proof is a direct generalization of Aczel's original proof, which is close to the well-known confluence proof for λ-calculus by Tait and Martin-Löf. There is a well-known connection between the parallel reduction featuring in the latter proof and the concept of “developments”, and a classical lemma in the theory of λ-calculus is that of “finite developments”, a strong normalization result. It turns out that the notion of “parallel reduction” used in Aczel's proof gives rise to a generalized form of developments which we call “superdevelopments” and on which we will briefly comment.

COMBINING TERM REWRITING AND TYPE ASSIGNMENT SYSTEMS

Recently some attention has been paid to the properties enjoyed by combinations of term rewriting and λ-calculus based systems. In this paper strong normalization and confluence are proved for λ-terms obtained by merging pure λ-terms and first order canonical term rewriting systems, in the framework of a system which extends the Coppo-Dezani intersection type assignment system. On terms of the resulting calculus we can perform ordinary β and η reductions, as well as the reductions induced in a natural way by the term rewriting systems. In some parts of our analysis we follow rather closely the development contained in a recent paper by Val Breazu-Tannen and Jean Gallier. There, the same properties of strong normalization and confluence are proved for systems obtained by combining the second order polymorphic λ-calculus with first order canonical term rewriting systems. The strong normalization result of Breazu-Tannen and Gallier is proved to be implied by the corresponding property of our system.

On the implementation of abstract data types by programming language constructs

Implementations of abstract data types are defined via enrichments of a target type. We propose to use an extended typed λ-calculus for enrichments in order to meet the conceptual requirement that an implementation has to bring us closer to a (functional) program. Composability of implementations is investigated, the main result being that composition of correct implementations is correct if terminating programs are implemented by terminating programs. Moreover, we provide syntactical criteria to guarantee correctness of composition. The proof is based on strong normalization and Church-Rosser results of the extended λ-calculus which seem to be of interest in their own right.