A typed lambda calculus with categorical type constructors (original) (raw)
Related papers
Normalization by evaluation for typed lambda calculus with coproducts
Proceedings 16th Annual IEEE Symposium on Logic in Computer Science, 2001
We solve the decision problem for simply typed lambda calculus with strong binary sums, equivalently the word problem for free cartesian closed categories with binary coproducts. Our method is based on the semantical technique known as "normalization by evaluation" and involves inverting the interpretation of the syntax into a suitable sheaf model and from this extracting appropriate unique normal forms. There is no rewriting theory involved, and the proof is completely constructive, allowing program extraction from the proof.
1993
We add extensional equalities for the functional and product types to the typed λ-calculus with not only products and terminal object, but also sums and bounded recursion (a version of recursion that does not allow recursive calls of infinite length). We provide a confluent and strongly normalizing (thus decidable) rewriting system for the calculus, that stays confluent when allowing unbounded recursion. For that, we turn the extensional equalities into expansion rules, and not into contractions as is done traditionally. We first prove the calculus to be weakly confluent, which is a more complex and interesting task than for the usual λ-calculus. Then we provide an effective mechanism to simulate expansions without expansion rules, so that the strong normalization of the calculus can be derived from that of the underlying, traditional, non extensional system. These results give us the confluence of the full calculus, but we also show how to deduce confluence without the weak confluence property, using only our technique of simulating expansions.
Reducibility of types in typed lambda calculus
Information and Computation, 1988
Consider types built up from a base type 0 using the operation ~. A type a is reducible to a type ~, notation a <~ z, iff there exists a closed term M in tr ~ ~ such that for all closed N1, N2 in a we have NI = ¢~,N 2 ¢~ MNI = I~,MN2. Two types are equivalent iff each is reducible to the other. In (Statman, 1980, in "To H, B. Curry:
Type Assignment for the Computational lambda-Calculus
arXiv (Cornell University), 2019
We study polymorphic type assignment systems for untyped lambda-calculi with effects. We introduce an intersection type assignment system for Moggi's computational lambda-calculus, where a generic monad T is considered, and provide a concrete model of the calculus via a filter model construction. We prove soundness and completeness of the type system, together with subject reduction and expansion properties.
The 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, 1999
Recent work on infinitary versions of the lambda calculus has shown that the infinite lambda calculus can be a useful tool to study the unsolvable terms of the classical lambda calculus. Working in the framework of the intersection type disciplines, we devise a type assignment system such that two terms are equal in the infinite lambda calculus iff they can be assigned the same types in any basis. A novel feature of the system is the presence of a type constant to denote the set of all terms of order zero, and the possibility of applying a type to another type. We prove a completeness and an approximation theorem for our system. Our results can be considered as a first step towards the goal of giving a denotational semantics for the lambda calculus which is suited for the study of the unsolvable terms. However, some noncontinuity phenomena of the infinite lambda calculus make a full realization of this idea (namely the construction of a filter model) a quite difficult task.
Normalization by Evaluation for Typed Weak lambda-Reduction
2018
Weak reduction relations in the λ-calculus are characterized by the rejection of the so-called ξ-rule, which allows arbitrary reductions under abstractions. A notable instance of weak reduction can be found in the literature under the name restricted reduction or weak λ-reduction. In this work, we attack the problem of algorithmically computing normal forms for λ, the λ-calculus with weak λ-reduction. We do so by first contrasting it with other weak systems, arguing that their notion of reduction is not strong enough to compute λ-normal forms. We observe that some aspects of weak λ-reduction prevent us from normalizing λ directly, thus devise a new, better-behaved weak calculus λ, and reduce the normalization problem for λ to that of λ. We finally define type systems for both calculi and apply Normalization by Evaluation to λ, obtaining a normalization proof for λ as a corollary. We formalize all our results in Agda, a proof-assistant based on intensional Martin-Löf Type Theory. 201...
The untyped computational λ-calculus and its intersection type discipline
Theoretical Computer Science, 2020
We study a Curry style type assignment system for untyped-calculi with e↵ects, based on Moggi's monadic approach. Moving from the abstract definition of monads, we introduce a version of the call-by-value computational-calculus based on Wadler's variant, without let, and with unit and bind operators. We define a notion of reduction for the calculus and prove it confluent. We then introduce an intersection type system inspired by Barendregt, Coppo and Dezani system for ordinary untyped-calculus, establishing type invariance under conversion. Finally, we introduce a notion of convergence, which is precisely related to reduction, and characterize convergent terms via their types.