15,334 research outputs found
Compositional reasoning for shared-variable concurrent programs
Scalable and automatic formal verification for concurrent systems is always
demanding. In this paper, we propose a verification framework to support
automated compositional reasoning for concurrent programs with shared
variables. Our framework models concurrent programs as succinct automata and
supports the verification of multiple important properties. Safety verification
and simulations of succinct automata are parallel compositional, and safety
properties of succinct automata are preserved under refinements. We generate
succinct automata from infinite state concurrent programs in an automated
manner. Furthermore, we propose the first automated approach to checking
rely-guarantee based simulations between infinite state concurrent programs. We
have prototyped our algorithms and applied our tool to the verification of
multiple refinements
Model checking infinite-state systems in CLP
The verification of safety and liveness properties for infinite-state systems is an important research problem. Can the well-established concepts and the existing technology for programming over constraints as first-class data structures contribute to this research? The work reported in this paper is a starting point for the experimental evaluation of constraint logic programming as a conceptual basis and practical implementation platform for model checking. We have implemented an automated verification method in CLP using real and boolean constraints. We have used the method on a number of infinite-state systems that model concurrent programs using integers or buffers. The basis of the correctness of our implementation is a formal connection between CLP programs and the formalism used for specifying concurrent systems
Automated verification of reactive and concurrent programs by calculation
Reactive programs combine traditional sequential programming constructs with primitives to allow communication with other concurrent agents. They are ubiquitous in modern applications, ranging from components systems and web services, to cyber-physical systems and autonomous robots. In this paper, we present an algebraic verification strategy for concurrent reactive programs, with a large or infinite state space. We define novel operators to characterise interactions and state updates, and an associated equational theory. With this we can calculate a reactive program's denotational semantics, and thereby facilitate automated proof. Of note is our reasoning support for iterative programs with reactive invariants, based on Kleene algebra, and for parallel composition. We illustrate our strategy by verifying a reactive buffer. Our laws and strategy are mechanised in Isabelle/UTP, our implementation of Hoare and He's Unifying Theories of Programming (UTP) framework, to provide soundness guarantees and practical verification support
Automatic Verification of Concurrent Stochastic Systems
Automated verification techniques for stochastic games allow formal reasoning
about systems that feature competitive or collaborative behaviour among
rational agents in uncertain or probabilistic settings. Existing tools and
techniques focus on turn-based games, where each state of the game is
controlled by a single player, and on zero-sum properties, where two players or
coalitions have directly opposing objectives. In this paper, we present
automated verification techniques for concurrent stochastic games (CSGs), which
provide a more natural model of concurrent decision making and interaction. We
also consider (social welfare) Nash equilibria, to formally identify scenarios
where two players or coalitions with distinct goals can collaborate to optimise
their joint performance. We propose an extension of the temporal logic rPATL
for specifying quantitative properties in this setting and present
corresponding algorithms for verification and strategy synthesis for a variant
of stopping games. For finite-horizon properties the computation is exact,
while for infinite-horizon it is approximate using value iteration. For
zero-sum properties it requires solving matrix games via linear programming,
and for equilibria-based properties we find social welfare or social cost Nash
equilibria of bimatrix games via the method of labelled polytopes through an
SMT encoding. We implement this approach in PRISM-games, which required
extending the tool's modelling language for CSGs, and apply it to case studies
from domains including robotics, computer security and computer networks,
explicitly demonstrating the benefits of both CSGs and equilibria-based
properties
Abstraction and Learning for Infinite-State Compositional Verification
Despite many advances that enable the application of model checking
techniques to the verification of large systems, the state-explosion problem
remains the main challenge for scalability. Compositional verification
addresses this challenge by decomposing the verification of a large system into
the verification of its components. Recent techniques use learning-based
approaches to automate compositional verification based on the assume-guarantee
style reasoning. However, these techniques are only applicable to finite-state
systems. In this work, we propose a new framework that interleaves abstraction
and learning to perform automated compositional verification of infinite-state
systems. We also discuss the role of learning and abstraction in the related
context of interface generation for infinite-state components.Comment: In Proceedings Festschrift for Dave Schmidt, arXiv:1309.455
Verifying Concurrent Stacks by Divergence-Sensitive Bisimulation
The verification of linearizability -- a key correctness criterion for
concurrent objects -- is based on trace refinement whose checking is
PSPACE-complete. This paper suggests to use \emph{branching} bisimulation
instead. Our approach is based on comparing an abstract specification in which
object methods are executed atomically to a real object program. Exploiting
divergence sensitivity, this also applies to progress properties such as
lock-freedom. These results enable the use of \emph{polynomial-time}
divergence-sensitive branching bisimulation checking techniques for verifying
linearizability and progress. We conducted the experiment on concurrent
lock-free stacks to validate the efficiency and effectiveness of our methods
Towards efficient verification of systems with dynamic process creation
Modelling and analysis of dynamic multi-threaded state systems often encounters obstacles when one wants to use automated verification methods, such as model checking. Our aim in this paper is to develop a technical device for coping with one such obstacle, namely that caused by dynamic process creation. We first introduce a general class of coloured Petri nets-not tied to any particular syntax or approach-allowing one to capture systems with dynamic (and concurrent) process creation as well as capable of manipulating data. Following this, we introduce the central notion of our method which is a marking equivalence that can be efficiently computed and then used, for instance, to aggregate markings in a reachability graph. In some situations, such an aggregation may produce a finite representation of an infinite state system which still allows one to establish the relevant behavioural properties. We show feasibility of the method on an example and provide initial experimental results
Searching for a Solution to Program Verification=Equation Solving in CCS
International audienceUnder non-exponential discounting, we develop a dynamic theory for stopping problems in continuous time. Our framework covers discount functions that induce decreasing impatience. Due to the inherent time inconsistency, we look for equilibrium stopping policies, formulated as fixed points of an operator. Under appropriate conditions, fixed-point iterations converge to equilibrium stopping policies. This iterative approach corresponds to the hierarchy of strategic reasoning in game theory and provides “agent-specific” results: it assigns one specific equilibrium stopping policy to each agent according to her initial behavior. In particular, it leads to a precise mathematical connection between the naive behavior and the sophisticated one. Our theory is illustrated in a real options model
- …