Book of Abstracts - IRIT

to be executed with the help of what we call a prophecy. The decision procedure is compiled
into an impure programming language (OCaml) with an efficient computational model which
performs all the effectful computations. The compilation maps the computations of the monad
in Coq, to effectful terms of OCaml; it also instruments the code to compute a small piece of
information to efficiently simulate a converging reduction of the compiled code in Type Theory,
using the initial monadic decision procedure. Finally, a relation of a posteriori simulation stands
between the compiled term Cptq and the initial monadic term t.
To formalise this idea in a general way, we have studied a concept of a posteriori simulation
of effectful computations in Type Theory. Roughly speaking, given a computation C of
type M A, we determine on which conditions there exists a piece of information p such that
the evaluation of C using p can witness an inhabitant of type A. Intuitively, if a compiled
computation Cptq converges to a value v, then the same evaluation can be simulated a posteriori
in Coq using some prophecy p. This prophecy completes the computation to get a
reduced one “ó p t” convertible to “unit t 1 ”, for some term t 1 of type T. The formalization of the
principle of a posteriori simulation focuses on simply typed λ-calculus. On the one hand, we
define λ, a purely functional and strongly normalizing programming language parameterized
by a monad M, which is abstractly specified by a set of requirements. On the other hand, we
define λ v,K, an impure functional and non-terminating programming language. The language
λ includes the usual monadic combinators for effects in the spirit of [5] and two unusual expressions:
the constant ó and the type constructor P for prophecies. The role of ó is to perform a
posteriori simulation, therefore we read ó p t of type M T as “the reduced computation of t using
the prophecy p”. This reduction remains as a computation, so ó has type P Ñ M T Ñ M T.
The type constructor M, used as a parameter for λ, is a simulable monad if the simulation
of effectful constants c converges thanks to the prophecies obtained during execution of the
compilation of c. The main theorem relates small-step semantics of λ and big-step semantics
of λ v,K: let ¤ $ t : MT be a computation which compilation converges to a value and produces a
prophecy p 1 , then there exists a term t 1 such that ó p
1 t t 1 .
There is a prototype plugin 1 for Coq to develop proofs using the method we described.
The monad includes the effectful operations of partiality, non-termination, state and printing.
Also the non-determinism can be programmed on top of the monad. Its type definition is
parameterized by a signature to type the memory operations: M Σ α State.t Σ Ñ pα
stringq ¢ State.t Σ. We keep the power of the dependently-typed system of Coq despite the fact
that we are working in a monad. Using this proposal of proof by reflection we also get a great
performance, gained for type-checking. This is an ongoing work, our long-term goal is to build
upon this system to use Coq as a typed tactic language for Coq.
References
[1] Guillaume Claret, Lourdes del Carmen González Huesca, Yann Régis-Gianas, and Beta Ziliani.
Lightweight proof by reflection using a posteriori simulation of effectful computation. Technical
report, 2013. https://gforge.inria.fr/frs/download.php/32051/coqbottom-techreport.pdf.
[2] John Harrison. Metatheory and reflection in theorem proving: A survey and critique. Technical
Report CRC-053, SRI Cambridge, Millers Yard, Cambridge, UK, 1995.
[3] Dimitri Hendriks. Proof reflection in coq. Journal of Automated Reasoning, 29(3-4):277–307, 2002.
[4] Martijn Oostdijk and Herman Geuvers. Proof by computation in the coq system. In Theoretical
Computer Science, pages 293–314. Elsevier, 2000.
[5] Philip Wadler. Comprehending monads. Mathematical Structures in Computer Science, 2(4):461–
493, 1992.
1 http://coqbottom.gforge.inria.fr
41