Results

**1 - 7**of**7**### Coq: The world’s best macro assembler?

"... We describe a Coq formalization of a subset of the x86 architecture. One emphasis of the model is brevity: using dependent types, type classes and notation we give the x86 semantics a makeover that counters its reputation for baroqueness. We model bits, bytes, and memory concretely using functions t ..."

Abstract
- Add to MetaCart

We describe a Coq formalization of a subset of the x86 architecture. One emphasis of the model is brevity: using dependent types, type classes and notation we give the x86 semantics a makeover that counters its reputation for baroqueness. We model bits, bytes, and memory concretely using functions that can be computed inside Coq itself; concrete representations are mapped across to mathematical objects in the SSREFLECT library (naturals, and integers modulo 2 n) to prove theorems. Finally, we use notation to support conventional assembly code syntax inside Coq, including lexically-scoped labels. Ordinary Coq definitions serve as a powerful “macro ” feature for everything from simple conditionals and loops to stack-allocated local variables and procedures with parameters. Assembly code can be assembled within Coq, producing a sequence of hex bytes. The assembler enjoys a correctness theorem relating machine code in memory to a separation-logic formula suitable for program verification. 1.

### Author manuscript, published in "Computer Science Logic, Czech Republic (2010)" DOI: 10.1007/978-3-642-15205-4_37 Untyping Typed Algebraic Structures and Colouring Proof Nets of Cyclic Linear Logic ⋆

, 2010

"... Abstract. We prove “untyping ” theorems: in some typed theories (semirings, Kleene algebras, residuated lattices, involutive residuated lattices), typed equations can be derived from the underlying untyped equations. As a consequence, the corresponding untyped decision procedures can be extended for ..."

Abstract
- Add to MetaCart

Abstract. We prove “untyping ” theorems: in some typed theories (semirings, Kleene algebras, residuated lattices, involutive residuated lattices), typed equations can be derived from the underlying untyped equations. As a consequence, the corresponding untyped decision procedures can be extended for free to the typed settings. Some of these theorems are obtained via a detour through fragments of cyclic linear logic, and give rise to a substantial optimisation of standard proof search algorithms. 1

### Kleene Algebra with Tests and Coq Tools for While Programs

, 2013

"... Abstract. We present a Coq library about Kleene algebra with tests, including a proof of their completeness over the appropriate notion of languages, a decision procedure for their equational theory, and tools for exploiting hypotheses of a certain kind in such a theory. Kleene algebra with tests ma ..."

Abstract
- Add to MetaCart

Abstract. We present a Coq library about Kleene algebra with tests, including a proof of their completeness over the appropriate notion of languages, a decision procedure for their equational theory, and tools for exploiting hypotheses of a certain kind in such a theory. Kleene algebra with tests make it possible to represent if-then-else statements and while loops in most imperative programming languages. They were actually introduced by Kozen as an alternative to propositional Hoare logic. We show how to exploit the corresponding Coq tools in the context of program verification by proving equivalences of while programs, correctness of some standard compiler optimisations, Hoare rules for partial correctness, and a particularly challenging equivalence of flowchart schemes.

### A language of patterns for subterm selection

, 2012

"... Abstract. This paper describes the language of patterns that equips the SSReflect proof shell extension for the Coq system. Patterns are used to focus proof commands on subexpressions of the conjecture under analysis in a declarative manner. They are designed to ease the writing of proof scripts and ..."

Abstract
- Add to MetaCart

Abstract. This paper describes the language of patterns that equips the SSReflect proof shell extension for the Coq system. Patterns are used to focus proof commands on subexpressions of the conjecture under analysis in a declarative manner. They are designed to ease the writing of proof scripts and to increase their readability and maintainability. A pattern can identify the subexpression of interest approximating the subexpression itself, or its enclosing context or both. The user is free to choose the most convenient option. Patterns are matched following an extremely precise and predictable discipline, that is carefully designed to admit an efficient implementation. In this paper we report on the language of patterns, its matching algorithm and its usage in the formal library developed by the Mathematical Components team to support the verification of the Odd Order Theorem. 1

### Noname manuscript No. (will be inserted by the editor) Proof Pearl: Regular Expression Equivalence and Relation Algebra

"... the date of receipt and acceptance should be inserted later Abstract We describe and verify an elegant equivalence checker for regular expressions. It works by constructing a bisimulation relation between (derivatives of) regular expressions. By mapping regular expressions to binary relations, an au ..."

Abstract
- Add to MetaCart

the date of receipt and acceptance should be inserted later Abstract We describe and verify an elegant equivalence checker for regular expressions. It works by constructing a bisimulation relation between (derivatives of) regular expressions. By mapping regular expressions to binary relations, an automatic and complete proof method for (in)equalities of binary relations over union, composition and (reflexive) transitive closure is obtained. The verification is carried out in the theorem prover Isabelle/HOL, yielding a practically useful decision procedure. 1

### Towards primitive data types for COQ: 63-bits integers and persistent arrays ∗

, 2013

"... As formal methods are applied to an increasingly wide variety of areas of mathematics and program verification, the need for efficient computations inside proof assistants is becoming more present. Typical applications are proofs inherently relying on costly computations, like the four color theorem ..."

Abstract
- Add to MetaCart

As formal methods are applied to an increasingly wide variety of areas of mathematics and program verification, the need for efficient computations inside proof assistants is becoming more present. Typical applications are proofs inherently relying on costly computations, like the four color theorem [Gon07], the Kepler conjecture [Hal05] or the certification of big prime numbers [GTW06]. But computational capabilities can also be used to enhance proof automation, like tactics deciding algebraic identities over rings [GM05] or Kleene algebras [BP10] or calling external solvers without trusting them [Arm+11; BCP11]. Other original applications may include importing proof objects from different proof systems [KW10] or emitting formally verified assembly code [JBK13]. Addressing this need, the COQ proof assistant has evolved to offer new features for efficient computations. Runtime environments for terms evaluation have been improved, a key step being definitely the introduction of a bytecode compiler along with a dedicated virtual machine [GL02]. This has been recently refined to evaluation by compilation to native code [BDG11]. However, another critical source of performance (or lack thereof) is the choice of data structures to represent the objects involved in the computation. The case of numbers is symptomatic: the traditional unary representation for natural numbers