Mechanized semantics - with applications to program proof and compiler verification

  title={Mechanized semantics - with applications to program proof and compiler verification},
  author={Xavier Leroy},
  booktitle={Logics and Languages for Reliability and Security},
  • X. Leroy
  • Published in
    Logics and Languages for…
    26 October 2010
  • Computer Science
syntax Inductive expr : Type := | Evar: ident -> expr | Econst: Z -> expr | Eadd: expr -> expr -> expr | Esub: expr -> expr -> expr. Inductive bool_expr : Type := | Bequal: expr -> expr -> bool_expr | Bless: expr -> expr -> bool_expr. Inductive cmd : Type := | Cskip: cmd | Cassign: ident -> expr -> cmd | Cseq: cmd -> cmd -> cmd | Cifthenelse: bool_expr -> cmd -> cmd -> cmd | Cwhile: bool_expr -> cmd -> cmd. X. Leroy (INRIA) Mechanized semantics Marktoberdorf 2009 29 / 173 

Figures from this paper

Lightweight Proof by Reflection Using a Posteriori Simulation of Effectful Computation

This work proposes a novel technique for proof-by-reflection that marries, in Type Theory, an effectful language with (partial) proofs of correctness and uses simulable monads.

Theoretical and Practical Aspects of Linking Operational and Algebraic Semantics for MDESL

The approach is a novel way to formalize and verify the correctness and equivalence of different semantics for MDESL in both a theoretical approach and a practical approach.

Certifying cost annotations in compilers

This formal study suggests that the labelling approach has good compositionality and scalability properties and reports the successful experience in implementing and testing thelabelling approach on top of a prototype compiler written in OCAML for (a large fragment of) the C language.

A Certified Denotational Abstract Interpreter

This paper shows how to program and prove correct in Coq an abstract interpreter that uses iteration strategies based on program syntax and allows us to decompose the soundness proof in an elegant manner.

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

A compiler that translates programs from an imperative higher-order language into a sequence of instructions for an abstract machine and shows that the compiler is correct with respect to the big-step semantics of the language, both for convergent and divergent programs.

Certifying and Reasoning on Cost Annotations in C Programs

A proof methodology is presented that extends standard simulation proofs of compiler correctness to ensure that the cost annotations on the source code are sound and precise with respect to an execution cost model of the object code.

Operational methods in semantics

These lecture notes contain a selection of the material taught by the author over several years in courses on the semantics of programming languages, foundations of programming, compilation, and concurrency theory to provide a compact reference for grasping the basic ideas of a rapidly evolving field.

19th International Conference on Types for Proofs and Programs, TYPES 2013, April 22-26, 2013, Toulouse, France

This work introduces update monads as a generalization of state monads, the compatible compositions of reader and writer monads given by a set and a monoid.

Towards Substructural Property-Based Testing

This work takes the first step by implementing a property-based testing system for specifications written in the linear logic programming language Lolli and employs the foundational proof certificates architecture to model various data generation strategies.



Oracle Semantics for Concurrent Separation Logic

This work defines a modular operational semantics for Concurrent C minor--a language with shared memory, spawnable threads, and first-class locks, and proves its soundness with respect to the operational semantics and proved the sequential C.S.L. rules (those inherited from sequential Separation Logic) simply by adapting Appel & Blazy's machine-checked soundness proofs.

On the Relationship Between Concurrent Separation Logic and Assume-Guarantee Reasoning

This work shows that CSL (adapted for the low-level language) can be viewed as a specialization of the extended A-G logic by enforcing the invariant that "shared resources are well-formed outside of critical regions".

Separation Logic for Small-Step cminor

This paper gives a small-step semantics (instead of the big-step of the proved-correct compiler) that is motivated by the need to support future concurrent extensions of Cminor, and detail a machine-checked proof of soundness of the authors' Separation Logic.

A machine-checked model for a Java-like language, virtual machine, and compiler

Jinja is a compromise between the realism of the language and the tractability and clarity of its formal semantics, and provides a unified model of the source language, the virtual machine, and the compiler.

Verified Software Toolchain - (Invited Talk)

The Verified Software Toolchain verifies with machine-checked proofs that the assertions claimed at the top of the toolchain really hold in the machine-language program, running in the operating-system context, on a weakly-consistent-shared-memory machine.

Theorem proving support in programming language semantics

We describe several views of the semantics of a simple programming language as formal documents in the calculus of inductive constructions that can be verified by the Coq proof system. Covered

Types and programming languages

This text provides a comprehensive introduction both to type systems in computer science and to the basic theory of programming languages, with a variety of approaches to modeling the features of object-oriented languages.

Mechanized Metatheory for the Masses: The PoplMark Challenge

An initial set of benchmarks for measuring progress in this area of programming languages are proposed, based on the metatheory of System F<:, a typed lambda-calculus with second-order polymorphism, subtyping, and records.

Foundational proof-carrying code

  • A. Appel
  • Computer Science
    Proceedings 16th Annual IEEE Symposium on Logic in Computer Science
  • 2001
This paper describes many of the mathematical and engineering problems to be solved in the construction of a foundational proof-carrying code system, using the simplest possible verifier and the smallest possible runtime system.

A Syntactic Approach to Type Soundness

A new approach to proving type soundness for Hindley/Milner-style polymorphic type systems by an adaptation of subject reduction theorems from combinatory logic to programming languages and the use of rewriting techniques for the specification of the language semantics is presented.