Reseña: “Certified, efficient and sharp univariate Taylor models in Coq”

Se ha publicado un artículo de razonamiento formalizado en Coq titulado Certified, efficient and sharp univariate Taylor models in Coq.

Sus autores son

Su resumen es

We present a formalisation, within the COQ proof assistant, of univariate Taylor models. This formalisation being executable, we get a generic library whose correctness has been formally proved and with which one can effectively compute rigorous and sharp approximations of univariate functions composed of usual functions such as 1/x, sqrt(x), exp(x), sin(x) among others. In this paper, we present the key parts of the formalisation and we evaluate the quality of our certified library on a set of examples.

Reseña: “Computational verification of network programs in Coq”

Se ha publicado un artículo de verificación formal en Coq titulado Computational verification of network programs in Coq.

Su autor es Gordon Stewart (miembro del proyecto Verified Software Toolchain la Universidad de Princeton).

Su resumen es

We report on the design of the first fully automatic, machine-checked tool suite for verification of high-level network programs. The tool suite targets programs written in NetCore, a new declarative network programming language. Our work builds on a recent effort by Guha, Reitblatt, and Foster to build a machine-verified compiler from NetCore to OpenFlow, a new protocol for software-defined networking. The result is an end-to-end system that provides strong guarantees on the compiled OpenFlow flow tables that are installed on actual network switches.

El correspondiente código en Coq se encuentra aquí.

Reseña: “Formalizing cut elimination of coalgebraic logics in Coq”

Se ha publicado un artículo de razonamiento formalizado en Coq sobre metalógica titulado Formalizing cut elimination of coalgebraic logics in Coq.

Su autor es Hendrik Tews (de la Dresden University of Technology) y se presentará en el Tableaux 2013 (Automated Reasoning with Analytic Tableaux and Related Methods).

Su resumen es

In their work on coalgebraic logics, Pattinson and Schröder prove soundness, completeness and cut elimination in a generic sequent calculus for propositional multi-modal logics. The present paper reports on a formalization of Pattinson’s and Schröder’s work in the proof assistant Coq that provides machine-checked proofs for soundness, completeness and cut elimination of their calculus. The formalization exploits dependent types to obtain a very concise deep embedding for formulas and proofs. The work presented here can be used to verify cut elimination theorems for different modal logics with considerably less effort in the future.

El código de las correspondientes teorías en Coq se encuentra aquí.

Coq gana el “2013 ACM SIGPLAN Software System Award”

El sistema de demostración asistida Coq ha recibido este año el premio Programming Languages Software Award del grupo SIGPLAN (Special Interest Group in Programing Languages) de la ACM (Association for Computing Machinery).

La justificación del premio a Coq es la siguiente:

The Coq proof assistant provides a rich environment for interactive development of machine-checked formal reasoning. Coq is having a profound impact on research on programming languages and systems, making it possible to extend foundational approaches to unprecedented levels of scale and confidence, and transfer them to realistic programming languages and tools. It has been widely adopted as a research tool by the programming language research community, as evidenced by the many papers at SIGPLAN conferences whose results have been developed and/or verified in Coq. It has also rapidly become one of the leading tools of choice for teaching the foundations of programming languages, with courses offered by many leading universities and a growing number of books emerging to support them. Last but not least, these successes have helped to spark a wave of widespread interest in dependent type theory, the richly expressive core logic on which Coq is based.

As a software system, Coq has been in continuous development for over 20 years, a truly impressive feat of sustained, research-driven engineering. The Coq team continues to develop the system, bringing significant improvements in expressiveness and usability with each new release.

In short, Coq is playing an essential role in our transition to a new era of formal assurance in mathematics, semantics, and program verification.

Reseña: “Certifying homological algorithms to study biomedical images”

Se ha presentado una Tesis doctoral de verificación formal con Coq/SSReflect titulada Certifying homological algorithms to study biomedical images.

Su autora es María Poza López de Echazarreta dirigida por César Domínguez y Julio Rubio (de la Universidad de la Rioja).

Su resumen es

In this memoir, we have reported on a research which provides a certified computation of homology groups associated with some digital images coming from a biomedical problem. The main contributions allowing us to reach this challenging goal have been the following ones.

  • The implementation in Coq/SSReflect of the Romero-Sergeraert algorithm computing an admissible discrete vector field for a digital image.
  • The complete formalization in Coq/SSReflect of the theorem known as Basic Perturbation Lemma (BPL).
  • Two formalizations of the Vector-Field Reduction Theorem for matrices. One is proved using the BPL and the other one applying the Hexagonal Lemma.
  • A discussion on different methods to overcome the efficiency problems appearing when executing programs inside proof assistants. In particular, the Haskell programming language has been used in two different ways: first, to model algorithms which are subsequently implemented in Coq and, second, as an oracle to produce results whose properties are verified in the proof assistant.
  • A verified program to compute homology groups of a simplicial complex obtained from a digital image.
  • As a by-product of all the other contributions, an application of Algebraic Topology to study biomedical images in a reliable manner. Our methodology ensures that the final homological calculations are correct.

By observing the memoir as a whole, it is clear that, even if our initial emphasis was in biomedical applications, much of the work has been devoted to the formalization of mathematics and program verification. The reason is that, even if we have built over very solid foundations (effective homology from the
algorithmic side and SSReflect as theorem proving basis), we needed to reproduce inside Coq/SSReflect a part of Computational Algebraic Topology. As a consequence, we focused on obtaining a complete verified path from biomedical digital images to homological computing, but without getting a good performance in the final implementation. Thus, our research should be considered as a proof of concept: homological image processing can be implemented in a verified manner by using interactive theorem provers. Our results are therefore rather a starting point, instead of a closed problem.

Un aspecto destacable es la metodología híbrida que se ha utilizado. Dicha metodología se explica en la página 24:

In our developments the formally certified implementation of the algorithms have followed the methodology presented in [Mörtberg 2010]. This methodology can be split into these three steps:

  1. Implement a version of our algorithms in Haskell, a lazy functional programming language.
  2. Test properties about the Haskell programs using QuickCheck. This tool allows one to test intensively properties about programs implemented in Haskell, in an automatic way.
  3. Verify the programs using Coq, an interactive proof assistant, and its SSReflect library.

Using QuickCheck can be considered as a good starting point towards the formal verification of our programs. This provides us two advantages:

  • A specification of the properties which must be satisfied by our programs is given (a necessary step in the formalization process which will be reused
    in Coq).

  • The testing process can be useful in order to detect bugs in a quick and easy way, before trying a formal verification of our programs (a quite difficult task).