RPP: Automatic Proof of Relational Properties by Self-Composition

Self-composition provides a powerful theoretical approach to prove relational properties, i.e. properties relating several program executions, that has been applied to compare two runs of one or similar programs (in secure dataflow properties, code transformations, etc.). This tool demo paper presents RPP, an original implementation of self-composition for specification and verification of relational properties in C programs in the FRAMA-C platform. We consider a very general notion of relational properties invoking any finite number of function calls of possibly dissimilar functions with possible nested calls. The new tool allows the user to specify a relational property, to prove it in a completely automatic way using classic deductive verification, and to use it as a hypothesis in the proof of other properties that may rely on it

JERBOA : un modeleur géométrique à base de règles

National audienceDans le cadre de la modélisation géométrique, chaque domaine d'application nécessite des logiciels spécifiques, appelés modeleurs. Leurs structures de données sont optimisées en fonction des objets manipulés, et leurs opérations de manipula- tion d'objets sont dédiées à l'application. Dans le cadre de la modélisation géomé- trique à base topologique, utilisant les cartes généralisées pour décrire la topologie, les objets géométriques sont représentés par une classe particulière de graphes. La structure topologique (volumes, faces, arêtes, sommets...) des objets est représen- tée par la structure du graphe, tandis que la géométrie ou toute autre information physique (couleur, forme, position...) sont portées par les nœuds du graphe. Nous avons proposé un langage à base de règles de transformations de graphes pour définir formellement les opérations géométriques. Notre noyau de modeleur est entièrement paramétrable par l'utilisateur (di- mension topologique des objets, nature des plongements, opérations géométriques). Il vérifie la préservation de la cohérence topologique et géométrique des objets. Cette vérification s'effectue statiquement, grâce à des conditions syntaxiques sur les règles définissant les opérations. Les objets sont construits interactivement par application des règles

Coq a dit : fromage tranché ne peut cacher ses trous *

International audienceLe slicing est une technique permettant d'extraire, à partir d'un programme donné, un programme plus petit, appelé tranche ou slice, tel que le programme et sa slice aient un comportement identique vis-à-vis d'un critère donné (appelé critère de slicing). Vérifier des slices de programme plutôt que le programme original est alléchant, mais cela nécessite des bases théoriques pour à la fois garantir la correction des résultats et permettre un slicing efficace. Ce travail apporte les justifications théoriques nécessaires pour vérifier une slice plutôt que le programme initial. Nous définissons une notion de slicing relaxé qui produit des slices de petite taille y compris en présence d'erreurs ou de non-terminaison, et prouvons un résultat de correction pour ce slicing, qui nous permet de faire la correspondance entre les différents cas de présence/absence d'erreurs dans la slice et dans le programme initial. Ces énoncés justifient l'application de la démarche de vérification sur les slices plutôt que sur les programmes originaux. Ce résumé étendu présente la formalisation de ce travail dans Coq

Input Output Symbolic Transition Systems Enriched by Program Calls and Contracts: a detailed example of vending machine

An Input Output Symbolic Transition System (IOSTS) specifies all expected sequences of input and output messages of a reactive system. Symbolic execution over this IOSTS then allows to generate a set of test cases that can exercise the various possible behaviors of the system it represents. In this paper, we extend the IOSTS framework with explicit program calls, possibly equipped with contracts specifying what the program is supposed to do. This approach bridges the gap between a model-based approach in which user-defined programs are abstracted away and a code-based approach in which small pieces of code are separately considered regardless of the way they are combined. First, we extend symbolic execution techniques for IOSTS with programs, in order to re-use classical test case generation algorithms. Second, we explore how constraints coming from IOSTS symbolic execution can be used to infer contracts for programs used in the IOSTS

Symbolic Path-guided Test Cases for Models with Data and Time

This paper focuses on generating test cases from timed symbolic transition systems. At the heart of the generation process are symbolic execution techniques on data and time. Test cases look like finite symbolic trees with verdicts on their leaves and are based on a user-specified finite symbolic path playing the role of a test purpose. Generated test cases handle data involved in time constraints and uninitialized parameters, leveraging the advantages of symbolic execution techniques

Certified Verification of Relational Properties

The use of function contracts to specify the behavior of functions often remains limited to the scope of a single function call. Relational properties link several function calls together within a single specification. They can express more advanced properties of a given function, such as non-interference, continuity, or monotonicity. They can also relate calls to different functions, for instance, to show that an optimized implementation is equivalent to its original counterpart. However, relational properties cannot be expressed and verified directly in the traditional setting of modular deductive verification. Self-composition has been proposed to overcome this limitation, but it requires complex transformations and additional separation hypotheses for real-life languages with pointers. We propose a novel approach that is not based on code transformation and avoids those drawbacks. It directly applies a verification condition generator to produce logical formulas that must be verified to ensure a given relational property. The approach has been fully formalized and proved sound in the Coq proof assistant

Actes des 14e journées sur les Approches Formelles dans l'Assistance au Développement de Logiciels

National audienceCet ouvrage présente les actes des 14èmes journées sur les Approches Formelles dans l'Assistance au Développement de Logiciels (AFADL'2015) qui se sont tenues à Bordeaux les 9 et 10 juin 2015

A Term-based Approach for Generating Finite Automata from Interaction Diagrams

Non-deterministic Finite Automata (NFA) represent regular languages concisely, increasing their appeal for applications such as word recognition. This paper proposes a new approach to generate NFA from an interaction language such as UML Sequence Diagrams or Message Sequence Charts. Via an operational semantics, we generate a NFA from a set of interactions reachable using the associated execution relation. In addition, by applying simplifications on reachable interactions to merge them, it is possible to obtain reduced NFA without relying on costly NFA reduction techniques. Experimental results regarding NFA generation and their application in trace analysis are also presented.Comment: 29 pages (15 pages paper, 3 pages references, 11 pages appendix) 9 figures in paper, 14 figures in appendi

A small-step approach to multi-trace checking against interactions

Interaction models describe the exchange of messages between the different components of distributed systems. We have previously defined a small-step operational semantics for interaction models. The paper extends this work by presenting an approach for checking the validity of multi-traces against interaction models. A multi-trace is a collection of traces (sequences of emissions and receptions), each representing a local view of the same global execution of the distributed system. We have formally proven our approach, studied its complexity, and implemented it in a prototype tool. Finally, we discuss some observability issues when testing distributed systems via the analysis of multi-traces.Comment: long version - 26 pages (23 for paper, 2 for bibliography, and a 1 page annex) - 15 figures (1 in annex

A formal denotation of complex systems: how to use algebraic refinement to deal with complexity of systems

Abstract A mathematical denotation is proposed for the notion of complex software systems whose behavior is specified by rigorous formalisms. Complex systems are described in a recursive way as an interconnection of sub-systems by means of architectural connectors. In order to consider the largest family of specification formalisms and architectural connectors, this denotation is essentially formalism, specification and connector-independent. For this, we build our denotation on Goguen's institution theory. We then denote in this abstract framework, system complexity by the notion of property emergence and give some conditions to establish when a system is or is not complex. Moreover, we define a refinement theory to deal with the complexity of systems in our generic framework. Indeed, one of the main problem encountered when dealing with complex system is the problem of emergent property detection. In this paper, we propose to use the algebraic refinement technics as a basic incremental method to simplify the emergent property detection. Finally, we illustrate our approach on the formalism classicaly used to specify biological processes: R. Thomas 's genetic regulatory networks (GRNs) over the temporal logic CTL and through the connector of sub-GRN embedding.