Filters








29 Hits in 0.76 sec

A Framework for Consistency Algorithms [article]

Peter Chini, Prakash Saivasan
2020 arXiv   pre-print
We present a framework that provides deterministic consistency algorithms for given memory models. Such an algorithm checks whether the executions of a shared-memory concurrent program are consistent under the axioms defined by a model. For memory models like SC and TSO, checking consistency is NP-complete. Our framework shows, that despite the hardness, fast deterministic consistency algorithms can be obtained by employing tools from fine-grained complexity. The framework is based on a
more » ... l consistency problem which can be instantiated by different memory models. We construct an algorithm for the problem running in time O*(2^k), where k is the number of write accesses in the execution that is checked for consistency. Each instance of the framework then admits an O*(2^k)-time consistency algorithm. By applying the framework, we obtain corresponding consistency algorithms for SC, TSO, PSO, and RMO. Moreover, we show that the obtained algorithms for SC, TSO, and PSO are optimal in the fine-grained sense: there is no consistency algorithm for these running in time 2^o(k) unless the exponential time hypothesis fails.
arXiv:2007.11398v1 fatcat:ukqpqmos4ngvfghpwyux4ccr2u

Fast Witness Counting [article]

Peter Chini, Rehab Massoud, Roland Meyer, Prakash Saivasan
2018 arXiv   pre-print
We study the witness-counting problem: given a set of vectors V in the d-dimensional vector space over F_2, a target vector t, and an integer k, count all ways to sum-up exactly k different vectors from V to reach t. The problem is well-known in coding theory and received considerable attention in complexity theory. Recently, it appeared in the context of hardware monitoring. Our contribution is an algorithm for witness counting that is optimal in the sense of fine-grained complexity. It runs
more » ... time O^*(2^d) with only a logarithmic dependence on m=|V|. The algorithm makes use of the Walsh-Hadamard transform to compute convolutions over F_2^d. The transform, however, overcounts the solutions. Inspired by the inclusion-exclusion principle, we introduce correction terms. The correction leads to a recurrence that we show how to solve efficiently. The correction terms are obtained from equivalence relations over F_2^d. We complement our upper bound with two lower bounds on the problem. The first relies on # ETH and prohibits an 2^o(d)-time algorithm. The second bound states the non-existence of a polynomial kernel for the decision version of the problem.
arXiv:1807.05777v1 fatcat:x27oeyplmrhbpkhl7wk5pv6a6y

Nested Words for Order-2 Pushdown Systems [article]

C. Aiswarya, Paul Gastin, Prakash Saivasan
2016 arXiv   pre-print
We study linear time model checking of collapsible higher-order pushdown systems (CPDS) of order 2 (manipulating stack of stacks) against MSO and PDL (propositional dynamic logic with converse and loop) enhanced with push/pop matching relations. To capture these linear time behaviours with matchings, we propose order-2 nested words. These graphs consist of a word structure augmented with two binary matching relations, one for each order of stack, which relate a push with matching pops (or
more » ... se) on the respective stack. Due to the matching relations, satisfiability and model checking are undecidable. Hence we propose an under-approximation, bounding the number of times an order-1 push can be popped. With this under-approximation, which still allows unbounded stack height, we get decidability for satisfiability and model checking of both MSO and PDL. The problems are ExpTime-Complete for PDL.
arXiv:1609.06290v1 fatcat:ns4yi2ezzrbi5omz744zmh7kw4

Liveness in Broadcast Networks [article]

Peter Chini, Roland Meyer, Prakash Saivasan
2020 arXiv   pre-print
We study liveness and model checking problems for broadcast networks, a system model of identical clients communicating via message passing. The first problem that we consider is Liveness Verification. It asks whether there is a computation such that one of the clients visits a final state infinitely often. The complexity of the problem has been open since 2010 when it was shown to be P-hard and solvable in EXPSPACE. We close the gap by a polynomial-time algorithm. The algorithm relies on a
more » ... acterization of live computations in terms of paths in a suitable graph, combined with a fixed-point iteration to efficiently check the existence of such paths. The second problem is Fair Liveness Verification. It asks for a computation where all participating clients visit a final state infinitely often. We adjust the algorithm to also solve fair liveness in polynomial time. Both problems can be instrumented to answer model checking questions for broadcast networks against linear time temporal logic specifications. The first problem in this context is Fair Model Checking. It demands that for all computations of a broadcast network, all participating clients satisfy the specification. We solve the problem via the Vardi-Wolper construction and a reduction to Liveness Verification. The second problem is Sparse Model Checking. It asks whether each computation has a participating client that satisfies the specification. We reduce the problem to Fair Liveness Verification.
arXiv:1904.00833v3 fatcat:t6hxy3tk4vdglkr4d4ws2puctm

Complexity of Liveness in Parameterized Systems [article]

Peter Chini, Roland Meyer, Prakash Saivasan
2019 arXiv   pre-print
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
more » ... 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.
arXiv:1909.12004v2 fatcat:tjshwenhbfhq5dcl7qk3dexnzy

Fine-Grained Complexity of Safety Verification [chapter]

Peter Chini, Roland Meyer, Prakash Saivasan
2018 Lecture Notes in Computer Science  
We study the fine-grained complexity of Leader Contributor Reachability (LCR) and Bounded-Stage Reachability (BSR), two variants of the safety verification problem for shared-memory concurrent programs. For both problems, the memory is a single variable over a finite data domain. We contribute new verification algorithms and lower bounds based on the Exponential Time Hypothesis (ETH) and kernels. LCR is the question whether a designated leader thread can reach an unsafe state when interacting
more » ... th a certain number of equal contributor threads. We suggest two parameterizations: (1) By the size of the data domain D and the size of the leader L, and (2) by the size of the contributors C. We present two algorithms, running in O * ((L · (D + 1)) L·D · D D ) and O * (4 C ) time, showing that both parameterizations are fixed-parameter tractable. Further, we suggest a modification of the first algorithm suitable for practical instances. The upper bounds are complemented by (matching) lower bounds based on ETH and kernels. For BSR, we consider programs involving t different threads. We restrict the analysis to computations where the write permission changes s times between the threads. BSR asks whether a given configuration is reachable via such an s-stage computation. When parameterized by P, the maximum size of a thread, and t, the interesting observation is that the problem has a large number of difficult instances. Formally, we show that there is no polynomial kernel, no compression algorithm that reduces D or s to a polynomial dependence on P and t. This indicates that symbolic methods may be harder to find for this problem.
doi:10.1007/978-3-319-89963-3_2 fatcat:y57lo3wexbdvnl452sxxrfawdi

Fine-Grained Complexity of Safety Verification

Peter Chini, Roland Meyer, Prakash Saivasan
2020 Journal of automated reasoning  
We study the fine-grained complexity of Leader Contributor Reachability (LCR) and Bounded-Stage Reachability (BSR), two variants of the safety verification problem for shared memory concurrent programs. For both problems, the memory is a single variable over a finite data domain. Our contributions are new verification algorithms and lower bounds. The latter are based on the Exponential Time Hypothesis (ETH), the problem Set Cover, and crosscompositions. LCR is the question whether a designated
more » ... eader thread can reach an unsafe state when interacting with a certain number of equal contributor threads. We suggest two parameterizations: (1) By the size of the data domain D and the size of the leader L, and (2) by the size of the contributors C. We present algorithms for both cases. The key techniques are compact witnesses and dynamic programming. The algorithms run in O * ((L showing that both parameterizations are fixed-parameter tractable. We complement the upper bounds by (matching) lower bounds based on ETH and Set Cover. Moreover, we prove the absence of polynomial kernels. For BSR, we consider programs involving t different threads. We restrict the analysis to computations where the write permission changes s times between the threads. BSR asks whether a given configuration is reachable via such an s-stage computation. When parameterized by P, the maximum size of a thread, and t, the interesting observation is that the problem has a large number of difficult instances. Formally, we show that there is no polynomial kernel, no compression algorithm that reduces the size of the data domain D or the number of stages s to a polynomial dependence on P and t. This indicates that symbolic methods may be harder to find for this problem.
doi:10.1007/s10817-020-09572-x fatcat:7w7iyoxfeff7zkdvmpjowqzxx4

Complexity of regular abstractions of one-counter languages [article]

Mohamed Faouzi Atig, Dmitry Chistikov, Piotr Hofman, K Narayan Kumar, Prakash Saivasan, Georg Zetzsche
2016 arXiv   pre-print
We study the computational and descriptional complexity of the following transformation: Given a one-counter automaton (OCA) A, construct a nondeterministic finite automaton (NFA) B that recognizes an abstraction of the language L(A): its (1) downward closure, (2) upward closure, or (3) Parikh image. For the Parikh image over a fixed alphabet and for the upward and downward closures, we find polynomial-time algorithms that compute such an NFA. For the Parikh image with the alphabet as part of
more » ... e input, we find a quasi-polynomial time algorithm and prove a completeness result: we construct a sequence of OCA that admits a polynomial-time algorithm iff there is one for all OCA. For all three abstractions, it was previously unknown if appropriate NFA of sub-exponential size exist.
arXiv:1602.03419v1 fatcat:piatzusl5vbyfn2zii6fdt2x4m

On the Complexity of Bounded Context Switching [article]

Peter Chini, Jonathan Kolberg, Andreas Krebs, Roland Meyer, Prakash Saivasan
2017 arXiv   pre-print
Saivasan. On bounded reachability analysis of shared memory systems. In FSTTCS, pages 611-623. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2014. M. F.Atig, A. Bouajjani, and T. Touili.  ... 
arXiv:1609.09728v2 fatcat:tdamef5gczegxilnaealmrcnmm

Fine-Grained Complexity of Safety Verification [article]

Peter Chini, Roland Meyer, Prakash Saivasan
2020 arXiv   pre-print
We study the fine-grained complexity of Leader Contributor Reachability (LCR) and Bounded-Stage Reachability (BSR), two variants of the safety verification problem for shared memory concurrent programs. For both problems, the memory is a single variable over a finite data domain. Our contributions are new verification algorithms and lower bounds. The latter are based on the Exponential Time Hypothesis (ETH), the problem Set Cover, and cross-compositions. LCR is the question whether a designated
more » ... leader thread can reach an unsafe state when interacting with a certain number of equal contributor threads. We suggest two parameterizations: (1) By the size of the data domain D and the size of the leader L, and (2) by the size of the contributors C. We present algorithms for both cases. The key techniques are compact witnesses and dynamic programming. The algorithms run in O*((L(D+1))^(LD) * D^D) and O*(2^C) time, showing that both parameterizations are fixed-parameter tractable. We complement the upper bounds by (matching) lower bounds based on ETH and Set Cover. Moreover, we prove the absence of polynomial kernels. For BSR, we consider programs involving t different threads. We restrict the analysis to computations where the write permission changes s times between the threads. BSR asks whether a given configuration is reachable via such an s-stage computation. When parameterized by P, the maximum size of a thread, and t, the interesting observation is that the problem has a large number of difficult instances. Formally, we show that there is no polynomial kernel, no compression algorithm that reduces the size of the data domain D or the number of stages s to a polynomial dependence on P and t. This indicates that symbolic methods may be harder to find for this problem.
arXiv:1802.05559v3 fatcat:m3pt6baayfeq5fqsmpoxndyb3a

Model checking Branching-Time Properties of Multi-Pushdown Systems is Hard [article]

Mohamed Faouzi Atig, Ahmed Bouajjani, K. Narayan Kumar, Prakash Saivasan
2012 arXiv   pre-print
We address the model checking problem for shared memory concurrent programs modeled as multi-pushdown systems. We consider here boolean programs with a finite number of threads and recursive procedures. It is well-known that the model checking problem is undecidable for this class of programs. In this paper, we investigate the decidability and the complexity of this problem under the assumption of bounded context-switching defined by Qadeer and Rehof, and of phase-boundedness proposed by La
more » ... e et al. On the model checking of such systems against temporal logics and in particular branching time logics such as the modal μ-calculus or CTL has received little attention. It is known that parity games, which are closely related to the modal μ-calculus, are decidable for the class of bounded-phase systems (and hence for bounded-context switching as well), but with non-elementary complexity (Seth). A natural question is whether this high complexity is inevitable and what are the ways to get around it. This paper addresses these questions and unfortunately, and somewhat surprisingly, it shows that branching model checking for MPDSs is inherently an hard problem with no easy solution. We show that parity games on MPDS under phase-bounding restriction is non-elementary. Our main result shows that model checking a k context bounded MPDS against a simple fragment of CTL, consisting of formulas that whose temporal operators come from the set , , has a non-elementary lower bound.
arXiv:1205.6928v1 fatcat:enmt7wj6fjaoxlsh5q7vux66hm

On the Upward/Downward Closures of Petri Nets [article]

Mohamed Faouzi Atig, Roland Meyer, Sebastian Muskalla, Prakash Saivasan
2018 arXiv   pre-print
We study the size and the complexity of computing finite state automata (FSA) representing and approximating the downward and the upward closure of Petri net languages with coverability as the acceptance condition. We show how to construct an FSA recognizing the upward closure of a Petri net language in doubly-exponential time, and therefore the size is at most doubly exponential. For downward closures, we prove that the size of the minimal automata can be non-primitive recursive. In the case
more » ... BPP nets, a well-known subclass of Petri nets, we show that an FSA accepting the downward/upward closure can be constructed in exponential time. Furthermore, we consider the problem of checking whether a simple regular language is included in the downward/upward closure of a Petri net/BPP net language. We show that this problem is EXPSPACE-complete (resp. NP-complete) in the case of Petri nets (resp. BPP nets). Finally, we show that it is decidable whether a Petri net language is upward/downward closed. To this end, we prove that one can decide whether a given regular language is a subset of a Petri net coverability language.
arXiv:1701.02927v2 fatcat:dl6f2yqrijaxrgprpt6yzgxes4

Parity Games on Bounded Phase Multi-pushdown Systems [chapter]

Mohamed Faouzi Atig, Ahmed Bouajjani, K. Narayan Kumar, Prakash Saivasan
2017 Lecture Notes in Computer Science  
In this paper we address the problem of solving parity games over the configuration graphs of bounded phase multi-pushdown systems. A non-elementary decision procedure was proposed for this problem by A. Seth. In this paper, we provide a simple and inductive construction to solve this problem. We also prove a non-elementary lower-bound, answering a question posed by A.Seth.
doi:10.1007/978-3-319-59647-1_21 fatcat:gyox52gcgng3nmi4f7gvhnlxqa

Linear-Time Model-Checking for Multithreaded Programs under Scope-Bounding [chapter]

Mohamed Faouzi Atig, Ahmed Bouajjani, K. Narayan Kumar, Prakash Saivasan
2012 Lecture Notes in Computer Science  
We address the model checking problem of omega-regular linear-time properties for shared memory concurrent programs modeled as multi-pushdown systems. We consider here boolean programs with a finite number of threads and recursive procedures. It is well-known that the model checking problem is undecidable for this class of programs. In this paper, we investigate the decidability and the complexity of this problem under the assumption of scope-boundedness defined recently by La Torre and Napoli
more » ... n [24] . A computation is scope-bounded if each pair of call and return events of a procedure executed by some thread must be separated by a bounded number of context-switches of that thread. The concept of scope-bounding generalizes the one of contextbounding [31] since it allows an unbounded number of context switches. Moreover, while context-bounding is adequate for reasoning about safety properties, scope-bounding is more suitable for reasoning about liveness properties that must be checked over infinite computations. It has been shown in [24] that the reachability problem for multi-pushdown systems under scope-bounding is PSPACE-complete. We prove in this paper that model-checking linear-time properties under scope-bounding is also decidable and is EXPTIME-complete.
doi:10.1007/978-3-642-33386-6_13 fatcat:uxoeg6x6mngm5pblwiftvgw3ee

Complexity of Liveness in Parameterized Systems

Peter Chini, Roland Meyer, Prakash Saivasan, Michael Wagner
2019 Foundations of Software Technology and Theoretical Computer Science  
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
more » ... 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. ACM Subject Classification Theory of computation → Formal languages and automata theory; Theory of computation → Problems, reductions and completeness
doi:10.4230/lipics.fsttcs.2019.37 dblp:conf/fsttcs/Chini0S19 fatcat:vpndlnv36fecjmff3ibbwxmtzy
« Previous Showing results 1 — 15 out of 29 results