The Implicit Calculus of Constructions as a Programming Language with Dependent Types

@inproceedings{Barras2008TheIC,
  title={The Implicit Calculus of Constructions as a Programming Language with Dependent Types},
  author={Bruno Barras and Bruno Bernardo},
  booktitle={FoSSaCS},
  year={2008}
}
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 type-checking, 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… Expand
Logic Programming and Type Inference with the Calculus of Constructions
TLDR
Because every result of execution is a term in the consistent calculus of constructions, Caledon can be considered an interactive theorem prover with a less orthogonal combination of proof search and proof checking than has previously been designed or implemented. Expand
Combining Proofs and Programs
TLDR
A work-in-progress overview of the Trellys project, which is new core language, designed to provide a smooth path from functional programming to dependently-typed programming, and allows programmers to work with total and partial functions uniformly. Expand
Typed closure conversion for the calculus of constructions
TLDR
A type-preserving closure-conversion translation from the Calculus of Constructions with strong dependent pairs to a type-safe, dependently typed compiler intermediate language named CC-CC, and proves soundness of CC- CC by giving a model in CC. Expand
Programming up to Congruence
TLDR
The design of Zombie is presented, a dependently-typed programming language that uses an adaptation of a congruence closure algorithm for proof and type inference that allows the type checker to automatically use equality assumptions from the context when reasoning about equality. Expand
Programming Up to Congruence (Extended version)
This paper presents the design of ZOMBIE, a dependently-typed programming language that uses an adaptation of a congruence closure algorithm for proof and type inference. This algorithm allows theExpand
Monnier 2019 ] is a functional language based on a dependently typed calculus , in the tradition of Coq [
Algebraic data types and inductive types like those of the Calculus of Inductive Constructions (CIC) are the bread and butter of statically typed functional programming languages. They convenientlyExpand
Down with kinds : adding dependent heterogeneous equality to FC ( Extended Version )
FC, the core language of the Glasgow Haskell Compiler, is an explicitly-typed variant of System F with first-class type equality proofs (i.e. coercions). This extensible proof system forms theExpand
System FC with explicit kind equality
TLDR
This paper introduces kind equalities to System FC, based on dependent type systems with heterogeneous equality and the "Type-in-Type" axiom, yet it preserves the metatheoretic properties of FC. Expand
Combining proofs and programs in a dependently typed language
TLDR
This language is composed of two fragments that share a common syntax and overlapping semantics: a logic that guarantees total correctness, and a call-by-value programming language that guarantees type safety but not termination. Expand
Towards dependently typed Haskell: System FC with kind equality (Extended Version)
System FC, the core language of the Glasgow Haskell Compiler, is an explicitly-typed variant of System F with first-class type equality proofs called coercions. This extensible proof system forms theExpand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 32 REFERENCES
Practical implementation of a dependently typed functional programming language
TLDR
This thesis considers the practical implementation of a dependently typed programming language using the Epigram notation, and sees that a dependent type theory is an effective base on which to build a feasible programming language. Expand
Subset Coercions in Coq
TLDR
A new language for writing programs with dependent types on top of the COQ proof assistant 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 COQProof apparatus. Expand
The Implicit Calculus of Constructions Extending Pure Type Systems with an Intersection Type Binder and Subtyping
In this paper, we introduce a new type system, the Implicit Calculus of Constructions, which is a Curry-style variant of the Calculus of Constructions that we extend by adding an intersection typeExpand
The Implicit Calculus of Constructions
In this paper, we introduce a new type system, the Implicit Calculus of Constructions, which is a Curry-style variant of the Calculus of Constructions that we extend by adding an intersection typeExpand
Dependent types in practical programming
We present an approach to enriching the type system of ML with a restricted form of dependent types, where type index objects are drawn from a constraint domain C, leading to the DML(C) languageExpand
Dependently typed functional programs and their proofs
TLDR
This thesis shows that the adoption of this uniqueness as axiomatic is sufficient to make pattern matching admissible, and develops technology for programming with dependent inductive families of datatypes and proving those programs correct. Expand
The Formal Semantics of PVS
TLDR
The formal semantics of the specification language of SRI''s Prototype Verification System (PVS) is presented, based on the simply typed lambda calculus, which illuminates several of the design considerations underlying PVS, the interaction between theorem proving and typechecking. Expand
Combining programming with theorem proving
TLDR
Instead of imposing syntactical restrictions on constraints, this design provides a means for the programmer to construct proofs that attest to the validity of constraints, to accommodate a programming paradigm that enables the programmers to combine programming with theorem proving. Expand
Towards a practical programming language based on dependent type theory
Dependent type theories have a long history of being used for theorem proving. One aspect of type theory which makes it very powerful as a proof language is that it mixes deduction with computation.Expand
Synthesis of ML Programs in the System Coq
TLDR
It is shown that the total program using primitive recursive functionals obtained out of a structural proof of termination leads to an (at first) surprisingly efficient algorithm. Expand
...
1
2
3
4
...