Show simple item record

Files in this item


Item metadata

dc.contributor.advisorBrady, Edwin
dc.contributor.authorSlama, Franck
dc.coverage.spatial180 p.en_US
dc.description.abstractDependent type theories are a kind of mathematical foundations investigated both for the formalisation of mathematics and for reasoning about programs. They are implemented as the kernel of many proof assistants and programming languages with proofs (Coq, Agda, Idris, Dedukti, Matita, etc). Dependent types allow to encode elegantly and constructively the universal and existential quantifications of higher-order logics and are therefore adapted for writing logical propositions and proofs. However, their usage is not limited to the area of pure logic. Indeed, some recent work has shown that they can also be powerful for driving the construction of programs. Using more precise types not only helps to gain confidence about the program built, but it can also help its construction, giving rise to a new style of programming called Type-Driven Development. However, one difficulty with reasoning and programming with dependent types is that proof obligations arise naturally once programs become even moderately sized. For example, implementing an adder for binary numbers indexed over their natural number equivalents naturally leads to proof obligations for equalities of expressions over natural numbers. The need for these equality proofs comes, in intensional type theories (like CIC and ML) from the fact that in a non-empty context, the propositional equality allows us to prove as equal (with the induction principles) terms that are not judgementally equal, which implies that the typechecker can't always obtain equality proofs by reduction. As far as possible, we would like to solve such proof obligations automatically, and we absolutely need it if we want dependent types to be used more broadly, and perhaps one day to become the standard in functional programming. In this thesis, we show one way to automate these proofs by reflection in the dependently typed programming language Idris. However, the method that we follow is independent from the language being used, and this work could be reproduced in any dependently-typed language. We present an original type-safe reflection mechanism, where reflected terms are indexed by the original Idris expression that they represent, and show how it allows us to easily construct and manipulate proofs. We build a hierarchy of correct-by-construction tactics for proving equivalences in semi-groups, monoids, commutative monoids, groups, commutative groups, semi-rings and rings. We also show how each tactic reuses those from simpler structures, thus avoiding duplication of code and proofs. Finally, and as a conclusion, we discuss the trust we can have in such machine-checked proofs.en_US
dc.publisherUniversity of St Andrews
dc.rightsAttribution-NonCommercial-NoDerivatives 4.0 International*
dc.subjectType theoryen_US
dc.subjectProof automationen_US
dc.subjectCorrect-by-construction softwareen_US
dc.subjectType-driven developmenten_US
dc.subjectProof by reflectionen_US
dc.subjectFormal certificationen_US
dc.subjectProof assistanten_US
dc.subjectAlgebraic structureen_US
dc.subjectDependent typesen_US
dc.subjectDependently typed programming languagesen_US
dc.subjectProof obligationen_US
dc.subject.lcshFunctional programming languagesen
dc.subject.lcshType theoryen
dc.subject.lcshAutomatic theorem provingen
dc.subject.lcshIdris (Computer program language)en
dc.titleAutomatic generation of proof terms in dependently typed programming languagesen_US
dc.contributor.sponsorUniversity of St Andrews. School of Computer Scienceen_US
dc.type.qualificationnamePhD Doctor of Philosophyen_US
dc.publisher.institutionThe University of St Andrewsen_US

The following license files are associated with this item:

    This item appears in the following Collection(s)

    Show simple item record

    Attribution-NonCommercial-NoDerivatives 4.0 International
    Except where otherwise noted within the work, this item's license for re-use is described as Attribution-NonCommercial-NoDerivatives 4.0 International