arXiv subjects

Soheil Behnezhad

Publications and source records attributed to Soheil Behnezhad.

At least 37 records · Page 2Linked to original sources

arXiv2023

Local Computation Algorithms for Maximum Matching: New Lower Bounds

We study local computation algorithms (LCA) for maximum matching. An LCA does not return its output entirely, but reveals parts of it upon query. For matchings, each query is a vertex $v$; the LCA should return whether $v$ is matched -- and if so to which neighbor -- while spending a small time per query. In this paper, we prove that any LCA that computes a matching that is at most an additive of $εn$ smaller than the maximum matching in $n$-vertex graphs of maximum degree $Δ$ must take at least $Δ^{Ω(1/\varepsilon)}$ time. This comes close to the existing upper bounds that take $(Δ/ε)^{O(1/ε^2)} polylog(n)$ time. In terms of sublinear time algorithms, our techniques imply that any algorithm that estimates the size of maximum matching up to an additive error of $εn$ must take $Δ^{Ω(1/ε)}$ time. This negatively resolves a decade old open problem of the area (see Open Problem 39 of sublinear.info) on whether such estimates can be achieved in $poly(Δ/ε)$ time.

cs.DS↗

arXiv2023

Exponentially Faster Massively Parallel Maximal Matching

The study of approximate matching in the Massively Parallel Computations (MPC) model has recently seen a burst of breakthroughs. Despite this progress, however, we still have a far more limited understanding of maximal matching which is one of the central problems of parallel and distributed computing. All known MPC algorithms for maximal matching either take polylogarithmic time which is considered inefficient, or require a strictly super-linear space of $n^{1+Ω(1)}$ per machine. In this work, we close this gap by providing a novel analysis of an extremely simple algorithm a variant of which was conjectured to work by Czumaj et al. [STOC'18]. The algorithm edge-samples the graph, randomly partitions the vertices, and finds a random greedy maximal matching within each partition. We show that this algorithm drastically reduces the vertex degrees. This, among some other results, leads to an $O(\log \log Δ)$ round algorithm for maximal matching with $O(n)$ space (or even mildly sublinear in $n$ using standard techniques). As an immediate corollary, we get a $2$ approximate minimum vertex cover in essentially the same rounds and space. This is the best possible approximation factor under standard assumptions, culminating a long line of research. It also leads to an improved $O(\log\log Δ)$ round algorithm for $1 + \varepsilon$ approximate matching. All these results can also be implemented in the congested clique model within the same number of rounds.

cs.DS↗

arXiv2023

Fully Dynamic Matching: $(2-\sqrt{2})$-Approximation in Polylog Update Time

We study maximum matchings in fully dynamic graphs, which are graphs that undergo both edge insertions and deletions. Our focus is on algorithms that estimate the size of maximum matching after each update while spending a small time. An important question studied extensively is the best approximation achievable via algorithms that only spend $\text{poly}(\log n)$ time per update, where $n$ is the number of vertices. The current best bound is a $(1/2+\varepsilon_0)$-approximation for a small constant $\varepsilon_0 > 0$, due to recent works of Behnezhad [SODA'23] ($\varepsilon_0 \sim 0.001$) and Bhattacharya, Kiss, Saranurak, Wajc [SODA'23] ($\varepsilon_0 \sim 0.006$) who broke the long-standing 1/2-approximation barrier. These works also showed that for any fixed $\varepsilon > 0$, the approximation can be further improved to $(2-\sqrt{2}-\varepsilon) \sim .585$ for bipartite graphs, leaving a huge gap between general and bipartite graphs. In this work, we close this gap. We show that for any fixed $\varepsilon > 0$, a $(2-\sqrt{2}-\varepsilon)$ approximation can be maintained in $\text{poly}(\log n)$ time per update even in general graphs. Our techniques also lead to the same approximation for general graphs in two passes of the semi-streaming setting, removing a similar gap in that setting.

cs.DS↗

arXiv2023

Streaming Edge Coloring with Asymptotically Optimal Colors

Given a graph $G$, an edge-coloring is an assignment of colors to edges of $G$ such that any two edges sharing an endpoint receive different colors. By Vizing's celebrated theorem, any graph of maximum degree $Δ$ needs at least $Δ$ and at most $(Δ+ 1)$ colors to be properly edge colored. In this paper, we study edge colorings in the streaming setting. The edges arrive one by one in an arbitrary order. The algorithm takes a single pass over the input and must output a solution using a much smaller space than the input size. Since the output of edge coloring is as large as its input, the assigned colors should also be reported in a streaming fashion. The streaming edge coloring problem has been studied in a series of works over the past few years. The main challenge is that the algorithm cannot "remember" all the color assignments that it returns. To ensure the validity of the solution, existing algorithms use many more colors than Vizing's bound. Namely, in $n$-vertex graphs, the state-of-the-art algorithm with $\widetilde{O}(n s)$ space requires $O(Δ^2/s + Δ)$ colors. Note, in particular, that for an asymptotically optimal $O(Δ)$ coloring, this algorithm requires $Ω(nΔ)$ space which is as large as the input. Whether such a coloring can be achieved with sublinear space has been left open. In this paper, we answer this question in the affirmative. We present a randomized algorithm that returns an asymptotically optimal $O(Δ)$ edge coloring using $\widetilde{O}(n \sqrtΔ)$ space. More generally, our algorithm returns a proper $O(Δ^{1.5}/s + Δ)$ edge coloring with $\widetilde{O}(n s)$ space, improving prior algorithms for the whole range of $s$.

cs.DS↗

arXiv2023

Robust Communication Complexity of Matching: EDCS Achieves 5/6 Approximation

We study the robust communication complexity of maximum matching. Edges of an arbitrary $n$-vertex graph $G$ are randomly partitioned between Alice and Bob independently and uniformly. Alice has to send a single message to Bob such that Bob can find an (approximate) maximum matching of the whole graph $G$. We specifically study the best approximation ratio achievable via protocols where Alice communicates only $\widetilde{O}(n)$ bits to Bob. There has been a growing interest on the robust communication model due to its connections to the random-order streaming model. An algorithm of Assadi and Behnezhad [ICALP'21] implies a $(2/3+ε_0 \sim .667)$-approximation for a small constant $0 < ε_0 < 10^{-18}$, which remains the best-known approximation for general graphs. For bipartite graphs, Assadi and Behnezhad [Random'21] improved the approximation to .716 albeit with a computationally inefficient (i.e., exponential time) protocol. In this paper, we study a natural and efficient protocol implied by a random-order streaming algorithm of Bernstein [ICALP'20] which is based on edge-degree constrained subgraphs (EDCS) [Bernstein and Stein; ICALP'15]. The result of Bernstein immediately implies that this protocol achieves an (almost) $(2/3 \sim .666)$-approximation in the robust communication model. We present a new analysis, proving that it achieves a much better (almost) $(5/6 \sim .833)$-approximation. This significantly improves previous approximations both for general and bipartite graphs. We also prove that our analysis of Bernstein's protocol is tight.

cs.DS↗

arXiv2022

Sublinear Time Algorithms and Complexity of Approximate Maximum Matching

Sublinear time algorithms for approximating maximum matching size have long been studied. Much of the progress over the last two decades on this problem has been on the algorithmic side. For instance, an algorithm of Behnezhad [FOCS'21] obtains a 1/2-approximation in $\tilde{O}(n)$ time for $n$-vertex graphs. A more recent algorithm by Behnezhad, Roghani, Rubinstein, and Saberi [SODA'23] obtains a slightly-better-than-1/2 approximation in $O(n^{1+ε})$ time. On the lower bound side, Parnas and Ron [TCS'07] showed 15 years ago that obtaining any constant approximation of maximum matching size requires $Ω(n)$ time. Proving any super-linear in $n$ lower bound, even for $(1-ε)$-approximations, has remained elusive since then. In this paper, we prove the first super-linear in $n$ lower bound for this problem. We show that at least $n^{1.2 - o(1)}$ queries in the adjacency list model are needed for obtaining a $(\frac{2}{3} + Ω(1))$-approximation of maximum matching size. This holds even if the graph is bipartite and is promised to have a matching of size $Θ(n)$. Our lower bound argument builds on techniques such as correlation decay that to our knowledge have not been used before in proving sublinear time lower bounds. We complement our lower bound by presenting two algorithms that run in strongly sublinear time of $n^{2-Ω(1)}$. The first algorithm achieves a $(\frac{2}{3}-ε)$-approximation; this significantly improves prior close-to-1/2 approximations. Our second algorithm obtains an even better approximation factor of $(\frac{2}{3}+Ω(1))$ for bipartite graphs. This breaks the prevalent $2/3$-approximation barrier and importantly shows that our $n^{1.2-o(1)}$ time lower bound for $(\frac{2}{3}+Ω(1))$-approximations cannot be improved all the way to $n^{2-o(1)}$.

cs.DS↗

arXiv2022

Dynamic Algorithms for Maximum Matching Size

We study fully dynamic algorithms for maximum matching. This is a well-studied problem, known to admit several update-time/approximation trade-offs. For instance, it is known how to maintain a 1/2-approximate matching in $\log^{O(1)} n$ update time or a $2/3$-approximate matching in $O(\sqrt{n})$ update time, where $n$ is the number of vertices. It has been a long-standing open problem to determine whether either of these bounds can be improved. In this paper, we show that when the goal is to maintain just the size of the matching (and not its edge-set), then these bounds can indeed be improved. First, we give an algorithm that takes $\log^{O(1)} n$ update-time and maintains a $.501$-approximation ($.585$-approximation if the graph is bipartite). Second, we give an algorithm that maintains a $(2/3 + Ω(1))$-approximation in $O(\sqrt{n})$ time for bipartite graphs. Our results build on new connections to sublinear time algorithms. In particular, a key tool for both is an algorithm of the author for estimating the size of maximal matchings in $\widetilde{O}(n)$ time [Behnezhad; FOCS 2021]. Our second result also builds on the edge-degree constrained subgraph (EDCS) of Bernstein and Stein [ICALP'15, SODA'16]. In particular, while it has been known that EDCS may not include a better than 2/3-approximation, we give a new characterization of such tight instances which allows us to break it. We believe this characterization might be of independent interest.

cs.DS↗

arXiv2022

On Regularity Lemma and Barriers in Streaming and Dynamic Matching

We present a new approach for finding matchings in dense graphs by building on Szemerédi's celebrated Regularity Lemma. This allows us to obtain non-trivial albeit slight improvements over longstanding bounds for matchings in streaming and dynamic graphs. In particular, we establish the following results for $n$-vertex graphs: * A deterministic single-pass streaming algorithm that finds a $(1-o(1))$-approximate matching in $o(n^2)$ bits of space. This constitutes the first single-pass algorithm for this problem in sublinear space that improves over the $\frac{1}{2}$-approximation of the greedy algorithm. * A randomized fully dynamic algorithm that with high probability maintains a $(1-o(1))$-approximate matching in $o(n)$ worst-case update time per each edge insertion or deletion. The algorithm works even against an adaptive adversary. This is the first $o(n)$ update-time dynamic algorithm with approximation guarantee arbitrarily close to one. Given the use of regularity lemma, the improvement obtained by our algorithms over trivial bounds is only by some $(\log^*{n})^{Θ(1)}$ factor. Nevertheless, in each case, they show that the ``right'' answer to the problem is not what is dictated by the previous bounds. Finally, in the streaming model, we also present a randomized $(1-o(1))$-approximation algorithm whose space can be upper bounded by the density of certain Ruzsa-Szemerédi (RS) graphs. While RS graphs by now have been used extensively to prove streaming lower bounds, ours is the first to use them as an upper bound tool for designing improved streaming algorithms.

cs.DS↗

arXiv2022

Beating Greedy Matching in Sublinear Time

We study sublinear time algorithms for estimating the size of maximum matching in graphs. Our main result is a $(\frac{1}{2}+Ω(1))$-approximation algorithm which can be implemented in $O(n^{1+ε})$ time, where $n$ is the number of vertices and the constant $ε> 0$ can be made arbitrarily small. The best known lower bound for the problem is $Ω(n)$, which holds for any constant approximation. Existing algorithms either obtain the greedy bound of $\frac{1}{2}$-approximation [Behnezhad FOCS'21], or require some assumption on the maximum degree to run in $o(n^2)$-time [Yoshida, Yamamoto, and Ito STOC'09]. We improve over these by designing a less "adaptive" augmentation algorithm for maximum matching that might be of independent interest.

cs.DS↗

arXiv2022

Almost 3-Approximate Correlation Clustering in Constant Rounds

We study parallel algorithms for correlation clustering. Each pair among $n$ objects is labeled as either "similar" or "dissimilar". The goal is to partition the objects into arbitrarily many clusters while minimizing the number of disagreements with the labels. Our main result is an algorithm that for any $ε> 0$ obtains a $(3+ε)$-approximation in $O(1/ε)$ rounds (of models such as massively parallel computation, local, and semi-streaming). This is a culminating point for the rich literature on parallel correlation clustering. On the one hand, the approximation (almost) matches a natural barrier of 3 for combinatorial algorithms. On the other hand, the algorithm's round-complexity is essentially constant. To achieve this result, we introduce a simple $O(1/ε)$-round parallel algorithm. Our main result is to provide an analysis of this algorithm, showing that it achieves a $(3+ε)$-approximation. Our analysis draws on new connections to sublinear-time algorithms. Specifically, it builds on the work of Yoshida, Yamamoto, and Ito [STOC'09] on bounding the "query complexity" of greedy maximal independent set. To our knowledge, this is the first application of this method in analyzing the approximation ratio of any algorithm.

cs.DS↗

arXiv2022

Time-Optimal Sublinear Algorithms for Matching and Vertex Cover

We study the problem of estimating the size of maximum matching and minimum vertex cover in sublinear time. Denoting the number of vertices by $n$ and the average degree in the graph by $\bar{d}$, we obtain the following results for both problems: * A multiplicative $(2+ε)$-approximation that takes $\tilde{O}(n/ε^2)$ time using adjacency list queries. * A multiplicative-additive $(2, εn)$-approximation in $\tilde{O}((\bar{d} + 1)/ε^2)$ time using adjacency list queries. * A multiplicative-additive $(2, εn)$-approximation in $\tilde{O}(n/ε^{3})$ time using adjacency matrix queries. All three results are provably time-optimal up to polylogarithmic factors culminating a long line of work on these problems. Our main contribution and the key ingredient leading to the bounds above is a new and near-tight analysis of the average query complexity of the randomized greedy maximal matching algorithm which improves upon a seminal result of Yoshida, Yamamoto, and Ito [STOC'09].

cs.DS↗

arXiv2022

New Trade-Offs for Fully Dynamic Matching via Hierarchical EDCS

We study the maximum matching problem in fully dynamic graphs: a graph is undergoing both edge insertions and deletions, and the goal is to efficiently maintain a large matching after each edge update. This problem has received considerable attention in recent years. The known algorithms naturally exhibit a trade-off between the quality of the matching maintained (i.e., the approximation ratio) and the time needed per update. While several interesting results have been obtained, the optimal behavior of this trade-off remains largely unclear. Our main contribution is a new approach to designing fully dynamic approximate matching algorithms that in a unified manner not only (essentially) recovers all previously known trade-offs that were achieved via very different techniques, but reveals some new ones as well. As our main tool to achieve this, we introduce a generalization of the edge-degree constrained subgraph (EDCS) of Bernstein and Stein (2015) that we call the hierarchical EDCS (HEDCS).

cs.DS↗

arXiv2021

Stochastic Vertex Cover with Few Queries

We study the minimum vertex cover problem in the following stochastic setting. Let $G$ be an arbitrary given graph, $p \in (0, 1]$ a parameter of the problem, and let $G_p$ be a random subgraph that includes each edge of $G$ independently with probability $p$. We are unaware of the realization $G_p$, but can learn if an edge $e$ exists in $G_p$ by querying it. The goal is to find an approximate minimum vertex cover (MVC) of $G_p$ by querying few edges of $G$ non-adaptively. This stochastic setting has been studied extensively for various problems such as minimum spanning trees, matroids, shortest paths, and matchings. To our knowledge, however, no non-trivial bound was known for MVC prior to our work. In this work, we present a: * $(2+ε)$-approximation for general graphs which queries $O(\frac{1}{ε^3 p})$ edges per vertex, and a * $1.367$-approximation for bipartite graphs which queries $poly(1/p)$ edges per vertex. Additionally, we show that at the expense of a triple-exponential dependence on $p^{-1}$ in the number of queries, the approximation ratio can be improved down to $(1+ε)$ for bipartite graphs. Our techniques also lead to improved bounds for bipartite stochastic matching. We obtain a $0.731$-approximation with nearly-linear in $1/p$ per-vertex queries. This is the first result to break the prevalent $(2/3 \sim 0.66)$-approximation barrier in the $poly(1/p)$ query regime, improving algorithms of [Behnezhad et al; SODA'19] and [Assadi and Bernstein; SOSA'19].

cs.DS↗

arXiv2021

Improved Analysis of EDCS via Gallai-Edmonds Decomposition

In this note, we revisit the edge-degree constrained subgraph (EDCS) introduced by Bernstein and Stein (ICALP'15). An EDCS is a sparse subgraph satisfying simple edge-degree constraints that is guaranteed to include an (almost) $\frac{2}{3}$-approximate matching of the base graph. Since its introduction, the EDCS has been successfully applied to numerous models of computation. Motivated by this success, we revisit EDCS and present an improved bound for its key property in general graphs. Our main result is a new proof of the approximation guarantee of EDCS that builds on the graph's Gallai-Edmonds decomposition, avoiding the probabilistic method of the previous proofs. As a result, we get that to obtain a $(\frac{2}{3} - ε)$-approximation, a sparse EDCS with maximum degree bounded by $O(1/ε)$ is sufficient. This improves the $O(\log(1/ε)/ε^2)$ bound of Assadi and Bernstein (SOSA'19) and the $O(1/ε^3)$ bound of Bernstein and Stein (SODA'16). Our guarantee essentially matches what was previously only known for bipartite graphs, thereby removing the gap in our understanding of EDCS in general vs. bipartite graphs.

cs.DS↗

arXiv2021

Beating Two-Thirds For Random-Order Streaming Matching

We study the maximum matching problem in the random-order semi-streaming setting. In this problem, the edges of an arbitrary $n$-vertex graph $G=(V, E)$ arrive in a stream one by one and in a random order. The goal is to have a single pass over the stream, use $n \cdot poly(\log n)$ space, and output a large matching of $G$. We prove that for an absolute constant $ε_0 > 0$, one can find a $(2/3 + ε_0)$-approximate maximum matching of $G$ using $O(n \log n)$ space with high probability. This breaks the natural boundary of $2/3$ for this problem prevalent in the prior work and resolves an open problem of Bernstein [ICALP'20] on whether a $(2/3 + Ω(1))$-approximation is achievable.

cs.DS↗

arXiv2020

Parallel Graph Algorithms in Constant Adaptive Rounds: Theory meets Practice

We study fundamental graph problems such as graph connectivity, minimum spanning forest (MSF), and approximate maximum (weight) matching in a distributed setting. In particular, we focus on the Adaptive Massively Parallel Computation (AMPC) model, which is a theoretical model that captures MapReduce-like computation augmented with a distributed hash table. We show the first AMPC algorithms for all of the studied problems that run in a constant number of rounds and use only $O(n^ε)$ space per machine, where $0 < ε< 1$. Our results improve both upon the previous results in the AMPC model, as well as the best-known results in the MPC model, which is the theoretical model underpinning many popular distributed computation frameworks, such as MapReduce, Hadoop, Beam, Pregel and Giraph. Finally, we provide an empirical comparison of the algorithms in the MPC and AMPC models in a fault-tolerant distriubted computation environment. We empirically evaluate our algorithms on a set of large real-world graphs and show that our AMPC algorithms can achieve improvements in both running time and round-complexity over optimized MPC baselines.

cs.DC↗

arXiv2020

Stochastic Weighted Matching: $(1-ε)$ Approximation

Let $G=(V, E)$ be a given edge-weighted graph and let its {\em realization} $\mathcal{G}$ be a random subgraph of $G$ that includes each edge $e \in E$ independently with probability $p$. In the {\em stochastic matching} problem, the goal is to pick a sparse subgraph $Q$ of $G$ without knowing the realization $\mathcal{G}$, such that the maximum weight matching among the realized edges of $Q$ (i.e. graph $Q \cap \mathcal{G}$) in expectation approximates the maximum weight matching of the whole realization $\mathcal{G}$. In this paper, we prove that for any desirably small $ε\in (0, 1)$, every graph $G$ has a subgraph $Q$ that guarantees a $(1-ε)$-approximation and has maximum degree only $O_{ε, p}(1)$. That is, the maximum degree of $Q$ depends only on $ε$ and $p$ (both of which are known to be necessary) and not for example on the number of nodes in $G$, the edge-weights, etc. The stochastic matching problem has been studied extensively on both weighted and unweighted graphs. Previously, only existence of (close to) half-approximate subgraphs was known for weighted graphs [Yamaguchi and Maehara, SODA'18; Behnezhad et al., SODA'19]. Our result substantially improves over these works, matches the state-of-the-art for unweighted graphs [Behnezhad et al., STOC'20], and essentially settles the approximation factor.

cs.DS↗

arXiv2020

Near-Optimal Massively Parallel Graph Connectivity

Identifying the connected components of a graph, apart from being a fundamental problem with countless applications, is a key primitive for many other algorithms. In this paper, we consider this problem in parallel settings. Particularly, we focus on the Massively Parallel Computations (MPC) model, which is the standard theoretical model for modern parallel frameworks such as MapReduce, Hadoop, or Spark. We consider the truly sublinear regime of MPC for graph problems where the space per machine is $n^δ$ for some desirably small constant $δ\in (0, 1)$. We present an algorithm that for graphs with diameter $D$ in the wide range $[\log^ε n, n]$, takes $O(\log D)$ rounds to identify the connected components and takes $O(\log \log n)$ rounds for all other graphs. The algorithm is randomized, succeeds with high probability, does not require prior knowledge of $D$, and uses an optimal total space of $O(m)$. We complement this by showing a conditional lower-bound based on the widely believed TwoCycle conjecture that $Ω(\log D)$ rounds are indeed necessary in this setting. Studying parallel connectivity algorithms received a resurgence of interest after the pioneering work of Andoni et al. [FOCS 2018] who presented an algorithm with $O(\log D \cdot \log \log n)$ round-complexity. Our algorithm improves this result for the whole range of values of $D$ and almost settles the problem due to the conditional lower-bound. Additionally, we show that with minimal adjustments, our algorithm can also be implemented in a variant of the (CRCW) PRAM in asymptotically the same number of rounds.

cs.DS↗