scholarly journals FRed: Conditional Model Checking via Reducers and Folders

2020 ◽  
pp. 113-132
Author(s):  
Dirk Beyer ◽  
Marie-Christine Jakobs
Keyword(s):  
Model Checking ◽  
State Space ◽  
Systematic Investigation ◽  
The State ◽  
Trade Off ◽  
Conditional Model ◽  
Residual Program ◽  
Successful Solution ◽  
Verification Tools ◽  
Public Collection

Abstract There are many hard verification problems that are currently only solvable by applying several verifiers that are based on complementing technologies. Conditional model checking (CMC) is a successful solution for cooperation between verification tools. In CMC, the first verifier outputs a condition describing the state space that it successfully verified. The second verifier uses the condition to focus its verification on the unverified state space. To use arbitrary second verifiers, we recently proposed a reducer-based approach. One can use the reducer-based approach to construct a conditional verifier from a reducer and a (non-conditional) verifier: the reducer translates the condition into a residual program that describes the unverified state space and the verifier can be any off-the-shelf verifier (that does not need to understand conditions). Until now, only one reducer was available. But for a systematic investigation of the reducer concept, we need several reducers. To fill this gap, we developed FRed, a Framework for exploring different REDucers. Given an existing reducer, FRed allows us to derive various new reducers, which differ in their trade-off between size and precision of the residual program. For our experiments, we derived seven different reducers. Our evaluation on the largest and most diverse public collection of verification problems shows that we need all seven reducers to solve hard verification tasks that were not solvable before with the considered verifiers.

On Improving Model Checking of Time Petri Nets and Its Application to the Formal Verification

2021 ◽  
Vol 12 (4) ◽  
pp. 68-84
Author(s):  
Naima Jbeli ◽  
Zohra Sbai
Keyword(s):  
Model Checking ◽  
Petri Nets ◽  
Formal Verification ◽  
State Space ◽  
Order Reduction ◽  
The State ◽  
Timing Constraints ◽  
Time Petri Nets ◽  
Explicit Timing ◽  
Class Graph

Time Petri nets (TPN) are successfully used in the specification and analysis of distributed systems that involve explicit timing constraints. Especially, model checking TPN is a hopeful method for the formal verification of such complex systems. For this, it is promising to lean to the construction of an optimized version of the state space. The well-known methods of state space abstraction are SCG (state class graph) and ZBG (graph based on zones). For ZBG, a symbolic state represents the real evaluations of the clocks of the TPN; it is thus possible to directly check quantitative time properties. However, this method suffers from the state space explosion. To attenuate this problem, the authors propose in this paper to combine the ZBG approach with the partial order reduction technique based on stubborn set, leading thus to the proposal of a new state space abstraction called reduced zone-based graph (RZBG). The authors show via case studies the efficiency of the RZBG which is implemented and integrated within the 〖TPN-TCTL〗_h^∆ model checking in the model checker Romeo.

scholarly journals Sequential and Parallel Algorithms for the State Space Exploration

2016 ◽  
Vol 16 (1) ◽  
pp. 3-18 ◽  
Author(s):  
Lamia Allal ◽  
Ghalem Belalem ◽  
Philippe Dhaussy ◽  
Ciprian Teodorov
Keyword(s):  
Model Checking ◽  
Parallel Algorithms ◽  
State Space ◽  
Parallel Algorithm ◽  
Space Exploration ◽  
The State ◽  
State Space Exploration

Abstract In this article, we are interested in the exploration part of model checking which consists in traversing all the possible states of a system. We propose two approaches to exploration, parallel and sequential. We present a comparison between our parallel approach and the parallel algorithm proposed in SPIN.

scholarly journals Symbolic and Structural Model-Checking

2022 ◽  
Vol 183 (3-4) ◽  
pp. 319-342
Author(s):  
Yann Thierry-Mieg
Keyword(s):  
Model Checking ◽  
State Space ◽  
Structural Model ◽  
The State ◽  
Force Model ◽  
Deadlock Detection ◽  
Brute Force ◽  
General Applicability ◽  
State Space Explosion ◽  
Reachability Queries

Brute-force model-checking consists in exhaustive exploration of the state-space of a Petri net, and meets the dreaded state-space explosion problem. In contrast, this paper shows how to solve model-checking problems using a combination of techniques that stay in complexity proportional to the size of the net structure rather than to the state-space size. We combine an SMT based over-approximation to prove that some behaviors are unfeasible, an under-approximation using memory-less sampling of runs to find witness traces or counter-examples, and a set of structural reduction rules that can simplify both the system and the property. This approach was able to win by a clear margin the model-checking contest 2020 for reachability queries as well as deadlock detection, thus demonstrating the practical effectiveness and general applicability of the system of rules presented in this paper.

A FORMULA-DRIVEN MODULAR ATTACK ON STATE EXPLOSION

2002 ◽  
Vol 13 (05) ◽  
pp. 719-731
Author(s):  
Nicoletta De Francesco ◽  
Antonella Santone
Keyword(s):  
Distributed Systems ◽  
Model Checking ◽  
State Space ◽  
Composition Operator ◽  
The State ◽  
Parallel Composition ◽  
State Explosion ◽  
State Explosion Problem ◽  
Parallel Processes ◽  
Compositional Method

A common characteristic of the new distributed systems is the increasing complexity. Useful paradigms to cope with the complexity of systems are modularity and compositionality. In this paper we define a compositional method to attack the state explosion problem in model checking. The method, given a formula to be checked on a system composed of a set of parallel processes, allows syntactically reducing in a modular way the processes, in order to reduce the state space of their composition. The reduction is formula driven and is based on a notion of equivalence between processes, which is a congruence w.r.t. the parallel composition operator.

scholarly journals Fuzzy Genetic Algorithm Approach for Verification of Reachability and Detection of Deadlock in Graph Transformation Systems

2020 ◽  
Author(s):  
Nahid Salimi ◽  
Vahid Rafe ◽  
Hamed Tabrizchi ◽  
Amir Mosavi
Keyword(s):  
Genetic Algorithm ◽  
Model Checking ◽  
State Space ◽  
Hybrid Approach ◽  
The State ◽  
Suggested Approach ◽  
Safety Property ◽  
Fuzzy Genetic Algorithm ◽  
Fuzzy Genetic ◽  
Graph Transformation Systems

model checking techniques are often used for the verification of software systems. Such techniques are accompanied with several advantages. However, state space explosion is one of the drawbacks to model checking. During recent years, several methods have been proposed based on evolutionary and meta-heuristic algorithms to solve this problem. In this paper, a hybrid approach is presented to cope with the SSE problem in model checking of systems modeled by GTS with an ample state space. Most of existence proposed methods that aim to verify systems are applied to detect deadlocks by graph transformations. The proposed approach is based on the fuzzy genetic algorithm and is designed to decline the safety property by verifying the reachability property and detecting deadlocks. In this solution, the state space of the system is searched by a fuzzy genetic algorithm to find the state in which the specified property is refuted/verified. To implement and evaluate the suggested approach, GROOVE is used as a powerful designing and model checking toolset in GTS. The experimental results indicate that the presented hybrid fuzzy method improves speed and performance by comparing other techniques

scholarly journals Parallelizing random-walk based model checking

2015 ◽  
Vol 18 (3) ◽  
pp. 108-118
Author(s):  
Thang Hoai Bui
Keyword(s):  
Random Walk ◽  
Model Checking ◽  
State Space ◽  
Formal Methods ◽  
Great Improvement ◽  
The State ◽  
Systems Research ◽  
Random Walk Algorithm ◽  
Long Time ◽  
Walk Algorithm

In model checking, a formal methods technique to verify a system with some desired properties, the guidance techniques have been employed a long time ago in driving the verification into area of `error` in the state space. Another technique is to choose the next state to be explored in a walk randomly to avoid the `wrong` guidance. When the latter is a nonexhaustive technique in the sense that only a manageable number of walks are carried out before the search is terminated, it does scale well. In enhancing the technique to use recently powerful parallel/multi-core systems, research on parallelizing the algorithm shall be carried out. In this work, we propose a method that parallelizes the random-walk algorithm. It also increases the completeness of the non-exhaustive algorithm. The experimentation has shown the great improvement of the proposed algorithm compares to the original once.

Bounded Model Checking Algorithm to Reduce the State Space in Multi-Agent Systems

2014 ◽  
Vol 23 (11) ◽  
pp. 2835-2861
Author(s):  
Cong-Hua ZHOU ◽  
Meng YE ◽  
Chang-Da WANG ◽  
Zhi-Feng LIU
Keyword(s):  
Model Checking ◽  
State Space ◽  
Bounded Model Checking ◽  
The State ◽  
Multi Agent Systems ◽  
Agent Systems ◽  
Multi Agent

scholarly journals Partitioning Techniques in LTLf Synthesis

2019 ◽  
Author(s):  
Lucas Martinelli Tabajara ◽  
Moshe Y. Vardi
Keyword(s):  
Model Checking ◽  
State Space ◽  
Reactive Systems ◽  
Computational Thinking ◽  
Standard Technique ◽  
The State ◽  
Problem Instance ◽  
State Spaces ◽  
Fundamental Limitations ◽  
Depth Analysis

Decomposition is a general principle in computational thinking, aiming at decomposing a problem instance into easier subproblems. Indeed, decomposing a transition system into a partitioned transition relation was critical to scaling BDD-based model checking to large state spaces. Since then, it has become a standard technique for dealing with related problems, such as Boolean synthesis. More recently, partitioning has begun to be explored in the synthesis of reactive systems. LTLf synthesis, a finite-horizon version of reactive synthesis with applications in areas such as robotics, seems like a promising candidate for partitioning techniques. After all, the state of the art is based on a BDD-based symbolic algorithm similar to those from model checking, and partitioning could be a potential solution to the current bottleneck of this approach, which is the construction of the state space. In this work, however, we expose fundamental limitations of partitioning that hinder its effective application to symbolic LTLf synthesis. We not only provide evidence for this fact through an extensive experimental evaluation, but also perform an in-depth analysis to identify the reason for these results. We trace the issue to an overall increase in the size of the explored state space, caused by an inability of partitioning to fully exploit state-space minimization, which has a crucial effect on performance. We conclude that more specialized decomposition techniques are needed for LTLf synthesis which take into account the effects of minimization.

scholarly journals Efficient CSP Model Checking for Symbolic State-space Exploration with Application in Bacterial Chemo-Taxis Modelings

2020 ◽  
Author(s):  
Jing GUO
Keyword(s):  
Model Checking ◽  
State Space ◽  
Space Exploration ◽  
Bacterial Chemotaxis ◽  
The State ◽  
Decision Diagrams ◽  
Two Phases ◽  
Time Required ◽  
State Space Exploration ◽  
State Functions

Abstract Event locality is a class of theory that can clearly minimizes the memory and time required to store the state space. We present the multi-way decision diagrams to encode the next-state functions based on event locality and CSP’s stable failure. Instead of studying symbolic overall model, we apply the above thinking to the set of sub-models. Furthermore, we focus on saturation algorithms for CSP theory. And the algorithms consist of two phases, the universal process’s saturation checking and the single CSP symbol’s saturation checking. In the former case, the algorithms discuss better iteration strategy and recursive local fifix-point computations. In the latter case, the the single CSP symbol’s saturation checking calls the former algorithms, being combined preformed events and refusal events. Finally, we discuss bacterial chemotaxis modeled in CSP’s framework and saturation checking used to check the predefifined properties. The all algorithms are implemented in CSP tool FDR, the running results show that our algorithms often perform signifificantly faster than other conventional algorithms.

Sign in / Sign up

Export Citation Format

Share Document