# 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

#### 92 Citations

Logic Programming and Type Inference with the Calculus of Constructions

- Computer Science
- 2014

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

- Computer Science
- RTA
- 2011

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

- Computer Science
- PLDI 2018
- 2018

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

- Computer Science
- POPL 2015
- 2015

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)

- Mathematics
- 2014

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 the… Expand

Monnier 2019 ] is a functional language based on a dependently typed calculus , in the tradition of Coq [

- 2019

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 conveniently… Expand

Down with kinds : adding dependent heterogeneous equality to FC ( Extended Version )

- 2012

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 the… Expand

System FC with explicit kind equality

- Computer Science
- ICFP 2013
- 2013

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

- Computer Science
- POPL 2014
- 2014

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)

- 2013

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 the… Expand

#### References

SHOWING 1-10 OF 32 REFERENCES

Practical implementation of a dependently typed functional programming language

- Computer Science
- 2005

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

- Computer Science
- TYPES
- 2006

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

- 2001

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 type… Expand

The Implicit Calculus of Constructions

- Computer Science
- TLCA
- 2001

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 type… Expand

Dependent types in practical programming

- Computer Science
- POPL '99
- 1999

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) language… Expand

Dependently typed functional programs and their proofs

- Computer Science, Mathematics
- 2000

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

- Computer Science
- 1999

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

- Computer Science
- ICFP '05
- 2005

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

- Mathematics
- 2007

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

- Computer Science, Mathematics
- J. Symb. Comput.
- 1993

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