• Corpus ID: 8333926

Dependently typed functional programs and their proofs

@inproceedings{McBride2000DependentlyTF,
  title={Dependently typed functional programs and their proofs},
  author={Conor McBride},
  year={2000}
}
Research in dependent type theories [M-L71a] has, in the past, concentrated on its use in the presentation of theorems and theorem-proving. This thesis is concerned mainly with the exploitation of the computational aspects of type theory for programming, in a context where the properties of programs may readily be specified and established. In particular, it develops technology for programming with dependent inductive families of datatypes and proving those programs correct. It demonstrates the… 
Towards a Proof-Irrelevant Calculus of Inductive Constructions
TLDR
The utilisation of Coq as a programming language as advocated by Sozeau relies on extending pCIC with a principle known as proof-irrelevance, which means that any two proofs of a logical proposition are identified by the system.
Practical implementation of a dependently typed functional programming language
TLDR
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.
Why dependent types matter
TLDR
This talk will explore some of the possibilities and challenges afforded by full spectrum type dependency at the static and dynamic level, and suggest a style of programming embracing 'learning by testing, views, and Burstall's 'hand simulation plus a little induction'.
On type-based termination and dependent pattern matching in the calculus of inductive constructions. (Terminaison basée sur les types et filtrage dépendant pour le calcul des constructions inductives)
TLDR
This thesis proposes an extension of CIC using a type-based mechanism for ensuring termination of recursive functions, and studies pattern-matching definitions in CIC, a functional programming language with an expressive type system.
A Formulation of Dependent ML with Explicit Equality Proofs
TLDR
A calculus that supports dependent programming in the style of Xi and Pfenning’s Dependent ML is studied and type safety and decidability of type checking are proved and a detailed comparison is presented with other dependently typed languages.
Type checking and normalisation
TLDR
This thesis considers type checking as it might form the basis of an implementation of type theory in the functional language Haskell and then normalisation in the more rigorous setting of the dependently typed languages Epigram and Agda.
Under Consideration for Publication in J. Functional Programming First-order Uniication by Structural Recursion Capsule Review
TLDR
Rst-order uniication becomes a structurally recursive program, and a termination proof is no longer required, and McBride proselytizes for a style of programming using structural recursion over indexed families of datatypes.
Irrelevance, polymorphism, and erasure in type theory
TLDR
A program analysis for identifying irrelevant expressions is developed and it is shown how previously studied types embodying computational irrelevance are expressible in the extension of type theory developed herein.
The view from the left
TLDR
This paper contributes a new programming notation for type theory which elaborates the notion of pattern matching in various ways, and develops enough syntax and semantics to account for this high-level style of programming in dependent type theory.
Supporting dependently typed functional programming with proof automation and testing
TLDR
A framework that provides improved proof automation and error feedback for the errors that occur when there is a mismatch between the specification of a program, described with the use of dependent types, and the behaviour of the program is designed.
...
...

References

SHOWING 1-10 OF 86 REFERENCES
HOPE: An experimental applicative language
TLDR
An applicative language called HOPE is described and discussed, to produce a very simple programming language which encourages the construction of clear and manipulable programs.
An exercise in dependent types: A well-typed interpreter
TLDR
By using depent types, the authors can be more precise about the type of values that the intepreter returns, something which opens the door to more eecient interpreters.
A Logic Programming Language with Lambda-Abstraction, Function Variables, and Simple Unification
TLDR
This paper presents a logic programming language, called Lλ, that also contains both function variables and λ-abstractions, but certain restriction are placed on occurrences of function variables, so that an implementation of Lλ does not need to implement full higher-order unification.
The implementation of ALF : a proof editor based on Martin-Löf's monomorphic type theory with explicit substitution
TLDR
A modular type/proof checking algorithm for complete proof objects is presented, and it is proved sound and complete assuming some basic meta theory properties of the substitution calculus and the proof editing facilities are proved to construct valid proofs.
Inductive Definitions in the system Coq - Rules and Properties
TLDR
This paper describes the rules for inductive definitions in the system Coq and proves strong normalization for a subsystem of Coq corresponding to the pure Calculus of Constructions plus Inductive Definitions with only weak eliminations.
Type Checking, Universe Polymorphism, and Typical Ambiguity in the Calculus of Constructions (Draft)
TLDR
It is shown that type synthesis is effective in CCω, even if explicit universe levels are erased from a term, and a set of constraints are computed that characterize all types of all well-typed instances of the term.
Proving Properties of Programs by Structural Induction
TLDR
Some syntactic extensions to Landin's functional programming language ISWIM are suggested which make it easier to program the manipulation of data structures and to develop proofs about such programs.
A Machine-Oriented Logic Based on the Resolution Principle
TLDR
The paper concludes with a discussion of several principles which are applicable to the design of efficient proof-procedures employing resolution as the basle logical process.
Monadic Presentations of Lambda Terms Using Generalized Inductive Types
TLDR
A definition of untyped λ-terms using a heterogeneous datatype is presented, i.e. an inductively defined operator can be extended to a Kleisli triple, which is a concise way to verify the substitution laws forλ-calculus.
Compiling Pattern Matching
TLDR
Only pattern matching in case expressions is described here, since the LML compiler project began as an attempt to produce efficient code for a typed functional language with lazy evaluation and it should also yield efficient code.
...
...