Motivated by applications to proof assistants based on dependent types, we develop and prove correct a strong reducer and b- equivalence checker for the l-calculus with products, sums, and guarded fixpoints. Our approach is based on compilation to the bytecode of an abstract machine performing weak reductions on non-closed terms, derived with minimal modifications from the ZAM machine used in the Objective Caml bytecode interpreter, and complemented by a recursive "read back" procedure. An implementation in the Coq proof assistant demonstrates important speedups compared with the original interpreter-based implementation of strong reduction in Coq.

Abstract. In this paper, we show how Miquel’s Implicit Calculus of Constructions (ICC) can be used as a programming language featuring dependent types. Since this system has an undecidable type-checking, we introduce a more verbose variant, called ICC ∗ which fixes this issue. Datatypes and program specifications are enriched with logical assertions (such as preconditions, postconditions, invariants) and programs are decorated with proofs of those assertions. The point of using ICC ∗ rather than the Calculus of Constructions (the core formalism of the Coq proof assistant) is that all of the static information (types and proof objects) is transparent, in the sense that it does not affect the computational behavior. This is concretized by a built-in extraction procedure that removes this static information. We also illustrate the main features of ICC ∗ on classical examples of dependently typed programs. 1

Abstract. We introduce Erasure Pure Type Systems, anextensionto Pure Type Systems with an erasure semantics centered around a type constructor ∀ indicating parametric polymorphism. The erasure phase is guided by lightweight program annotations. The typing rules guarantee that well-typed programs obey a phase distinction between erasable (compile-time) and non-erasable (run-time) terms. The erasability of an expression depends only on how its value is used in the rest of the program. Despite this simple observation, most languages treat erasability as an intrinsic property of expressions, leading to code duplication problems. Our approach overcomes this deficiency by treating erasability extrinsically. Because the execution model of EPTS generalizes the familiar notions of type erasure and parametric polymorphism, we believe functional programmers will find it quite natural to program in such a setting. 1

It is well-known that the Calculus of Constructions (CC) bears a simple set-theoretical model in which proof-terms are mapped onto a single object—a property which is known as proof-irrelevance. In this paper, we show that when going into the (generally omitted) technical details, this naive model raises several unexpected difficulties related to the interpretation of the impredicative level, especially for the soundness property which is surprisingly difficult to be given a correct proof in this simple framework. We propose a way to tackle these difficulties, thus giving a (more) detailed elementary consistency proof of CC without going back to a translation to Fω. We also discuss some possible alternatives and possible extensions of our construction.

Abstract. Dependently typed programs contain an excessive amount of static terms which are necessary to please the type checker but irrelevant for computation. To obtain reasonable performance of not only the compiled program but also the type checker such static terms need to be erased as early as possible, preferably immediately after type checking. To this end, Pfenning’s type theory with irrelevant quantification, that models a distinction between static and dynamic code, is extended to universes and large eliminations. Novel is a heterogeneously typed implementation of equality which allows the smooth construction of a universal Kripke model that proves normalization, consistency and decidability.

Abstract. We introduce Erasure Pure Type Systems, an extension to Pure Type Systems with an erasure semantics centered around a type constructor ∀ indicating parametric polymorphism. The erasure phase is guided by lightweight program annotations. The typing rules guarantee that well-typed programs obey a phase distinction between erasable (compile-time) and non-erasable (run-time) terms. The erasability of an expression depends only on how its value is used in the rest of the program. Despite this simple observation, most languages treat erasability as an intrinsic property of expressions, leading to code duplication problems. Our approach overcomes this deficiency by treating erasability extrinsically. Because the execution model of EPTS generalizes the familiar notions of type erasure and parametric polymorphism, we believe functional programmers will find it quite natural to program in such a setting. 1

This report has two distinct parts: rst I'll try to introduce ludics and its objects; then I'll analyze a little more deeply the notion of uniformity.

We devise a typed equality judgement for a predicative version of Miquel’s Implicit Calculus and complete it with a calculus for explicit substitutions. The resulting theory IITT, Implicit Intensional Type Theory, is shown consistent by a partial equivalence model. We further present a bidirectional type checking and extraction algorithm and briefly sketch the integration of another notion of irrelevance, Awodey and Bauer’s bracket types. This work is aimed at providing a solid an practical foundation for extraction of efficient programs from type theory.

Dependent type theory is a proven technology for verified functional programming in which programs and their correctness proofs may be developed using the same rules in a single formal system. In practice, large portions of programs developed in this way have no computational relevance to the ultimate result of the program and should therefore be removed prior to program execution. In previous work on identifying and removing irrelevant portions of programs, computational irrelevance is usually treated as an intrinsic property of program expressions. We find that such an approach forces programmers to maintain two copies of commonly used datatypes: a computationally relevant one and a computationally irrelevant one. We instead develop an extrinsic notion of computational irrelevance and find that it yields several benefits including (1) avoidance of the above mentioned code duplication problem; (2) an identification of computational irrelevance with a highly general form of parametric polymorphism; and (3) an elective (i.e., user-2 directed) notion of proof irrelevance. We also develop a program analysis for identifying irrelevant expressions and show how previously studied types embodying computational irrelevance (including subset types and squash types) are expressible in the extension of type theory developed herein.

We show how to replace the PER model of the original MFPS 2007 publication by a simpler subset model without losing any results. This observation follows from the general insight that PER semantics is strongly preferable when one models judgemental (aka typed) equality, yet for untyped equality is has no advantage over subset semantics. The paper under discussion[1] constructs a model of type theory over an untyped λ-model D, by constructing a partial equivalence relation (PER) Type ⊆ D×D which identifies the type values in D, plus for each a ∈ Type an associated PER [a] ⊆ D×D which identifies the values of type a in D. Equal types a = a ′ ∈ Type have equal extensions [a] = [a ′]. The purpose of a PER semantics is to model extensional equality on values, and it defines f = f ′ ∈ [Pi a g] iff f · d = f ′ · d ′ ∈ [g(d)] for all d = d ′ ∈ [a]. However, we have already treated η-equality in the term model D; in Lemma 3.4 we show that t −→βη t ′ implies [[t]] ρ ⊑ [[t ′]] ρ (in particular [[λfλx. f x]] ⊑ [[λf. f]]). Also, since we are constructing an open model where Nat is inhabited by the neutrals in addition to the numerals, extensionality does not mean more than η-equality. We can therefore replace the PER model by a simpler subset model. induction-recursion we define a subset Type ⊆ D and for each a ∈ Type a subset [a] ⊆ D. Type and types are upward closed, and improving the definedness of a type does not change its extension. Thus, if a ∈ Type then a ⊑ a ′ implies a ′ ∈ Type and [a] = [a ′], and d ∈ [a] and d ⊑ d ′ imply d ′ ∈ [a]. Improvement does not change the normal form, so ⇓ a ≡ ⇓ a ′ and ↓ a d ≡ ↓ a′ d ′.