arXiv subjects

Sorrachai Yingchareonthawornchai

Publications and source records attributed to Sorrachai Yingchareonthawornchai.

23 records · Page 2Linked to original sources

arXiv2019

Computing and Testing Small Connectivity in Near-Linear Time and Queries via Fast Local Cut Algorithms

Consider the following "local" cut-detection problem in a directed graph: We are given a seed vertex $x$ and need to remove at most $k$ edges so that at most $ν$ edges can be reached from $x$ (a "local" cut) or output $\bot$ to indicate that no such cut exists. If we are given query access to the input graph, then this problem can in principle be solved without reading the whole graph and with query complexity depending on $k$ and $ν$. In this paper we consider a slack variant of this problem where, when such a cut exists, we can output a cut with up to $O(kν)$ edges reachable from $x$. We present a simple randomized algorithm spending $O(k^2ν)$ time and $O(kν)$ queries for the above variant, improving in particular a previous time bound of $O(k^{O(k)}ν)$ by Chechik et al. [SODA '17]. We also extend our algorithm to handle an approximate variant. We demonstrate that these local algorithms are versatile primitives for designing substantially improved algorithms for classic graph problems by providing the following three applications. (Throughout, $\tilde O(T)$ hides $\operatorname{polylog}(T)$.) (1) A randomized algorithm for the classic $k$-vertex connectivity problem that takes near-linear time when $k=O(\operatorname{polylog}(n))$, namely $\tilde O(m+nk^3)$ time in undirected graphs. For directed graphs our $\tilde O(mk^2)$-time algorithm is near-linear when $k=O(\operatorname{polylog}(n))$. Our techniques also yield an improved approximation scheme. (2) Property testing algorithms for $k$-edge and -vertex connectivity with query complexities that are near-linear in $k$, exponentially improving the state-of-the-art. This resolves two open problems, one by Goldreich and Ron [STOC '97] and one by Orenstein and Ron [Theor. Comput Sci. '11]. (3) A faster algorithm for computing the maximal $k$-edge connected subgraphs, improving prior work of Chechik et al. [SODA '17].

cs.DS↗

arXiv2019

Deterministic Graph Cuts in Subquadratic Time: Sparse, Balanced, and k-Vertex

We study deterministic algorithms for computing graph cuts, with focus on two fundamental problems: balanced sparse cut and $k$-vertex connectivity for small $k$ ($k=O(\polylog n)$). Both problems can be solved in near-linear time with randomized algorithms, but their previous deterministic counterparts take at least quadratic time. In this paper, we break this bound for both problems. Interestingly, achieving this for one problem crucially relies on doing so for the other. In particular, via a divide-and-conquer argument, a variant of the cut-matching game by [Khandekar et al.`07], and the local vertex connectivity algorithm of [Nanongkai et al. STOC'19], we give a subquadratic time algorithm for $k$-vertex connectivity using a subquadratic time algorithm for computing balanced sparse cuts on sparse graphs. To achieve the latter, we improve the previously best $mn$ bound for approximating balanced sparse cut for the whole range of $m$. This starts from (1) breaking the $n^3$ barrier on dense graphs to $n^{ω+ o(1)}$ (where $ω< 2.372$) using the the PageRank matrix, but without explicitly sweeping to find sparse cuts; to (2) getting the $\tilde O(m^{1.58})$ bound by combining the $J$-trees by [Madry FOCS `10] with the $n^{ω+ o(1)}$ bound above, and finally; to (3) getting the $m^{1.5 + o(1)}$ bound by recursively invoking the second bound in conjunction with expander-based graph sparsification. Interestingly, our final $m^{1.5 + o(1)}$ bound lands at a natural stopping point in the sense that polynomially breaking it would lead to a breakthrough for the dynamic connectivity problem.

cs.DS↗

arXiv2019

Computing and Testing Small Vertex Connectivity in Near-Linear Time and Queries

We present a new, simple, algorithm for the local vertex connectivity problem (LocalVC) introduced by Nanongkai~et~al. [STOC'19]. Roughly, given an undirected unweighted graph $G$, a seed vertex $x$, a target volume $ν$, and a target separator size $k$, the goal of LocalVC is to remove $k$ vertices `near' $x$ (in terms of $ν$) to disconnect the graph in `local time', which depends only on parameters $ν$ and $k$. In this paper, we present a simple randomized algorithm with running time $O(νk^2)$ and correctness probability $2/3$. Plugging our new localVC algorithm in the generic framework of Nanongkai~et~al. immediately lead to a randomized $\tilde O(m+nk^3)$-time algorithm for the classic $k$-vertex connectivity problem on undirected graphs. ($\tilde O(T)$ hides $\text{polylog}(T)$.) This is the first near-linear time algorithm for any $4\leq k \leq \text{polylog} n$. Previous fastest algorithm for small $k$ takes $\tilde O(m+n^{4/3}k^{7/3})$ time [Nanongkai~et~al., STOC'19]. This work is inspired by the algorithm of Chechik~et~al. [SODA'17] for computing the maximal $k$-edge connected subgraphs. Forster and Yang [arXiv'19] has independently developed local algorithms similar to ours, and showed that they lead to an $\tilde O(k^3/ε)$ bound for testing $k$-edge and -vertex connectivity, resolving two long-standing open problems in property testing since the work of Goldreich and Ron [STOC'97] and Orenstein and Ron [Theor. Comput. Sci.'11]. Inspired by this, we use local approximation algorithms to obtain bounds that are near-linear in $k$, namely $\tilde O(k/ε)$ and $\tilde O(k/ε^2)$ for the bounded and unbounded degree cases, respectively. For testing $k$-edge connectivity for simple graphs, the bound can be improved to $\tilde O(\min(k/ε, 1/ε^2))$.

cs.DS↗

arXiv2017

Monitoring Partially Synchronous Distributed Systems using SMT Solvers

In this paper, we discuss the feasibility of monitoring partially synchronous distributed systems to detect latent bugs, i.e., errors caused by concurrency and race conditions among concurrent processes. We present a monitoring framework where we model both system constraints and latent bugs as Satisfiability Modulo Theories (SMT) formulas, and we detect the presence of latent bugs using an SMT solver. We demonstrate the feasibility of our framework using both synthetic applications where latent bugs occur at any time with random probability and an application involving exclusive access to a shared resource with a subtle timing bug. We illustrate how the time required for verification is affected by parameters such as communication frequency, latency, and clock skew. Our results show that our framework can be used for real-life applications, and because our framework uses SMT solvers, the range of appropriate applications will increase as these solvers become more efficient over time.

cs.DC↗

arXiv2016

Precision, Recall, and Sensitivity of Monitoring Partially Synchronous Distributed Systems

Runtime verification focuses on analyzing the execution of a given program by a monitor to determine if it is likely to violate its specifications. There is often an impedance mismatch between the assumptions/model of the monitor and that of the underlying program. This constitutes problems especially for distributed systems, where the concept of current time and state are inherently uncertain. A monitor designed with asynchronous system model assumptions may cause false-positives for a program executing in a partially synchronous system: the monitor may flag a global predicate that does not actually occur in the underlying system. A monitor designed with a partially synchronous system model assumption may cause false negatives as well as false positives for a program executing in an environment where the bounds on partial synchrony differ (albeit temporarily) from the monitor model assumptions. In this paper we analyze the effects of the impedance mismatch between the monitor and the underlying program for the detection of conjunctive predicates. We find that there is a small interval where the monitor assumptions are hypersensitive to the underlying program environment. We provide analytical derivations for this interval, and also provide simulation support for exploring the sensitivity of predicate detection to the impedance mismatch between the monitor and the program under a partially synchronous system.

cs.DC↗