Miguel Pagano

A MODULAR TYPE-CHECKING ALGORITHM FOR TYPE THEORY WITH SINGLETON TYPES AND PROOF IRRELEVANCE

We define a logical framework with singleton types and one universe of small types. We give the semantics using a PER model; it is used for constructing a normalisation-by-evaluation algorithm. We prove completeness and soundness of the algorithm; and get as a corollary the injectivity of type constructors. Then we give the definition of a correct and complete type-checking algorithm for terms in normal form. We extend the results to proof-irrelevant propositions.

A Modular Type-Checking Algorithm for Type Theory with Singleton Types and Proof Irrelevance

We define a logical framework with singleton types and one universe of small types. We give the semantics using a PER model; it is used for constructing a normalisation-by-evaluation algorithm. We prove completeness and soundness of the algorithm; and get as a corollary the injectivity of type constructors. Then we give the definition of a correct and complete type-checking algorithm for terms in normal form. We extend the results to proof-irrelevant propositions.

Proving Correctness of a Compiler Using Step-indexed Logical Relations

In this paper we prove the correctness of a compiler for a call-by-name language using step-indexed logical relations and biorthogonality. The source language is an extension of the simply typed lambda-calculus with recursion, and the target language is an extension of the Krivine abstract machine. We formalized the proof in the Coq proof assistant.

A Certified Extension of the Krivine Machine for a Call-by-Name Higher-Order Imperative Language

In this paper we present a compiler that translates programs from an imperative higher-order language into a sequence of instructions for an abstract machine. We consider an extension of the Krivine machine for the call-by-name lambda calculus, which includes strict operators and imperative features. We show that the compiler is correct with respect to the big-step semantics of our language, both for convergent and divergent programs.

A Type-Checking Algorithm for Martin-Löf Type Theory with Subtyping Based on Normalisation by Evaluation

We present a core Martin-Lof type theory with subtyping; it has a cumulative hierarchy of universes and the contravariant rule for subtyping between dependent product types. We extend to this calculus the normalisation by evaluation technique defined for a variant of MLTT without subtyping. This normalisation function makes the subtyping relation and type-checking decidable. To our knowledge, this is the first time that the normalisation by evaluation technique has been considered in the context of subtypes, which introduce some subtleties in the proof of correctness of NbE; an important result to prove correctness and completeness of type-checking.

An Internalist Approach to Correct-by-Construction Compilers

In this paper we present a methodology to organize the construction of a correct compiler, taking advantage of the power of full dependently type systems. The basic idea consists in decorating the abstract syntax of languages with their semantics, allowing to express the correctness of the compiler at type level. We show our methodology in a first small example and then explore how it can be promoted to more realistic languages, realizing that our internalistic approach is feasible for defining a correct-by-construction compiler from an imperative language with conditional iteration to a stack based intermediate language. We also show how this methodology can be combined with the externalist approach, compiling from the intermediate language to an assembly-like low level code and separately proving its correctness.

Biorthogonality for a Lazy language

In this paper we extend the technique of biorthogonality for proving the correctness of a compiler for a lazy language, which, as far as we know, has only been preliminary explored by Rodríguez [19]. One of the technical difficulties arising in this context is the sharing of the heap between the realizer and the test. We significantly extend the language considered by Rodríguez by adding integer numbers and products, which may be used as a test case for tackling other data-types. Our language does not yet support recursive definitions.