8 research outputs found
Parameterized Complexity of Safety of Threshold Automata
Threshold automata are a formalism for modeling fault-tolerant distributed algorithms. In this paper, we study the parameterized complexity of reachability of threshold automata. As a first result, we show that the problem becomes W[1]-hard even when parameterized by parameters which are quite small in practice. We then consider two restricted cases which arise in practice and provide fixed-parameter tractable algorithms for both these cases. Finally, we report on experimental results conducted on some protocols taken from the literature
Complexity of Liveness in Parameterized Systems
We investigate the fine-grained complexity of liveness verification for leader contributor systems. These consist of a designated leader thread and an arbitrary number of identical contributor threads communicating via a shared memory. The liveness verification problem asks whether there is an infinite computation of the system in which the leader reaches a final state infinitely often. Like its reachability counterpart, the problem is known to be NP-complete. Our results show that, even from a fine-grained point of view, the complexities differ only by a polynomial factor.
Liveness verification decomposes into reachability and cycle detection. We present a fixed point iteration solving the latter in polynomial time. For reachability, we reconsider the two standard parameterizations. When parameterized by the number of states of the leader L and the size of the data domain D, we show an (L + D)^O(L + D)-time algorithm. It improves on a previous algorithm, thereby settling an open problem. When parameterized by the number of states of the contributor C, we reuse an O^*(2^C)-time algorithm. We show how to connect both algorithms with the cycle detection to obtain algorithms for liveness verification. The running times of the composed algorithms match those of reachability, proving that the fine-grained lower bounds for liveness verification are met
TAPInspector: Safety and Liveness Verification of Concurrent Trigger-Action IoT Systems
Trigger-action programming (TAP) is a popular end-user programming framework
that can simplify the Internet of Things (IoT) automation with simple
trigger-action rules. However, it also introduces new security and safety
threats. A lot of advanced techniques have been proposed to address this
problem. Rigorously reasoning about the security of a TAP-based IoT system
requires a well-defined model and verification method both against rule
semantics and physical-world states, e.g., concurrency, rule latency, and
connection-based interactions, which has been missing until now. This paper
presents TAPInspector, a novel system to detect vulnerabilities in concurrent
TAP-based IoT systems using model checking. It automatically extracts TAP rules
from IoT apps, translates them into a hybrid model with model slicing and state
compression, and performs model checking with various safety and liveness
properties. Our experiments corroborate that TAPInspector is effective: it
identifies 533 violations with 9 new types of violations from 1108 real-world
market IoT apps and is 60000 times faster than the baseline without
optimization at least.Comment: 14 pages, 5 figure
Safety Verification of Parameterized Systems under Release-Acquire
We study the safety verification problem for parameterized systems under the
release-acquire (RA) semantics. It has been shown that the problem is
intractable for systems with unlimited access to atomic compare-and-swap (CAS)
instructions. We show that, from a verification perspective where approximate
results help, this is overly pessimistic. We study parameterized systems
consisting of an unbounded number of environment threads executing identical
but CAS-free programs and a fixed number of distinguished threads that are
unrestricted.
Our first contribution is a new semantics that considerably simplifies RA but
is still equivalent for the above systems as far as safety verification is
concerned. We apply this (general) result to two subclasses of our model. We
show that safety verification is only \pspace-complete for the bounded model
checking problem where the distinguished threads are loop-free. Interestingly,
we can still afford the unbounded environment. We show that the complexity
jumps to \nexp-complete for thread-modular verification where an unrestricted
distinguished `ego' thread interacts with an environment of CAS-free threads
plus loop-free distinguished threads (as in the earlier setting). Besides the
usefulness for verification, the results are strong in that they delineate the
tractability border for an established semantics
Parameterized Broadcast Networks with Registers: from NP to the Frontiers of Decidability
We consider the parameterized verification of arbitrarily large networks of
agents which communicate by broadcasting and receiving messages. In our model,
the broadcast topology is reconfigurable so that a sent message can be received
by any set of agents. In addition, agents have local registers which are
initially distinct and may therefore be thought of as identifiers. When an
agent broadcasts a message, it appends to the message the value stored in one
of its registers. Upon reception, an agent can store the received value or test
this value for equality with one of its own registers. We consider the
coverability problem, where one asks whether a given state of the system may be
reached by at least one agent. We establish that this problem is decidable;
however, it is as hard as coverability in lossy channel systems, which is
non-primitive recursive. This model lies at the frontier of decidability as
other classical problems on this model are undecidable; this is in particular
true for the target problem where all processes must synchronize on a given
state. By contrast, we show that the coverability problem is NP-complete when
each agent has only one register
Foundations of Software Science and Computation Structures
This open access book constitutes the proceedings of the 25th International Conference on Foundations of Software Science and Computational Structures, FOSSACS 2022, which was held during April 4-6, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 23 regular papers presented in this volume were carefully reviewed and selected from 77 submissions. They deal with research on theories and methods to support the analysis, integration, synthesis, transformation, and verification of programs and software systems
Foundations of Software Science and Computation Structures
This open access book constitutes the proceedings of the 25th International Conference on Foundations of Software Science and Computational Structures, FOSSACS 2022, which was held during April 4-6, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 23 regular papers presented in this volume were carefully reviewed and selected from 77 submissions. They deal with research on theories and methods to support the analysis, integration, synthesis, transformation, and verification of programs and software systems