Alexis Marechal

High-Level Petri Net Model Checking with AlPiNA

Although model checking is heavily used in the hardware domain, it did not take off in software engineering yet. One of the possible reasons is that software models are very complex. They integrate many dimensions such as data types and concurrency, leading to the infamous state space explosion problem. This article introduces the Algebraic Petri Nets Analyzer (AlPiNA), a symbolic model checker for High-level Petri nets. It is comprised of two independent modules: a GUI plug-in for Eclipse and an underlying model checking engine. AlPiNA is a step towards performing efficient and user-friendly model checking of large software systems. This is achieved by separating the model and its properties from the optimisation artifacts. This article describes the features that AlPiNA provides to the user for designing models and verifying properties. It also presents the techniques and artifacts used for tuning verification performance, along with some theoretical background.

AlPiNA: a symbolic model checker

AlPiNA is a symbolic model checker for High Level Petri nets. It is comprised of two independent modules: a GUI plugin for Eclipse and an underlying model checking engine. AlPiNA’s objective is to perform efficient and user-friendly, easy to use model checking of large software systems. This is achieved by separating the model and its properties from the model checking-related concerns: the users can describe and perform checks on a high-level model without having to master low-level techniques. This article describes the features that AlPiNA provides to the user for specifying models and properties to validate, followed by the techniques that it implements for tuning validation performance.

AlPiNA: an algebraic petri net analyzer

AlPiNA is a graphical editor and model checker for a class of high-level Petri nets called Algebraic Petri Nets. Its main purpose is to perform reachability checks on complex models. It performs symbolic model checking based on ΣDD, an efficient evolution in the Decision Diagrams field, using novel techniques such as algebraic clustering and algebraic unfolding. AlPiNA offers a user-friendly interface, and is easily extensible.

Unifying the semantics of modular extensions of petri nets

Modularity is a mandatory principle to apply Petri nets to real world-sized systems. Modular extensions of Petri nets allow to create complex models by combining smaller entities. They facilitate the modeling and verification of large systems by applying a divide and conquer approach and promoting reuse. Modularity includes a wide range of notions such as encapsulation, hierarchy and instantiation. Over the years, Petri nets have been extended to include these mechanisms in many different ways. The heterogeneity of such extensions and their definitions makes it difficult to reason about their common features at a general level. We propose in this article an approach to standardize the semantics of modular Petri nets formalisms, with the objective of gathering even the most complex modular features from the literature. This is achieved with a new Petri nets formalism, called the LLAMAS Language for Advanced Modular Algebraic Nets (LLAMAS). We focus principally on the composition mechanism of LLAMAS, while introducing the rest of the language with an example. Our approach has two positive outcomes. First, the definition of new formalisms is facilitated, by providing common ground for the definition of their semantics. Second, it is possible to reason at a general level on the most advanced verification techniques, such as the recent advances in the domain of decision diagrams.

Generalizing the Compositions of Petri Nets Modules

Modularity is a mandatory principle to apply Petri nets to real world-sized systems. Modular extensions of Petri nets allow to create complex models by combining smaller entities. They facilitate the modeling and verification of large systems by applying a divide and conquer approach and promoting reuse. Modularity includes a wide range of notions such as encapsulation, hierarchy and instantiation. Over the years, Petri nets have been extended to include these mechanisms in many different ways. The heterogeneity of such extensions and their definitions makes it difficult to reason about their common features at a general level. We propose in this article an approach to standardize the semantics of modular Petri nets formalisms, with the objective of gathering even the most complex modular features from the literature. This is achieved with a new Petri nets formalism, called the LLAMAS Language for Advanced Modular Algebraic Nets LLAMAS. We focus principally on the composition mechanism of LLAMAS, while introducing the rest of the language with an example. The composition mechanism is introduced both informally and with formal definitions. Our approach has two positive outcomes. First, the definition of new formalisms is facilitated, by providing common ground for the definition of their semantics. Second, it is possible to reason at a general level on the most advanced verification techniques, such as the recent advances in the domain of decision diagrams.

A Domain Specific Language Approach for Genetic Regulatory Mechanisms Analysis

Systems biology and synthetic biology can be considered as model-driven methodologies. In this context, models are used to discover emergent properties arising from the complex interactions between components. Most available tools propose simulation frameworks to study models of biological systems. Simulation only explores a limited number of behaviors of these models. This may lead to a biased view of the system. On the contrary, model checking explores all the possible behaviors. The use of model checking in the domain of life sciences is limited. It suffers from the complexity of modeling languages designed by and for computer scientists. This article describes an approach based on Domain Specific Languages. It provides a comprehensible, yet formal, language called GReg to describe genetic regulatory mechanisms and their properties, and to apply powerful model checking techniques on them. GReg’s objective is to shelter the user from the complexity of those underlying techniques.

Experience-based model refinement

The resilience of a software system can be guaranteed, among other techniques, by model checking. In that setting, it consists in exploring every execution of the system to detect violations of resilience properties. One approach is to automatically transform the program into a model. To harness the system complexity and the state space explosion, designers usually abstract details of the studied system. However, abstracting too many details may dramatically impact the validity of the model checking. This includes details about the execution environment on which resilience properties are often based. This article sketches an iterative methodology to verify and refine the transformation. We introduce the concept of witness programs to reveal a set of behaviors that the transformation must preserve.