Proof-Assistants Using Dependent Type Systems

2001 ◽  
pp. 1149-1238 ◽  
Author(s):  
Henk Barendregt ◽  
Herman Geuvers
Keyword(s):  
Type Systems ◽  
Proof Assistants ◽  
Dependent Type

Introduction to the Special Issue on Dependent Type Theory Meets Practical Programming

2004 ◽  
Vol 14 (1) ◽  
pp. 1-2
Author(s):  
GILLES BARTHE ◽  
PETER DYBJEN ◽  
PETER THIEMANN
Keyword(s):  
Programming Languages ◽  
Type Theory ◽  
Type System ◽  
Type Systems ◽  
Special Issue ◽  
Dependent Type Theory ◽  
Dependent Type

Modern programming languages rely on advanced type systems that detect errors at compile-time. While the benefits of type systems have long been recognized, there are some areas where the standard systems in programming languages are not expressive enough. Language designers usually trade expressiveness for decidability of the type system. Some interesting programs will always be rejected (despite their semantical soundness) or be assigned uninformative types.

scholarly journals Pure type systems with more liberal rules

2001 ◽  
Vol 66 (4) ◽  
pp. 1561-1580 ◽  
Author(s):  
Martin Bunder ◽  
Wil Dekkers
Keyword(s):  
Type Systems ◽  
Independent Interest ◽  
Combinatory Logic ◽  
Proof Assistants ◽  
Formal Proofs ◽  
Pure Type ◽  
Pure Type Systems

Abstract.Pure Type Systems. PTSs, introduced as a generalisation of the type systems of Barendregt's lambda-cube, provide a foundation for actual proof assistants, aiming at the mechanic verification of formal proofs. In this paper we consider simplifications of some of the rules of PTSs. This is of independent interest for PTSs as this produces more flexible PTS-like systems, but it will also help, in a later paper, to bridge the gap between PTSs and systems of Illative Combinatory Logic.First we consider a simplification of the start and weakening rules of PTSs. which allows contexts to be sets of statements, and a generalisation of the conversion rule. The resulting Set-modified PTSs or SPTSs, though essentially equivalent to PTSs, are closer to standard logical systems.A simplification of the abstraction rule results in Abstraction-modified PTSs or APTSs. These turn out to be equivalent to standard PTSs if and only if a condition (*) holds. Finally we consider SAPTSs which have both modifications.

scholarly journals Dependent type systems as macros

2020 ◽  
Vol 4 (POPL) ◽  
pp. 1-29 ◽  
Author(s):  
Stephen Chang ◽  
Michael Ballantyne ◽  
Milo Turner ◽  
William J. Bowman
Keyword(s):  
Type Systems ◽  
Dependent Type

scholarly journals MiniAgda: Integrating Sized and Dependent Types

10.29007/322q ◽  
2018 ◽  
Author(s):  
Andreas Abel
Keyword(s):  
Programming Languages ◽  
Type Theory ◽  
Type System ◽  
Proof Assistants ◽  
Parametric Function ◽  
Dependent Type Theory ◽  
Essential Idea ◽  
Core Language ◽  
Higher Order Functions ◽  
Dependent Type

Sized types are a modular and theoretically well-understood tool for checking termination of recursive and productivity of corecursive definitions. The essential idea is to track structural descent and guardedness in the type system to make termination checking robust and suitable for strong abstractions like higher-order functions and polymorphism.To study the application of sized types to proof assistants and programming languages based on dependent type theory, we have implemented a core language with explicit handling of sizes. New considerations were necessary to soundly integrate sized types with dependencies and pattern matching, which was made possible by modern concepts such as inaccessible patterns and parametric function spaces.

scholarly journals Denotational semantics for guarded dependent type theory

2020 ◽  
Vol 30 (4) ◽  
pp. 342-378
Author(s):  
Aleš Bizjak ◽  
Rasmus Ejlers Møgelberg
Keyword(s):  
Type Theory ◽  
Denotational Semantics ◽  
Dependent Types ◽  
Proof Assistants ◽  
New Model ◽  
Dependent Type Theory ◽  
Additional Requirement ◽  
The One ◽  
Dependent Type

AbstractWe present a new model of guarded dependent type theory (GDTT), a type theory with guarded recursion and multiple clocks in which one can program with and reason about coinductive types. Productivity of recursively defined coinductive programs and proofs is encoded in types using guarded recursion and can therefore be checked modularly, unlike the syntactic checks implemented in modern proof assistants. The model is based on a category of covariant presheaves over a category of time objects, and quantification over clocks is modelled using a presheaf of clocks. To model the clock irrelevance axiom, crucial for programming with coinductive types, types must be interpreted as presheaves internally right orthogonal to the object of clocks. In the case of dependent types, this translates to a lifting condition similar to the one found in homotopy theoretic models of type theory, but here with an additional requirement of uniqueness of lifts. Since the universes defined by the standard Hofmann–Streicher construction in this model do not satisfy this property, the universes in GDTT must be indexed by contexts of clock variables. We show how to model these universes in such a way that inclusions of clock contexts give rise to inclusions of universes commuting with type operations on the nose.

A module calculus for Pure Type Systems

2006 ◽  
Vol 17 (3) ◽  
pp. 287-352 ◽  
Author(s):  
JUDICAËL COURANT
Keyword(s):  
Programming Languages ◽  
Theoretical Foundation ◽  
Type Systems ◽  
Proof Assistants ◽  
Pure Type ◽  
Formal Basis ◽  
Pure Type Systems ◽  
Module Systems ◽  
Theoretical Foundations ◽  
Module System

AbstractSeveral proof-assistants rely on the very formal basis of Pure Type Systems (PTS) as their foundations. We are concerned with the issues involved in the development of large proofs in these provers such as namespace management, development of reusable proof libraries and separate verification. Although implementations offer many features to address them, few theoretical foundations have been laid for them up to now. This is a problem as features dealing with modularity may have harmful, unsuspected effects on the reliability or usability of an implementation.In this paper, we propose an extension of Pure Type Systems with a module system, $\mathcal{MC}_2$, adapted from SML-like module systems for programming languages. This system gives a theoretical framework addressing the issues mentioned above in a quite uniform way. It is intended to be a theoretical foundation for the module systems of proof-assistants such as Coq or Agda. We show how reliability and usability can be formalized as metatheoretical properties and prove they hold for $\mathcal{MC}_2$.

Special issue on Dependent Type Theory Meets Programming Practice CALL FOR PAPERS

2001 ◽  
Vol 11 (4) ◽  
pp. 437-437
Author(s):  
Gilles Barthe ◽  
Peter Dybjer ◽  
Peter Thiemann
Keyword(s):  
Programming Languages ◽  
Type Theory ◽  
Type System ◽  
Type Systems ◽  
Point Of View ◽  
Theoretical Point ◽  
Special Issue ◽  
Dependent Type Theory ◽  
The Impact ◽  
Dependent Type

Modern programming languages rely on advanced type systems that detect errors at compile-time. While the benefits of type systems have long been recognized, there are some areas where the standard systems in programming languages are not expressive enough. Language designers usually trade expressiveness for decidability of the type system. Some interesting programs will always be rejected (despite their semantical soundness) or be assigned uninformative types.There are several remedies to this situation. Dependent type systems, which allow the formation of types that explicitly depend on other types or values, are one of the most promising approaches. These systems are well-investigated from a theoretical point of view by logicians and type theorists. For example, dependent types are used in proof assistants to implement various logics and there are sophisticated proof editors for developing programs in a dependently typed language.To the present day, the impact of these developments on practical programming has been small, partially because of the level of sophistication of these systems and of their type checkers. Only recently, there have been efforts to integrate dependent systems into intermediate languages in compilers and programming languages. Additional uses have been identified in high-profile applications such as mobile code security, where terms of a dependently typed lambda calculus to encode safety proofs.A special issue of the Journal of Functional Programming will be devoted to the interplay between dependent type theory and programming practice. We welcome technical contributions in the field, as well as position papers that:[bull ] make researchers in programming languages aware of new developments and research directions on the theory side;[bull ] point out to theorists practical uses of advanced type systems and urge them to address theoretical problems arising in emerging applications.Authors who are concerned about the appropriateness of a topic are welcome to contact the guest editors. Manuscripts should be unpublished works and not submitted elsewhere. Revised and enhanced versions of papers published in conference proceedings that have not appeared in archival journals are eligible for submission. All submissions will be reviewed according to the usual standards of scholarship and originality.Submissions should be sent to Gilles Barthe ([email protected]), with a copy to Nasreen Ahmad ([email protected]). Submitted articles should be sent in postscript format, preferably gzipped and uuencoded. In addition, please send, as plain text, title, abstract and contact information.The submission deadline is December 1st, 2001.

scholarly journals EMTST: Engineering the Meta-theory of Session Types

2020 ◽  
pp. 278-285
Author(s):  
David Castro ◽  
Francisco Ferreira ◽  
Nobuko Yoshida
Keyword(s):  
Wide Spectrum ◽  
Type Systems ◽  
Small Scale ◽  
Proof Assistant ◽  
Proof Assistants ◽  
Type Safety ◽  
Session Types ◽  
The Coq Proof Assistant ◽  
Coq Proof Assistant ◽  
Type Preservation

Abstract Session types provide a principled programming discipline for structured interactions. They represent a wide spectrum of type-systems for concurrency. Their type safety is thus extremely important. EMTST is a tool to aid in representing and validating theorems about session types in the Coq proof assistant. On paper, these proofs are often tricky, and error prone. In proof assistants, they are typically long and difficult to prove. In this work, we propose a library that helps validate the theory of session types calculi in proof assistants. As a case study, we study two of the most used binary session types systems: we show the impossibility of representing the first system in $$\alpha $$-equivalent representations, and we prove type preservation for the revisited system. We develop our tool in the Coq proof assistant, using locally nameless for binders and small scale reflection to simplify the handling of linear typing environments.

Sign in / Sign up

Export Citation Format

Share Document