68 research outputs found
Analyzing Timed Systems Using Tree Automata
Timed systems, such as timed automata, are usually analyzed using their
operational semantics on timed words. The classical region abstraction for
timed automata reduces them to (untimed) finite state automata with the same
time-abstract properties, such as state reachability. We propose a new
technique to analyze such timed systems using finite tree automata instead of
finite word automata. The main idea is to consider timed behaviors as graphs
with matching edges capturing timing constraints. When a family of graphs has
bounded tree-width, they can be interpreted in trees and MSO-definable
properties of such graphs can be checked using tree automata. The technique is
quite general and applies to many timed systems. In this paper, as an example,
we develop the technique on timed pushdown systems, which have recently
received considerable attention. Further, we also demonstrate how we can use it
on timed automata and timed multi-stack pushdown systems (with boundedness
restrictions)
Analyzing Timed Systems Using Tree Automata
Timed systems, such as timed automata, are usually analyzed using their operational semantics on timed words. The classical region abstraction for timed automata reduces them to (untimed) finite state automata with the same time-abstract properties, such as state reachability. We propose a new technique to analyze such timed systems using finite tree automata instead of finite word automata. The main idea is to consider timed behaviors as graphs with matching edges capturing timing constraints. Such graphs can be interpreted in trees opening the way to tree automata based techniques which are more powerful than analysis based on word automata. The technique is quite general and applies to many timed systems. In this paper, as an example, we develop the technique on timed pushdown systems, which have recently received considerable attention. Further, we also demonstrate how we can use it on timed automata and timed multi-stack pushdown systems (with boundedness restrictions)
Verifying Communicating Multi-pushdown Systems
International audienceCommunicating multi-pushdown systems model networks of multi-threaded recursive programs communicating via reliable FIFO channels. Hence their verification problems are undecidable in general. The behaviours of these systems can be represented as directed graphs, which subsume both Message Sequence Charts and nested words. We extend the notion of split-width to these graphs, defining a simple algebra to compose/decompose these behaviours using two natural operations: shuffle and merge. We obtain simple, uniform and optimal decision procedures for various verification problems parametrized by split-width, ranging from reachability to model-checking against MSO, PDL and Temporal Logics
Data Multi-Pushdown Automata
We extend the classical model of multi-pushdown systems by considering systems that operate on a finite set of variables ranging over natural numbers. The conditions on variables are defined via gap-order constraints that allow to compare variables for equality, or to check that the gap between the values of two variables exceeds a given natural number. Furthermore, each message inside a stack is equipped with a data item representing its value. When a message is pushed to the stack, its value may be defined by a variable. When a message is popped, its value may be copied to a variable. Thus, we obtain a system that is infinite in multiple dimensions, namely we have a number of stacks that may contain an unbounded number of messages each of which is equipped with a natural number.
It is well-known that the verification of any non-trivial property of multi-pushdown systems is undecidable, even for two stacks and for a finite data-domain. In this paper, we show the decidability of the reachability problem for the classes of data multi-pushdown system that admit a bounded split-width (or equivalently a bounded tree-width). As an immediate consequence, we obtain decidability for several subclasses of data multi-pushdown systems. These include systems with single stacks, restricted ordering policies on stack operations, bounded scope, bounded phase, and bounded context switches
Model Checking Synchronized Products of Infinite Transition Systems
Formal verification using the model checking paradigm has to deal with two
aspects: The system models are structured, often as products of components, and
the specification logic has to be expressive enough to allow the formalization
of reachability properties. The present paper is a study on what can be
achieved for infinite transition systems under these premises. As models we
consider products of infinite transition systems with different synchronization
constraints. We introduce finitely synchronized transition systems, i.e.
product systems which contain only finitely many (parameterized) synchronized
transitions, and show that the decidability of FO(R), first-order logic
extended by reachability predicates, of the product system can be reduced to
the decidability of FO(R) of the components. This result is optimal in the
following sense: (1) If we allow semifinite synchronization, i.e. just in one
component infinitely many transitions are synchronized, the FO(R)-theory of the
product system is in general undecidable. (2) We cannot extend the expressive
power of the logic under consideration. Already a weak extension of first-order
logic with transitive closure, where we restrict the transitive closure
operators to arity one and nesting depth two, is undecidable for an
asynchronous (and hence finitely synchronized) product, namely for the infinite
grid.Comment: 18 page
Analyzing Timed Systems Using Tree Automata
International audienceTimed systems, such as timed automata, are usually analyzed using their operational semantics on timed words. The classical region abstraction for timed automata reduces them to (untimed) finite state automata with the same time-abstract properties, such as state reachability. We propose a new technique to analyze such timed systems using finite tree automata instead of finite word automata. The main idea is to consider timed behaviors as graphs with matching edges capturing timing constraints. Such graphs can be interpreted in trees opening the way to tree automata based techniques which are more powerful than analysis based on word automata. The technique is quite general and applies to many timed systems. In this paper, as an example, we develop the technique on timed pushdown systems, which have recently received considerable attention. Further, we also demonstrate how we can use it on timed automata and timed multi- stack pushdown systems (with boundedness restrictions)
Controllers for the Verification of Communicating Multi-Pushdown Systems
International audienceMulti-pushdowns communicating via queues are formal models of multi-threaded programs communicating via channels. They are turing powerful and much of the work on their verification has focussed on under-approximation techniques. Any error detected in the under-approximation implies an error in the system. However the successful verification of the under-approximation is not as useful if the system exhibits unverified behaviours. Our aim is to design controllers that observe/restrict the system so that it stays within the verified under-approximation. We identify some important properties that a good con- troller should satisfy. We consider an extensive under-approximation class, construct a distributed controller with the desired properties and also establish the decidability of verification problems for this class
Revisiting Underapproximate Reachability for Multipushdown Systems
Boolean programs with multiple recursive threads can be captured as pushdown
automata with multiple stacks. This model is Turing complete, and hence, one is
often interested in analyzing a restricted class that still captures useful
behaviors. In this paper, we propose a new class of bounded under
approximations for multi-pushdown systems, which subsumes most existing
classes. We develop an efficient algorithm for solving the under-approximate
reachability problem, which is based on efficient fix-point computations. We
implement it in our tool BHIM and illustrate its applicability by generating a
set of relevant benchmarks and examining its performance. As an additional
takeaway, BHIM solves the binary reachability problem in pushdown automata. To
show the versatility of our approach, we then extend our algorithm to the timed
setting and provide the first implementation that can handle timed
multi-pushdown automata with closed guards.Comment: 52 pages, Conference TACAS 202
- …