Results 1 
9 of
9
Subset coercions in Coq
 In Selected papers from the International Workshop on Types for Proofs and Programs (TYPES’06
, 2006
"... Abstract. We propose a new language for writing programs with dependent types which can be elaborated into partial Coq terms. This language permits to establish a phase distinction between writing and proving algorithms in the Coq environment. Concretely, this means allowing to write algorithms as e ..."
Abstract

Cited by 38 (2 self)
 Add to MetaCart
Abstract. We propose a new language for writing programs with dependent types which can be elaborated into partial Coq terms. This language permits to establish a phase distinction between writing and proving algorithms in the Coq environment. Concretely, this means allowing to write algorithms as easily as in a practical functional programming language whilst giving them as rich a specification as desired and proving that the code meets the specification using the whole Coq proof apparatus. This is achieved by extending conversion to an equivalence which relates types and subsets based on them, a technique originating from the “Predicate subtyping ” feature of PVS and following mathematical convention. The typing judgements can be translated to the Calculus of (Co)Inductive Constructions (Cic) by means of an interpretation which inserts coercions at the appropriate places. These coercions can contain existential variables representing the propositional parts of the final term, corresponding to proof obligations (or PVS typechecking conditions). A prototype implementation of this process is integrated with the Coq environment. 1
The implicit calculus of constructions as a programming language with dependent types
 In Amadio [6
"... Abstract. In this paper, we show how Miquel’s Implicit Calculus of Constructions (ICC) can be used as a programming language featuring dependent types. Since this system has an undecidable typechecking, we introduce a more verbose variant, called ICC ∗ which fixes this issue. Datatypes and program ..."
Abstract

Cited by 29 (1 self)
 Add to MetaCart
Abstract. In this paper, we show how Miquel’s Implicit Calculus of Constructions (ICC) can be used as a programming language featuring dependent types. Since this system has an undecidable typechecking, we introduce a more verbose variant, called ICC ∗ which fixes this issue. Datatypes and program specifications are enriched with logical assertions (such as preconditions, postconditions, invariants) and programs are decorated with proofs of those assertions. The point of using ICC ∗ rather than the Calculus of Constructions (the core formalism of the Coq proof assistant) is that all of the static information (types and proof objects) is transparent, in the sense that it does not affect the computational behavior. This is concretized by a builtin extraction procedure that removes this static information. We also illustrate the main features of ICC ∗ on classical examples of dependently typed programs. 1
On the strength of proofirrelevant type theories
 of Lecture Notes in Computer Science
, 2006
"... Vol. 4 (3:13) 2008, pp. 1–20 ..."
Towards Normalization by Evaluation for the βηCalculus of Constructions
"... Abstract. We consider the Calculus of Constructions with typed betaeta equality and an algorithm which computes long normal forms. The normalization algorithm evaluates terms into a semantic domain, and reifies the values back to terms in normal form. To show termination, we interpret types as part ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Abstract. We consider the Calculus of Constructions with typed betaeta equality and an algorithm which computes long normal forms. The normalization algorithm evaluates terms into a semantic domain, and reifies the values back to terms in normal form. To show termination, we interpret types as partial equivalence relations between values and type constructors as operators on PERs. This models also yields consistency of the betaetaCalculus of Constructions. The model construction can be carried out directly in impredicative type theory, enabling a formalization in Coq. 1
HigherOrder Encodings with Constructors
, 2008
"... As programming languages become more complex, there is a growing call in the research community for machinechecked proofs about programming languages. A key obstacle to this goal is in formalizing name binding, where a new name is created in a limited scope. Name binding is used in almost every pro ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
As programming languages become more complex, there is a growing call in the research community for machinechecked proofs about programming languages. A key obstacle to this goal is in formalizing name binding, where a new name is created in a limited scope. Name binding is used in almost every programming language to refer to the formal arguments to a function. For example, the function f (x) = x ∗ 2, which doubles its argument, binds the name x for its formal argument. Though this concept is intuitively straightforward, it is complex to define precisely because of the intended properties of name binding. For example, the above function is considered “syntactically equivalent ” to f (y) = y ∗ 2. It is the goal of this dissertation to posit a new technique for encoding name binding, called HigherOrder Encodings with Constructors or HOEC. HOEC encodes name binding with a construct called the νabstraction, which binds new constructors in a limited scope. These constructors can then be used to encode names. νabstractions already have the required properties of name bindings, so name binding need only be ii formalized once, in the definition of the νabstraction. The user thus then gets name
Author manuscript, published in "CALCULEMUS 2007, Hagenberg: Austria (2007)" DOI: 10.1007/9783540730866_4 Towards Constructive Homological Algebra in Type Theory
, 2009
"... Abstract. This paper reports on ongoing work on the project of representing the Kenzo system [15] in type theory [11]. ..."
Abstract
 Add to MetaCart
Abstract. This paper reports on ongoing work on the project of representing the Kenzo system [15] in type theory [11].
Type Systems for Dummies
"... We extend Pure Type Systems with a function turning each term M of type A into a dummy ∣M ∣ of the same type ( ∣ ⋅ ∣ is not an identity, in that M ≠ ∣M∣). Intuitively, a dummy represents an unknown, canonical object of the given type: dummies are opaque (cannot be internally inspected), and irrele ..."
Abstract
 Add to MetaCart
We extend Pure Type Systems with a function turning each term M of type A into a dummy ∣M ∣ of the same type ( ∣ ⋅ ∣ is not an identity, in that M ≠ ∣M∣). Intuitively, a dummy represents an unknown, canonical object of the given type: dummies are opaque (cannot be internally inspected), and irrelevant in the sense that dummies of a same type are convertible to each other. This latter condition makes convertibility in PTS with dummies (DPTS) stronger than usual, hence raising not trivial consistency issues. DPTS offer an alternative approach to (proof) irrelevance, tagging irrelevant information at the level of terms and not of types, and avoiding the annoying syntactical duplication of products, abstractions and applications into an explicit and an implicit version, typical of systems like ICC ∗. Categories and Subject Descriptors F.4.1 [Mathematical Logic
Towards Constructive Homological Algebra in Type Theory
"... Abstract. This paper reports on ongoing work on the project of representing the Kenzo system [15] in type theory [11]. ..."
Abstract
 Add to MetaCart
Abstract. This paper reports on ongoing work on the project of representing the Kenzo system [15] in type theory [11].