Results 1  10
of
10
Algebraic Simulations
"... Rewriting logic is a flexible and general logic to specify concurrent systems. To prove properties about concurrent systems in temporal logic, it is very useful to use simulations that relate the transitions and atomic predicates of a system to those of a potentially much simpler one; then, if the s ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
(Show Context)
Rewriting logic is a flexible and general logic to specify concurrent systems. To prove properties about concurrent systems in temporal logic, it is very useful to use simulations that relate the transitions and atomic predicates of a system to those of a potentially much simpler one; then, if the simpler system satisfies a property ϕ in a suitable temporal logic we are guaranteed that the more complex system does too. In this paper, the suitability of rewriting logic as a formal framework not only to specify concurrent systems but also to specify simulations is explored in depth. For this, increasingly more general notions of simulation (allowing stuttering) are first defined for Kripke structures, and suitable temporal logics allowing properties to be reflected back by such simulations are characterized. The paper then proves various representability results à la Bergstra and Tucker, showing that recursive Kripke structures and recursive simulation maps (resp. r.e. simulation relations) can always be specified in a finitary way in rewriting logic. Using simulations typically requires both model checking and theorem proving, since their correctness requires discharging proof obligations. In this regard, rewriting logic, by containing equational logic as a sublogic and having equationallybased inductive theorem proving at its disposal, is shown to be particularly wellsuited for verifying the correctness of simulations.
Automatic abstraction refinement for Petri nets verification
 IN: PROCEEDINGS OF THE 10TH IEEE INTERNATIONAL HIGHLEVEL DESIGN VALIDATION AND TEST WORKSHOP
, 2005
"... Model Checking has emerged as a promising and powerful approach to analyze Petri nets automatically, but a main challenge is the state explosion problem. To obtain an efficient state space, we implement a series of formalisms based on Petri nets to achieve automatically predicate abstraction and r ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Model Checking has emerged as a promising and powerful approach to analyze Petri nets automatically, but a main challenge is the state explosion problem. To obtain an efficient state space, we implement a series of formalisms based on Petri nets to achieve automatically predicate abstraction and refinement via new predicate discovery. However, the complicated predicates would slow down the abstraction refinement process. A novel feature of our approach is minimizing the support of predicates, via diagnosing the failure reasons of transitions and projecting places on predicates to eliminate the dumb variables. In addition, a demonstrative example shows that our techniques could work efficiently on Petri nets.
On enabling dataaware compliance checking . . .
"... In the light of an increasing demand on business process compliance, the verification of process models against compliance rules has become essential in enterprise computing. To be broadly applicable compliance checking has to support dataaware compliance rules as well as to consider data conditio ..."
Abstract
 Add to MetaCart
In the light of an increasing demand on business process compliance, the verification of process models against compliance rules has become essential in enterprise computing. To be broadly applicable compliance checking has to support dataaware compliance rules as well as to consider data conditions within a process model. Independently of the actual technique applied to accomplish compliance checking, dataawareness means that in addition to the control flow dimension, the data dimension has to be explored during compliance checking. However, naive exploration of the data dimension can lead to state explosion. We address this issue by introducing an abstraction approach in this paper. We show how state explosion can be avoided by conducting compliance checking for an abstract process model and abstract compliance rules. Our abstraction approach can serve as preprocessing step to the actual compliance checking and provides the basis for more efficient application of existing compliance checking algorithms.
Abstraction Techniques for Extracted Automata Models
"... Abstract — In this paper we present the application of abstraction techniques for automata models. We give an overview on a stateoftheart method to reduce the complexity of an automaton model without loosing essential information on the behavior of the modeled system (predicate abstraction). We f ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract — In this paper we present the application of abstraction techniques for automata models. We give an overview on a stateoftheart method to reduce the complexity of an automaton model without loosing essential information on the behavior of the modeled system (predicate abstraction). We focus on the applicability of the presented methods, especially on models that are directly extracted from the C source code of a system. We present the process for automated model extraction that yields an automaton model we can use for a verification and testing framework. We show how to apply different abstraction techniques on a case study from the automotive domain and evaluate the resulting state space reduction.
Counter Abstraction in the CSP/FDR setting Abstract
"... In this paper we consider an adaptation of counter abstraction for the CSP/FDR setting. The technique allows us to transform a concurrent system with an unbounded number of agents into a finitestate abstraction. The systems to which the method can be applied are composed of many identical node proc ..."
Abstract
 Add to MetaCart
In this paper we consider an adaptation of counter abstraction for the CSP/FDR setting. The technique allows us to transform a concurrent system with an unbounded number of agents into a finitestate abstraction. The systems to which the method can be applied are composed of many identical node processes that run in parallel with a controller process. Refinement checks on the abstract state machine can be performed automatically in the traces and stable failures models using the model checker FDR. We illustrate the method on an example based on a multiprocessor operating system. Keywords: Counter abstraction, model checking, parameterised verification, CSP. 1
Verification of Infinite State Mutual Exclusion Protocols
"... Abstract — In this work we present formal verification of two infinite state mutual exclusion protocols. Infinite state systems cannot be verified by automatic algorithmic verification techniques such as model checking. On the other hand, deductive verification can be used in infinite state verifica ..."
Abstract
 Add to MetaCart
Abstract — In this work we present formal verification of two infinite state mutual exclusion protocols. Infinite state systems cannot be verified by automatic algorithmic verification techniques such as model checking. On the other hand, deductive verification can be used in infinite state verification, but it is time consuming and requires considerable expertise. We combine algorithmic and deductive verification using the abstract interpretation framework. A methodology from that framework called predicate abstraction allows us to reduce infinite state systems to finite state using decision procedures. The obtained finite state system can be model checked against restricted class of temporal logic formulas. That restricted class is expressive enough for specification of the safety properties, and can be verified with NuSMV tool. I.
A predicate abstraction tool for Maude
"... Rewriting logic [7], through its executable Maude implementation [2], has proved to be a very flexible framework for the specification of concurrent systems. Designing such systems is hard and errorprone and thus studying whether the final design indeed satisfies the expected properties becomes an ..."
Abstract
 Add to MetaCart
(Show Context)
Rewriting logic [7], through its executable Maude implementation [2], has proved to be a very flexible framework for the specification of concurrent systems. Designing such systems is hard and errorprone and thus studying whether the final design indeed satisfies the expected properties becomes an unavoidable task.
CoAdviser c © Copyright by
, 2012
"... Proper functionality is a necessity for systems used in safetycritical applications; consequently, software in these systems is often subject to rigorous validation and formal verification that aims at ensuring expected behavior. To aid in the design of these systems, several synchronous programmi ..."
Abstract
 Add to MetaCart
(Show Context)
Proper functionality is a necessity for systems used in safetycritical applications; consequently, software in these systems is often subject to rigorous validation and formal verification that aims at ensuring expected behavior. To aid in the design of these systems, several synchronous programming languages exist for describing deterministic system models suitable for formal verification and validation. Examples of such synchronous languages include SIGNAL, Lustre, MRICDF, and Esterel. Common application domains for synchronous programs include avionics, automotive control, process control, and defense systems. In many cases, rigorous formal verification of these systems is unfeasible because the methods, such as theorem proving and model checking, are too expensive. A theorem proving approach requires a great deal of user involvement and expertise, and a model checking approach may not be feasible on systems of substantial complexity due to computation constraints. This thesis presents the design, implementation, and evaluation of SAGA, a prototype tool for the automated validation of synchronous reactive embedded systems. SAGA shifts
Predicate Abstraction in Protocol Verification
, 2005
"... This paper presents how predicate abstraction can be applied to protocol verification. Predicate abstraction is a method for automatic construction of abstract state graph. Basic idea is to use n predicates 1, ..., n defined on concrete state space to generate abstract state graph. Model checking ..."
Abstract
 Add to MetaCart
This paper presents how predicate abstraction can be applied to protocol verification. Predicate abstraction is a method for automatic construction of abstract state graph. Basic idea is to use n predicates 1, ..., n defined on concrete state space to generate abstract state graph. Model checking is a formal verification technique which has been successfully applied to protocol verification. But model checking can only be applied to finite state systems. Many interesting systems are innite state or number of states is so large that verification becomes infeasible. Predicate abstraction can be applied in verification of infinite state systems (or large finite state systems). Abstract state graph created by predicate abstraction can be used for verification of safety properties using a model checker. We provide simple examples of protocol verification using predicate abstraction.