Modular type-safety proofs in Agda

Authors:
Christopher Schwaab;Jeremy G. Siek
Affiliations:
University of Colorado at Boulder, Boulder, CO, USA;University of Colorado at Boulder, Boulder, CO, USA
Venue:
PLPV '13 Proceedings of the 7th workshop on Programming languages meets program verification
Year:
2013

Citing 10
Cited 2

Monad transformers and modular interpreters

POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Bananas in space: extending fold and unfold to exponential types

FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Recursion schemes from comonads

Nordic Journal of Computing
Data types à la carte

Journal of Functional Programming
Dependently typed programming in Agda

Proceedings of the 4th international workshop on Types in language design and implementation
The gentle art of levitation

Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Modularising inductive families

Proceedings of the seventh ACM SIGPLAN workshop on Generic programming
Mechanized metatheory for the masses: the PoplMark challenge

TPHOLs'05 Proceedings of the 18th international conference on Theorem Proving in Higher Order Logics
A generic abstract syntax model for embedded languages

Proceedings of the 17th ACM SIGPLAN international conference on Functional programming
Meta-theory à la carte

POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages

Generic datatypes à la carte

Proceedings of the 9th ACM SIGPLAN workshop on Generic programming
TeJaS: retrofitting type systems for JavaScript

Proceedings of the 9th symposium on Dynamic languages

Quantified Score

Hi-index	0.00

Visualization

Abstract

Methods for reusing code are widespread and well researched, but methods for reusing proofs are still emerging. We consider the use of dependent types for this purpose, introducing a modular approach for composing mechanized proofs. We show that common techniques for abstracting algorithms over data structures naturally translate to abstractions over proofs. We introduce a language composed of a series of smaller language components, each defined as functors, and tie them together by taking the fixed point of their sum [Malcom, 1990]. We then give proofs of type preservation for each language component and show how to compose these proofs into a proof for the entire language, again by taking the fixed point of a sum of functors.