55 research outputs found
Reachability in Continuous Pushdown VASS
Pushdown Vector Addition Systems with States (PVASS) consist of finitely many
control states, a pushdown stack, and a set of counters that can be incremented
and decremented, but not tested for zero. Whether the reachability problem is
decidable for PVASS is a long-standing open problem.
We consider continuous PVASS, which are PVASS with a continuous semantics.
This means, the counter values are rational numbers and whenever a vector is
added to the current counter values, this vector is first scaled with an
arbitrarily chosen rational factor between zero and one. We show that
reachability in continuous PVASS is NEXPTIME-complete. Our result is unusually
robust: Reachability can be decided in NEXPTIME even if all numbers are
specified in binary. On the other hand, NEXPTIME-hardness already holds for
coverability, in fixed dimension, for bounded stack, and even if all numbers
are specified in unary
On Functions Weakly Computable by Pushdown Petri Nets and Related Systems
We consider numerical functions weakly computable by grammar-controlled
vector addition systems (GVASes, a variant of pushdown Petri nets). GVASes can
weakly compute all fast growing functions for
, hence they are computationally more powerful than
standard vector addition systems. On the other hand they cannot weakly compute
the inverses or indeed any sublinear function. The proof relies
on a pumping lemma for runs of GVASes that is of independent interest
What makes petri nets harder to verify : stack or data?, Concurrency, security, and puzzles : Festschrift for A.W. Roscoe on the occasion of his 60th birthday
We show how the yardstick construction of Stockmeyer, also developed as counter bootstrapping by Lipton, can be adapted and extended to obtain new lower bounds for the coverability problem for two prominent classes of systems based on Petri nets: Ackermann-hardness for unordered data Petri nets, and Tower-hardness for pushdown vector addition systems
Decidable Models of Recursive Asynchronous Concurrency
Asynchronously communicating pushdown systems (ACPS) that satisfy the
empty-stack constraint (a pushdown process may receive only when its stack is
empty) are a popular decidable model for recursive programs with asynchronous
atomic procedure calls. We study a relaxation of the empty-stack constraint for
ACPS that permits concurrency and communication actions at any stack height,
called the shaped stack constraint, thus enabling a larger class of concurrent
programs to be modelled. We establish a close connection between ACPS with
shaped stacks and a novel extension of Petri nets: Nets with Nested Coloured
Tokens (NNCTs). Tokens in NNCTs are of two types: simple and complex. Complex
tokens carry an arbitrary number of coloured tokens. The rules of NNCT can
synchronise complex and simple tokens, inject coloured tokens into a complex
token, and eject all tokens of a specified set of colours to predefined places.
We show that the coverability problem for NNCTs is Tower-complete. To our
knowledge, NNCT is the first extension of Petri nets, in the class of nets with
an infinite set of token types, that has primitive recursive coverability. This
result implies Tower-completeness of coverability for ACPS with shaped stacks
Monus Semantics in Vector Addition Systems with States
Vector addition systems with states (VASS) are a popular model for concurrent systems. However, many decision problems have prohibitively high complexity. Therefore, it is sometimes useful to consider overapproximating semantics in which these problems can be decided more efficiently.
We study an overapproximation, called monus semantics, that slightly relaxes the semantics of decrements: A key property of a vector addition systems is that in order to decrement a counter, this counter must have a positive value. In contrast, our semantics allows decrements of zero-valued counters: If such a transition is executed, the counter just remains zero.
It turns out that if only a subset of transitions is used with monus semantics (and the others with classical semantics), then reachability is undecidable. However, we show that if monus semantics is used throughout, reachability remains decidable. In particular, we show that reachability for VASS with monus semantics is as hard as that of classical VASS (i.e. Ackermann-hard), while the zero-reachability and coverability are easier (i.e. EXPSPACE-complete and NP-complete, respectively). We provide a comprehensive account of the complexity of the general reachability problem, reachability of zero configurations, and coverability under monus semantics. We study these problems in general VASS, two-dimensional VASS, and one-dimensional VASS, with unary and binary counter updates
Monus semantics in vector addition systems with states
Vector addition systems with states (VASS) are a popular model for concurrent
systems. However, many decision problems have prohibitively high complexity.
Therefore, it is sometimes useful to consider overapproximating semantics in
which these problems can be decided more efficiently.
We study an overapproximation, called monus semantics, that slightly relaxes
the semantics of decrements: A key property of a vector addition systems is
that in order to decrement a counter, this counter must have a positive value.
In contrast, our semantics allows decrements of zero-valued counters: If such a
transition is executed, the counter just remains zero.
It turns out that if only a subset of transitions is used with monus
semantics (and the others with classical semantics), then reachability is
undecidable. However, we show that if monus semantics is used throughout,
reachability remains decidable. In particular, we show that reachability for
VASS with monus semantics is as hard as that of classical VASS (i.e.
Ackermann-hard), while the zero-reachability and coverability are easier (i.e.
EXPSPACE-complete and NP-complete, respectively). We provide a comprehensive
account of the complexity of the general reachability problem, reachability of
zero configurations, and coverability under monus semantics. We study these
problems in general VASS, two-dimensional VASS, and one-dimensional VASS, with
unary and binary counter updates
Context-Bounded Analysis For Concurrent Programs With Dynamic Creation of Threads
Context-bounded analysis has been shown to be both efficient and effective at
finding bugs in concurrent programs. According to its original definition,
context-bounded analysis explores all behaviors of a concurrent program up to
some fixed number of context switches between threads. This definition is
inadequate for programs that create threads dynamically because bounding the
number of context switches in a computation also bounds the number of threads
involved in the computation. In this paper, we propose a more general
definition of context-bounded analysis useful for programs with dynamic thread
creation. The idea is to bound the number of context switches for each thread
instead of bounding the number of switches of all threads. We consider several
variants based on this new definition, and we establish decidability and
complexity results for the analysis induced by them
Algorithmic Verification of Asynchronous Programs
Asynchronous programming is a ubiquitous systems programming idiom to manage
concurrent interactions with the environment. In this style, instead of waiting
for time-consuming operations to complete, the programmer makes a non-blocking
call to the operation and posts a callback task to a task buffer that is
executed later when the time-consuming operation completes. A co-operative
scheduler mediates the interaction by picking and executing callback tasks from
the task buffer to completion (and these callbacks can post further callbacks
to be executed later). Writing correct asynchronous programs is hard because
the use of callbacks, while efficient, obscures program control flow.
We provide a formal model underlying asynchronous programs and study
verification problems for this model. We show that the safety verification
problem for finite-data asynchronous programs is expspace-complete. We show
that liveness verification for finite-data asynchronous programs is decidable
and polynomial-time equivalent to Petri Net reachability. Decidability is not
obvious, since even if the data is finite-state, asynchronous programs
constitute infinite-state transition systems: both the program stack and the
task buffer of pending asynchronous calls can be potentially unbounded.
Our main technical construction is a polynomial-time semantics-preserving
reduction from asynchronous programs to Petri Nets and conversely. The
reduction allows the use of algorithmic techniques on Petri Nets to the
verification of asynchronous programs.
We also study several extensions to the basic models of asynchronous programs
that are inspired by additional capabilities provided by implementations of
asynchronous libraries, and classify the decidability and undecidability of
verification questions on these extensions.Comment: 46 pages, 9 figure
- …