Lambda Calculus,Conservative Extension and Structural Induction

Lecture Notes in Computer Science, 1995

We propose a uniform, category-theoretic account of structural induction for inductively defined data types. The account is based on the understanding of inductively defined data types as initial• algebras for certain kind of endofunctors T: llll-.JB on a bicartesian/distributive category B. Regarding a predicate logic as a fibration p : !Pl-+llll over llll, we consider a logical predicate lifting of T to the total category lF. Then, a predicate is inductive precisely when it carries an algebra structure for such lifted endofunctor. The validity of the induction principle is formulated by requiring that the 'truth' predicate functor T: JBl-.JP' preserve initial algebras. We then show that when the fibration admits a comprehension principle, analogous to the one in set theory, it satisfies the induction principle. We also consider the appropriate extensions of the above formulation to deal with initiality (and induction) in arbitrary contexts, i.e. the 'stability' property of the induction principle.

Lecture Notes in Computer Science, 2003

We discuss the formalization of Abadi and Cardelli's impς, a paradigmatic object-based calculus with types and side effects, in Co-Inductive Type Theories, such as the Calculus of (Co)Inductive Constructions (CC (Co)Ind ). Instead of representing directly the original system "as it is", we reformulate its syntax and semantics bearing in mind the proof-theoretical features provided by the target metalanguage. On one hand, this methodology allows for a smoother implementation and treatment of the calculus in the metalanguage. On the other, it is possible to see the calculus from a new perspective, thus having the occasion to suggest original and cleaner presentations. We give hence a new presentation of impς, exploiting natural deduction semantics, (weak) higher-order abstract syntax, and, for a significant fragment of the calculus, coinductive typing systems. This presentation is easier to use and implement than the original one, and the proofs of key metaproperties, e.g. subject reduction, are much simpler. Although all proof developments have been carried out in the Coq system, the solutions we have devised in the encoding of and metareasoning on impς can be applied to other imperative calculi and proof environments with similar features.

[1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science

In the polymorphic-calculus, one may explicitly define functions that take a type as input and return a term as output. This work focuses on how such functions depend on their input types. Indeed, these functions are generally understood to have an essentially constant meaning on input types. We show how the proof theory of the polymorphic-calculus suggests a clear syntactic description of this phenomenon. Namely, under a reasonable condition, we show that if two polymorphic functions agree on an input type, then they are, in fact, the same function. Equivalently, types are generic inputs to polymorphic functions. Résumé Dans le-calcul polymorphe, on peut explicitement définir des fonctions qui prennent un type comme argument et qui renvoient un terme comme résultat. Le but de ce travail est de mieux comprendre la dépendance de ces fonctions vis-à-vis de leurs arguments types. En effet, ces fonctions sont généralement considérées commeétant essentiellement constantes par rapport aux arguments types. Nous montrons que la théorie syntaxique du-calcul polymorphe suggère une description claire de ce phénomène : sous une condition raisonnable, si deux fonctions polymorphes s'accordent sur un seul type, elles sont identiques. Autrement dit, les types sont des arguments génériques aux fonctions polymorphes.

The λ-calculus was first published in , with the aim of providing a foundation for logic which would be an alternative to Russell's type theory or Zermelo's set theory. The theory is based on the concept of functions rather than sets and it is about functions as rules 1 rather than as graphs 2 . Almost immediately after publication a contradiction was found in it. Church revised the theory a year later, the inconsistency of which was discovered by two students of Church, Stephen . Discouraged in his foundational project, Church gave a consistent subtheory, known as λI -calculus in ].

Lecture Notes in Computer Science, 2005

We consider terms of simply typed lambda calculus in which copy of a subterm may not be inserted to the argument of itself during the reduction. The terms form wide class which includes linear terms. We show that corresponding variant of the dual interpolation problem i.e. problem in which all expressions can be restricted to terms of this kind. Thus the model for this kind of expressions can admit fully abstract semantics.

2008

By using an infinity of extra variables every λ-term with indexed redexes is interpreted into a term in the simply typed lambda calculus à la Curry. A development becomes a usual β-reduction in the simply typed lambda calculus and the corresponding properties of developments come out from the corresponding properties (strong normalization and Church-Rosser) holding in this system. In this way we obtain a complete simulation of the notion of development into the system of simply typed lambda calculus.

Lambda Calculus with Types, 2009

A type is a collection of computational entities that share some common property. For example, the type int represents all expressions that evaluate to an integer, and the type int → int represents all functions from integers to integers. The Pascal subrange type [1..100] represents all integers between 1 and 100. Types can be thought of as describing computations succinctly and approximately: types are a static approximation to the run-time behaviors of terms and programs. Type systems are a lightweight formal method for reasoning about behavior of a program. Uses of type systems include: naming and organizing useful concepts; providing information (to the compiler or programmer) about data manipulated by a program; and ensuring that the run-time behavior of programs meet certain criteria. In this lecture, we'll consider a type system for the lambda calculus that ensures that values are used correctly; for example, that a program never tries to add an integer to a function. The resulting language (lambda calculus plus the type system) is called the simply-typed lambda calculus.

Theoretical Computer Science, 1993

Longo, G., K. M&ted and S. Soloviev, The genericity theorem and parametricity in the polymorphic I-calculus, Theoretical Computer Science 121 (1993) 323-349. This paper focuses on how terms of the polymorphic I-calculus, which may take types as inputs, depend on types. These terms are generally understood, in all models, to have an "essentially" constant meaning on input types. We show how the proof theory of polymorphic I.-calculus suggests a clear syntactic description of this phenomenon. Namely, under a reasonable conditon, we show that if two polymorphic functions agree on a single type, then they agree on all types (equivalently, types are generic inputs).

Electronic Notes in Theoretical Computer Science, 2001

Plotkin has advocated the combination of linear lambda calculus, polymorphism and fixed point recursion as an expressive semantic metalanguage. We study its expressive power from an operational point of view. We show that the naturally call-by-value operators of linear lambda calculus can be given a call-by-name semantics without affecting termination at exponential types and hence without affecting ground contextual equivalence. This result is used to prove properties of a logical relation that provides a new extensional characterisation of ground contextual equivalence and relational parametricity properties of polymorphic types.

1988

Rewriting techniques have been used to rea.son about a variety of topics related to programming languages, e.g., abstract data types, Petri Nets, FP programs, and data bases. They have also been used in the implementation and definition of a variety of programming languages. At the 1980 POPL Conference, David Musser proposed a new method of proving inductive properties of abstract data types, Since that time, this method, which came to be called inductionless induction, has attracted considerable attention. Numerous applications and improvements have been proposed and several implementations described. However, little or no work has appeared that questions the basic utility of the idea. The thesis of this paper is that while induction using equational term-rewriting holds great promise, inductionless induction does not. More specifically, we argue that for reasoning about abstract data types traditional inductive methods are usually superior.