Irrelevance, polymorphism, and erasure in type theory

  title={Irrelevance, polymorphism, and erasure in type theory},
  author={Richard Nathan Mishra-Linger},
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… Expand
Practical Erasure in Dependently Typed Languages
This paper presents a new erasure mechanism based on whole-program analysis, currently implemented in the Idris programming language, and shows that with it, erasure can lead to asymptotically faster code thanks to the ability to erase not only proofs but also indices. Expand
On Irrelevance and Algorithmic Equality in Predicative Type Theory
Pfenning's type theory with irrelevant quantification is considered which is compatible with a type-based notion of equality that respects eta-laws and its meta-theory is extended to universes and large eliminations and developed. Expand
Irrelevance in Type Theory with a Heterogeneous Equality Judgement
Pfenning's type theory with irrelevant quantification, that models a distinction between static and dynamic code, is extended to universes and large eliminations, which allows the smooth construction of a universal Kripke model that proves normalization, consistency and decidability. Expand
A dependently typed language with nontermination
It is proved type saftey for a large subset of the Zombie core language, including features such as computational irrelevance, CBV-reduction, and propositional equality with a heterogeneous, completely erased elimination form. Expand
Equational reasoning about programs with general recursion and call-by-value semantics
This paper outlines one core language design for Trellys, and demonstrates the use of the key language constructs to facilitate sound reasoning about potentially unsound programs. Expand
MiniAgda: Integrating Sized and Dependent Types
This paper has implemented a core language, MiniAgda, with explicit handling of sizes, to study the application of sized types to proof assistants and programming languages based on dependent type theory. Expand
Church encodings in higher-dimensional type theory Toward a theory of abstraction
The past four years of my intellectual life have been dominated by the urge to better understand just what such abstraction consists in. Initially, the problem posed itself to me in my first foraysExpand
Typed closure conversion for the calculus of constructions
A type-preserving closure-conversion translation from the Calculus of Constructions with strong dependent pairs to a type-safe, dependently typed compiler intermediate language named CC-CC, and proves soundness of CC- CC by giving a model in CC. Expand
Un Calcul des Constructions implicite avec sommes dépendantes et à inférence de type décidable. (An implicit Calculus of Constructions with dependent sums and decidable type inference)
These propose un langage permettant de developper des programmes certifies purement calculatoires avec des operateurs de type implicite, rendant possible l'ecriture de programmes certifiespurement calculatoire dans ICC_Σ. Expand
A dependently typed calculus with pattern matching and erasure inference
This paper explains why erasure is needed, that it is different from other concepts like irrelevance, and proposes a dependently typed calculus with pattern matching with erasure annotations to model it and shows that erasure in well-typed programs is sound in that it commutes with reduction. Expand


Dependently typed functional programs and their proofs
This thesis shows that the adoption of this uniqueness as axiomatic is sufficient to make pattern matching admissible, and develops technology for programming with dependent inductive families of datatypes and proving those programs correct. Expand
Constraint systems for useless variable elimination
This work reformulates Shivers' analysis as a set of constraints, and proves that any solution to the constraints is sound: that two computations that differ only on variables marked as useless give the same answer up to useless variables, and hence the sameanswer when the answer is a constant. Expand
On specifications, subset types and interpretation of proposition in type theory
In this paper we discuss some practical aspects of using type theory as a programming and specification language, where the viewpoint is to use it not only as a basis for program synthesis but alsoExpand
Refinement Types for Program Analysis
The main application of this method is the optimization of programs extracted from proofs in logical frameworks but it could be used as well in the elimination of dead code determined by program specialization. Expand
Practical implementation of a dependently typed functional programming language
This thesis considers the practical implementation of a dependently typed programming language using the Epigram notation, and sees that a dependent type theory is an effective base on which to build a feasible programming language. Expand
Phase Distinctions in Type Theory
The loss of phase distinctions manifests itself as the inability to perform compilation, since compilers are based on a syntactic translation phase which strips out phase distinctions. Expand
Dependent types in practical programming
We present an approach to enriching the type system of ML with a restricted form of dependent types, where type index objects are drawn from a constraint domain C, leading to the DML(C) languageExpand
The Implicit Calculus of Constructions as a Programming Language with Dependent Types
This paper shows how Miquel's Implicit Calculus of Constructions can be used as a programming language featuring dependent types and introduces a more verbose variant, called ICC* which fixes the issue of an undecidable type-checking. Expand
Type-based useless variable elimination
A type-based method for useless variable elimination is presented and the proof of the correctness is clear and the method can be easily extended to deal with a polymorphic language. Expand
Control-flow analysis of higher-order languages of taming lambda
This dissertation presents a technique for recovering the control-flow graph of a Scheme program at compile time, and gives examples of how this information can be used to perform several data-flow analysis optimisations, including copy propagation, induction- variable elimination, useless-variable elimination, and type recovery. Expand