2,839 research outputs found
On Verifying Causal Consistency
Causal consistency is one of the most adopted consistency criteria for
distributed implementations of data structures. It ensures that operations are
executed at all sites according to their causal precedence. We address the
issue of verifying automatically whether the executions of an implementation of
a data structure are causally consistent. We consider two problems: (1)
checking whether one single execution is causally consistent, which is relevant
for developing testing and bug finding algorithms, and (2) verifying whether
all the executions of an implementation are causally consistent.
We show that the first problem is NP-complete. This holds even for the
read-write memory abstraction, which is a building block of many modern
distributed systems. Indeed, such systems often store data in key-value stores,
which are instances of the read-write memory abstraction. Moreover, we prove
that, surprisingly, the second problem is undecidable, and again this holds
even for the read-write memory abstraction. However, we show that for the
read-write memory abstraction, these negative results can be circumvented if
the implementations are data independent, i.e., their behaviors do not depend
on the data values that are written or read at each moment, which is a
realistic assumption.Comment: extended version of POPL 201
Buffered Simulation Games for B\"uchi Automata
Simulation relations are an important tool in automata theory because they
provide efficiently computable approximations to language inclusion. In recent
years, extensions of ordinary simulations have been studied, for instance
multi-pebble and multi-letter simulations which yield better approximations and
are still polynomial-time computable.
In this paper we study the limitations of approximating language inclusion in
this way: we introduce a natural extension of multi-letter simulations called
buffered simulations. They are based on a simulation game in which the two
players share a FIFO buffer of unbounded size. We consider two variants of
these buffered games called continuous and look-ahead simulation which differ
in how elements can be removed from the FIFO buffer. We show that look-ahead
simulation, the simpler one, is already PSPACE-hard, i.e. computationally as
hard as language inclusion itself. Continuous simulation is even EXPTIME-hard.
We also provide matching upper bounds for solving these games with infinite
state spaces.Comment: In Proceedings AFL 2014, arXiv:1405.527
Game Characterization of Probabilistic Bisimilarity, and Applications to Pushdown Automata
We study the bisimilarity problem for probabilistic pushdown automata (pPDA)
and subclasses thereof. Our definition of pPDA allows both probabilistic and
non-deterministic branching, generalising the classical notion of pushdown
automata (without epsilon-transitions). We first show a general
characterization of probabilistic bisimilarity in terms of two-player games,
which naturally reduces checking bisimilarity of probabilistic labelled
transition systems to checking bisimilarity of standard (non-deterministic)
labelled transition systems. This reduction can be easily implemented in the
framework of pPDA, allowing to use known results for standard
(non-probabilistic) PDA and their subclasses. A direct use of the reduction
incurs an exponential increase of complexity, which does not matter in deriving
decidability of bisimilarity for pPDA due to the non-elementary complexity of
the problem. In the cases of probabilistic one-counter automata (pOCA), of
probabilistic visibly pushdown automata (pvPDA), and of probabilistic basic
process algebras (i.e., single-state pPDA) we show that an implicit use of the
reduction can avoid the complexity increase; we thus get PSPACE, EXPTIME, and
2-EXPTIME upper bounds, respectively, like for the respective non-probabilistic
versions. The bisimilarity problems for OCA and vPDA are known to have matching
lower bounds (thus being PSPACE-complete and EXPTIME-complete, respectively);
we show that these lower bounds also hold for fully probabilistic versions that
do not use non-determinism
The Complexity of Bisimulation and Simulation on Finite Systems
In this paper the computational complexity of the (bi)simulation problem over
restricted graph classes is studied. For trees given as pointer structures or
terms the (bi)simulation problem is complete for logarithmic space or NC,
respectively. This solves an open problem from Balc\'azar, Gabarr\'o, and
S\'antha. Furthermore, if only one of the input graphs is required to be a
tree, the bisimulation (simulation) problem is contained in AC (LogCFL). In
contrast, it is also shown that the simulation problem is P-complete already
for graphs of bounded path-width
The size of BDDs and other data structures in temporal logics model checking
Temporal Logic Model Checking is a verification method in which we describe a system, the model, and then we verify whether important properties, expressed in a temporal logic formula, hold in the system. Many Model Checking tools employ BDDs or some other data structure to represent sets of states. It has been empirically observed that the BDDs used in these algorithms may grow exponentially as the model and formula increase in size. We formally prove that no kind of data structure of polynomial size can represent the set of valid initial states for all models and all formulae. This result holds for all data structures where a state can be checked in polynomial time. Therefore, it holds not only for all types of BDDs regardless of variable ordering, but also for more powerful data structures, such as RBCs, MTBDDs, ADDs and SDDs. Thus, the size explosion of BDDs is not a limit of these specific data representation structures, but is unavoidable: every formalism used in the same way would lead to an exponential size blow up
Probabilistic Bisimulations for PCTL Model Checking of Interval MDPs
Verification of PCTL properties of MDPs with convex uncertainties has been
investigated recently by Puggelli et al. However, model checking algorithms
typically suffer from state space explosion. In this paper, we address
probabilistic bisimulation to reduce the size of such an MDPs while preserving
PCTL properties it satisfies. We discuss different interpretations of
uncertainty in the models which are studied in the literature and that result
in two different definitions of bisimulations. We give algorithms to compute
the quotients of these bisimulations in time polynomial in the size of the
model and exponential in the uncertain branching. Finally, we show by a case
study that large models in practice can have small branching and that a
substantial state space reduction can be achieved by our approach.Comment: In Proceedings SynCoP 2014, arXiv:1403.784
Branching Bisimilarity of Normed BPA Processes is in NEXPTIME
Branching bisimilarity on normed BPA processes was recently shown to be
decidable by Yuxi Fu (ICALP 2013) but his proof has not provided any upper
complexity bound. We present a simpler approach based on relative prime
decompositions that leads to a nondeterministic exponential-time algorithm;
this is close to the known exponential-time lower bound.Comment: This is the same text as in July 2014, but only with some
acknowledgment added due to administrative need
The model checking fingerprints of CTL operators
The aim of this study is to understand the inherent expressive power of CTL
operators. We investigate the complexity of model checking for all CTL
fragments with one CTL operator and arbitrary Boolean operators. This gives us
a fingerprint of each CTL operator. The comparison between the fingerprints
yields a hierarchy of the operators that mirrors their strength with respect to
model checking
Computing the interleaving distance is NP-hard
We show that computing the interleaving distance between two multi-graded
persistence modules is NP-hard. More precisely, we show that deciding whether
two modules are -interleaved is NP-complete, already for bigraded, interval
decomposable modules. Our proof is based on previous work showing that a
constrained matrix invertibility problem can be reduced to the interleaving
distance computation of a special type of persistence modules. We show that
this matrix invertibility problem is NP-complete. We also give a slight
improvement of the above reduction, showing that also the approximation of the
interleaving distance is NP-hard for any approximation factor smaller than .
Additionally, we obtain corresponding hardness results for the case that the
modules are indecomposable, and in the setting of one-sided stability.
Furthermore, we show that checking for injections (resp. surjections) between
persistence modules is NP-hard. In conjunction with earlier results from
computational algebra this gives a complete characterization of the
computational complexity of one-sided stability. Lastly, we show that it is in
general NP-hard to approximate distances induced by noise systems within a
factor of 2.Comment: 25 pages. Several expository improvements and minor corrections. Also
added a section on noise system
- …