Results 1  10
of
18
A logical framework with dependently typed records
 In Proceedings of TLCA 2003, volume 2701 of LNCS
, 2003
"... ..."
Erasure and Polymorphism in Pure Type Systems
"... Abstract. We introduce Erasure Pure Type Systems, anextensionto Pure Type Systems with an erasure semantics centered around a type constructor ∀ indicating parametric polymorphism. The erasure phase is guided by lightweight program annotations. The typing rules guarantee that welltyped programs obe ..."
Abstract

Cited by 14 (0 self)
 Add to MetaCart
Abstract. We introduce Erasure Pure Type Systems, anextensionto Pure Type Systems with an erasure semantics centered around a type constructor ∀ indicating parametric polymorphism. The erasure phase is guided by lightweight program annotations. The typing rules guarantee that welltyped programs obey a phase distinction between erasable (compiletime) and nonerasable (runtime) terms. The erasability of an expression depends only on how its value is used in the rest of the program. Despite this simple observation, most languages treat erasability as an intrinsic property of expressions, leading to code duplication problems. Our approach overcomes this deficiency by treating erasability extrinsically. Because the execution model of EPTS generalizes the familiar notions of type erasure and parametric polymorphism, we believe functional programmers will find it quite natural to program in such a setting. 1
PROGRAMing finger trees in Coq
 In ACM SIGPLAN International Conference on Functional Programming. Association for Computing Machinery
, 2007
"... Finger Trees (Hinze and Paterson 2006) are a general purpose persistent data structure with good performance. Their genericity permits developing a wealth of structures like ordered sequences or interval trees on top of a single implementation. However, the type systems used by current functional la ..."
Abstract

Cited by 12 (0 self)
 Add to MetaCart
Finger Trees (Hinze and Paterson 2006) are a general purpose persistent data structure with good performance. Their genericity permits developing a wealth of structures like ordered sequences or interval trees on top of a single implementation. However, the type systems used by current functional languages do not guarantee the coherent parameterization and specialization of Finger Trees, let alone the correctness of their implementation.We present a certified implementation of Finger Trees solving these problems using the PROGRAM extension of COQ. We not only implement the structure but also prove its invariants along the way, which permit building certified structures on top of Finger Trees in an elegant way. Categories and Subject Descriptors D.2.4 [Software/Program
On the strength of proofirrelevant type theories
 of Lecture Notes in Computer Science
, 2006
"... Vol. 4 (3:13) 2008, pp. 1–20 ..."
A modular typechecking algorithm for type theory with singleton types and proof irrelevance
 IN TLCA’09, VOLUME 5608 OF LNCS
, 2009
"... ..."
Irrelevance in Type Theory with a Heterogeneous Equality Judgement
"... Abstract. Dependently typed programs contain an excessive amount of static terms which are necessary to please the type checker but irrelevant for computation. To obtain reasonable performance of not only the compiled program but also the type checker such static terms need to be erased as early as ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
Abstract. Dependently typed programs contain an excessive amount of static terms which are necessary to please the type checker but irrelevant for computation. To obtain reasonable performance of not only the compiled program but also the type checker such static terms need to be erased as early as possible, preferably immediately after type checking. To this end, Pfenning’s type theory with irrelevant quantification, that models a distinction between static and dynamic code, is extended to universes and large eliminations. Novel is a heterogeneously typed implementation of equality which allows the smooth construction of a universal Kripke model that proves normalization, consistency and decidability.
More On Implicit Syntax
 In Automated Reasoning. First International Joint Conference (IJCAR'01
"... Proof assistants based on type theories, such as Coq and Lego, allow users to omit subterms on input that can be inferred automatically. While those mechanisms are well known, adhoc algorithms are used to suppress subterms on output. As a result, terms might be printed identically although they di ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Proof assistants based on type theories, such as Coq and Lego, allow users to omit subterms on input that can be inferred automatically. While those mechanisms are well known, adhoc algorithms are used to suppress subterms on output. As a result, terms might be printed identically although they di#er in hidden parts. Such ambiguous representations may confuse users. Additionally, terms might be rejected by the type checker because the printer has erased too much type information. This paper addresses these problems by proposing e#ective erasure methods that guarantee successful term reconstruction, similar to the ones developed for the compression of proofterms in ProofCarrying Code environments. Experiences with the implementation in Typelab proved them both e#cient and practical. 1 Implicit Syntax Type theories are powerful formal systems that capture both the notion of computation and deduction. Particularly the expressive theories, such as the Calculus of Constructions (CC) [CH88] which is investigated in this paper, are used for the development of mathematical and algorithmic theories since proofs and specifications are representable in a very direct way using one uniform language. There is a price to pay for this expressiveness: abstractions have to be decorated with annotations, and type applications have to be written explicitly, because type abstraction and type application are just special cases of #abstraction and application. For example, to form a list one has to provide the element type as an additional argument to instantiate the polymorphic constructors cons and nil as in (cons IN1(nil IN))). Also, one has to annotate the abstraction of n in #n:IN .n+1 with its type IN although this type is determined by the abstraction body. These excessive ...
Termination Casts: A Flexible Approach to Termination with General Recursion
"... This paper proposes a typeandeffect system called T eq ↓ , which distinguishes terminating terms and total functions from possibly diverging terms and partial functions, for a lambda calculus with general recursion and equality types. The central idea is to include a primitive typeform “Terminate ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
This paper proposes a typeandeffect system called T eq ↓ , which distinguishes terminating terms and total functions from possibly diverging terms and partial functions, for a lambda calculus with general recursion and equality types. The central idea is to include a primitive typeform “Terminates t”, expressing that term t is terminating; and then allow terms t to be coerced from possibly diverging to total, using a proof of Terminates t. We call such coercions termination casts, and show how to implement terminating recursion using them. For the metatheory of the system, we describe a translation from T eq ↓ to a logical theory of termination for general recursive, simply typed functions. Every typing judgment of T eq ↓ is translated to a theorem expressing the appropriate termination property of the computational part of the T eq ↓ term. 1
Erasure and Polymorphism in Pure Type Systems
"... Abstract. We introduce Erasure Pure Type Systems, an extension to Pure Type Systems with an erasure semantics centered around a type constructor ∀ indicating parametric polymorphism. The erasure phase is guided by lightweight program annotations. The typing rules guarantee that welltyped programs o ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract. We introduce Erasure Pure Type Systems, an extension to Pure Type Systems with an erasure semantics centered around a type constructor ∀ indicating parametric polymorphism. The erasure phase is guided by lightweight program annotations. The typing rules guarantee that welltyped programs obey a phase distinction between erasable (compiletime) and nonerasable (runtime) terms. The erasability of an expression depends only on how its value is used in the rest of the program. Despite this simple observation, most languages treat erasability as an intrinsic property of expressions, leading to code duplication problems. Our approach overcomes this deficiency by treating erasability extrinsically. Because the execution model of EPTS generalizes the familiar notions of type erasure and parametric polymorphism, we believe functional programmers will find it quite natural to program in such a setting. 1
Universe Subtyping in MartinLöf Type Theory Internship Report
"... The pragmatic goal of this internship was to establish the theoretical soundness of a particular feature of the Agda proof assistant, the socalled universe polymorphism. This is part of a series of work by my supervisor Andreas Abel [ACD07] aiming to provide a coherent metatheory for the different ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
The pragmatic goal of this internship was to establish the theoretical soundness of a particular feature of the Agda proof assistant, the socalled universe polymorphism. This is part of a series of work by my supervisor Andreas Abel [ACD07] aiming to provide a coherent metatheory for the different features implemented or desired in this proof assistant. More precisely, we first considered universe cumulativity, a wellknown feature for universe hierarchy, then universe polymorphism, which is a less explored area, and finally attempted to add irrelevance to the type system, to ease universe levels manipulations. All those notions will be introduced in more detail in the first section. I will highlight the main goals and constraints of the desired theory, in comparison to related works. I will also have to discuss some of the technical choices and issues we have faced; those technical decisions have large consequences – often unforeseen – on the technical development and its structure. The second section will describe the formal type system – or type systems, as we will consider variants – used throughout the report. To this declarative type