arXiv subjects

Sepehr Assadi

Publications and source records attributed to Sepehr Assadi.

At least 55 records · Page 3Linked to original sources

arXiv2022

Asymptotically Optimal Bounds for Estimating H-Index in Sublinear Time with Applications to Subgraph Counting

The $h$-index is a metric used to measure the impact of a user in a publication setting, such as a member of a social network with many highly liked posts or a researcher in an academic domain with many highly cited publications. Specifically, the $h$-index of a user is the largest integer $h$ such that at least $h$ publications of the user have at least $h$ units of positive feedback. We design an algorithm that, given query access to the $n$ publications of a user and each publication's corresponding positive feedback number, outputs a $(1\pm \varepsilon)$-approximation of the $h$-index of this user with probability at least $1-δ$ in time \[ O(\frac{n \cdot \ln{(1/δ)}}{\varepsilon^2 \cdot h}), \] where $h$ is the actual $h$-index which is unknown to the algorithm a-priori. We then design a novel lower bound technique that allows us to prove that this bound is in fact asymptotically optimal for this problem in all parameters $n,h,\varepsilon,$ and $δ$. Our work is one of the first in sublinear time algorithms that addresses obtaining asymptotically optimal bounds, especially in terms of the error and confidence parameters. As such, we focus on designing novel techniques for this task. In particular, our lower bound technique seems quite general -- to showcase this, we also use our approach to prove an asymptotically optimal lower bound for the problem of estimating the number of triangles in a graph in sublinear time, which now is also optimal in the error and confidence parameters. This result improves upon prior lower bounds of Eden, Levi, Ron, and Seshadhri (FOCS'15) for this problem, as well as multiple follow-ups that extended this lower bound to other subgraph counting problems.

cs.DS↗

arXiv2022

Tight Bounds for Monotone Minimal Perfect Hashing

The monotone minimal perfect hash function (MMPHF) problem is the following indexing problem. Given a set $S= \{s_1,\ldots,s_n\}$ of $n$ distinct keys from a universe $U$ of size $u$, create a data structure $DS$ that answers the following query: \[ RankOp(q) = \text{rank of } q \text{ in } S \text{ for all } q\in S ~\text{ and arbitrary answer otherwise.} \] Solutions to the MMPHF problem are in widespread use in both theory and practice. The best upper bound known for the problem encodes $DS$ in $O(n\log\log\log u)$ bits and performs queries in $O(\log u)$ time. It has been an open problem to either improve the space upper bound or to show that this somewhat odd looking bound is tight. In this paper, we show the latter: specifically that any data structure (deterministic or randomized) for monotone minimal perfect hashing of any collection of $n$ elements from a universe of size $u$ requires $Ω(n \cdot \log\log\log{u})$ expected bits to answer every query correctly. We achieve our lower bound by defining a graph $\mathbf{G}$ where the nodes are the possible ${u \choose n}$ inputs and where two nodes are adjacent if they cannot share the same $DS$. The size of $DS$ is then lower bounded by the log of the chromatic number of $\mathbf{G}$. Finally, we show that the fractional chromatic number (and hence the chromatic number) of $\mathbf{G}$ is lower bounded by $2^{Ω(n \log\log\log u)}$.

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

Decremental Matching in General Graphs

We consider the problem of maintaining an approximate maximum integral matching in a dynamic graph $G$, while the adversary makes changes to the edges of the graph. The goal is to maintain a $(1+ε)$-approximate maximum matching for constant $ε>0$, while minimizing the update time. In the fully dynamic setting, where both edge insertion and deletions are allowed, Gupta and Peng (see \cite{GP13}) gave an algorithm for this problem with an update time of $O(\sqrt{m}/ε^2)$. Motivated by the fact that the $O_ε(\sqrt{m})$ barrier is hard to overcome (see Henzinger, Krinninger, Nanongkai, and Saranurak [HKNS15]); Kopelowitz, Pettie, and Porat [KPP16]), we study this problem in the \emph{decremental} model, where the adversary is only allowed to delete edges. Recently, Bernstein, Probst-Gutenberg, and Saranurak (see [BPT20]) gave an $O_ε(1)$ update time decremental algorithm for this problem in \emph{bipartite graphs}. However, beating $O(\sqrt{m})$ update time remained an open problem for \emph{general graphs}. In this paper, we bridge the gap between bipartite and general graphs, by giving an $O_ε(1)$ update time algorithm that maintains a $(1+ε)$-approximate maximum integral matching under adversarial deletions. Our algorithm is randomized, but works against an adaptive adversary. Together with the work of Grandoni, Leonardi, Sankowski, Schwiegelshohn, and Solomon [GLSSS19] who give an $O_ε(1)$ update time algorithm for general graphs in the \emph{incremental} (insertion-only) model, our result essentially completes the picture for partially dynamic matching.

cs.DS↗

arXiv2022

Hierarchical Clustering in Graph Streams: Single-Pass Algorithms and Space Lower Bounds

The Hierarchical Clustering (HC) problem consists of building a hierarchy of clusters to represent a given dataset. Motivated by the modern large-scale applications, we study the problem in the \streaming model, in which the memory is heavily limited and only a single or very few passes over the input are allowed. Specifically, we investigate whether a good hierarchical clustering can be obtained, or at least whether we can approximately estimate the value of the optimal hierarchy. To measure the quality of a hierarchy, we use the HC minimization objective introduced by Dasgupta. Assuming that the input is an $n$-vertex weighted graph whose edges arrive in a stream, we derive the following results on space-vs-accuracy tradeoffs: * With $O(n\cdot \text{polylog}\,{n})$ space, we develop a single-pass algorithm, whose approximation ratio matches the currently best offline algorithm. * When the space is more limited, namely, $n^{1-o(1)}$, we prove that no algorithm can even estimate the value of optimum HC tree to within an $o(\frac{\log{n}}{\log\log{n}})$ factor, even when allowed $\text{polylog}{\,{n}}$ passes over the input. * In the most stringent setting of $\text{polylog}\,{n}$ space, we rule out algorithms that can even distinguish between "highly"-vs-"poorly" clusterable graphs, namely, graphs that have an $n^{1/2-o(1)}$ factor gap between their HC objective value. * Finally, we prove that any single-pass streaming algorithm that computes an optimal HC tree requires to store almost the entire input even if allowed exponential time. Our algorithmic results establish a general structural result that proves that cut sparsifiers of input graph can preserve cost of "balanced" HC trees to within a constant factor. Our lower bound results include a new streaming lower bound for a novel problem "One-vs-Many-Expanders", which can be of independent interest.

cs.DS↗

arXiv2022

An Asymptotically Optimal Algorithm for Maximum Matching in Dynamic Streams

We present an algorithm for the maximum matching problem in dynamic (insertion-deletions) streams with *asymptotically optimal* space complexity: for any $n$-vertex graph, our algorithm with high probability outputs an $α$-approximate matching in a single pass using $O(n^2/α^3)$ bits of space. A long line of work on the dynamic streaming matching problem has reduced the gap between space upper and lower bounds first to $n^{o(1)}$ factors [Assadi-Khanna-Li-Yaroslavtsev; SODA 2016] and subsequently to $\text{polylog}{(n)}$ factors [Dark-Konrad; CCC 2020]. Our upper bound now matches the Dark-Konrad lower bound up to $O(1)$ factors, thus completing this research direction. Our approach consists of two main steps: we first (provably) identify a family of graphs, similar to the instances used in prior work to establish the lower bounds for this problem, as the only "hard" instances to focus on. These graphs include an induced subgraph which is both sparse and contains a large matching. We then design a dynamic streaming algorithm for this family of graphs which is more efficient than prior work. The key to this efficiency is a novel sketching method, which bypasses the typical loss of $\text{polylog}{(n)}$-factors in space compared to standard $L_0$-sampling primitives, and can be of independent interest in designing optimal algorithms for other streaming problems.

cs.DS↗

arXiv2021

Deterministic Graph Coloring in the Streaming Model

Recent breakthroughs in graph streaming have led to the design of single-pass semi-streaming algorithms for various graph coloring problems such as $(Δ+1)$-coloring, degeneracy-coloring, coloring triangle-free graphs, and others. These algorithms are all randomized in crucial ways and whether or not there is any deterministic analogue of them has remained an important open question in this line of work. We settle this fundamental question by proving that there is no deterministic single-pass semi-streaming algorithm that given a graph $G$ with maximum degree $Δ$, can output a proper coloring of $G$ using any number of colors which is sub-exponential in $Δ$. Our proof is based on analyzing the multi-party communication complexity of a related communication game, using random graph theory type arguments that may be of independent interest. We complement our lower bound by showing that just one extra pass over the input allows one to recover an $O(Δ^2)$ coloring via a deterministic semi-streaming algorithm. This result is further extended to an $O(Δ)$ coloring in $O(\logΔ)$ passes even in dynamic streams.

cs.DS↗

arXiv2021

Sublinear Time and Space Algorithms for Correlation Clustering via Sparse-Dense Decompositions

We present a new approach for solving (minimum disagreement) correlation clustering that results in sublinear algorithms with highly efficient time and space complexity for this problem. In particular, we obtain the following algorithms for $n$-vertex $(+/-)$-labeled graphs $G$: -- A sublinear-time algorithm that with high probability returns a constant approximation clustering of $G$ in $O(n\log^2{n})$ time assuming access to the adjacency list of the $(+)$-labeled edges of $G$ (this is almost quadratically faster than even reading the input once). Previously, no sublinear-time algorithm was known for this problem with any multiplicative approximation guarantee. -- A semi-streaming algorithm that with high probability returns a constant approximation clustering of $G$ in $O(n\log{n})$ space and a single pass over the edges of the graph $G$ (this memory is almost quadratically smaller than input size). Previously, no single-pass algorithm with $o(n^2)$ space was known for this problem with any approximation guarantee. The main ingredient of our approach is a novel connection to sparse-dense graph decompositions that are used extensively in the graph coloring literature. To our knowledge, this connection is the first application of these decompositions beyond graph coloring, and in particular for the correlation clustering problem, and can be of independent interest.

cs.DS↗

arXiv2021

A Two-Pass Lower Bound for Semi-Streaming Maximum Matching

We prove a lower bound on the space complexity of two-pass semi-streaming algorithms that approximate the maximum matching problem. The lower bound is parameterized by the density of Ruzsa-Szemeredi graphs: * Any two-pass semi-streaming algorithm for maximum matching has approximation ratio at least $(1- Ω(\frac{\log{RS(n)}}{\log{n}}))$, where $RS(n)$ denotes the maximum number of induced matchings of size $Θ(n)$ in any $n$-vertex graph, i.e., the largest density of a Ruzsa-Szemeredi graph. Currently, it is known that $n^{Ω(1/\!\log\log{n})} \leq RS(n) \leq \frac{n}{2^{O(\log^*{\!(n)})}}$ and closing this (large) gap between upper and lower bounds has remained a notoriously difficult problem in combinatorics. Under the plausible hypothesis that $RS(n) = n^{Ω(1)}$, our lower bound is the first to rule out small-constant approximation two-pass semi-streaming algorithms for the maximum matching problem, making progress on a longstanding open question in the graph streaming literature.

cs.DS↗

arXiv2021

Semi-Streaming Bipartite Matching in Fewer Passes and Optimal Space

We provide $\widetilde{O}(ε^{-1})$-pass semi-streaming algorithms for computing $(1-ε)$-approximate maximum cardinality matchings in bipartite graphs. Our most efficient methods are deterministic and use optimal, $O(n)$, space, improving upon the space complexity of the previous state-of-the-art $\widetilde{O}(ε^{-1})$-pass algorithm of Ahn and Guha. To obtain our results we provide semi-streaming adaptations of more general continuous optimization tools. Further, we leverage these techniques to obtain improvements for streaming variants of approximate linear programming, optimal transport, exact matching, transshipment, and shortest path problems.

cs.DS↗

arXiv2021

Graph Connectivity and Single Element Recovery via Linear and OR Queries

We study the problem of finding a spanning forest in an undirected, $n$-vertex multi-graph under two basic query models. One is the Linear query model which are linear measurements on the incidence vector induced by the edges; the other is the weaker OR query model which only reveals whether a given subset of plausible edges is empty or not. At the heart of our study lies a fundamental problem which we call the {\em single element recovery} problem: given a non-negative real vector $x$ in $N$ dimension, return a single element $x_j > 0$ from the support. Queries can be made in rounds, and our goals is to understand the trade-offs between the query complexity and the rounds of adaptivity needed to solve these problems, for both deterministic and randomized algorithms. These questions have connections and ramifications to multiple areas such as sketching, streaming, graph reconstruction, and compressed sensing. Our main results are: * For the single element recovery problem, it is easy to obtain a deterministic, $r$-round algorithm which makes $(N^{1/r}-1)$-queries per-round. We prove that this is tight: any $r$-round deterministic algorithm must make $\geq (N^{1/r} - 1)$ linear queries in some round. In contrast, a $1$-round $O(\log^2 N)$-query randomized algorithm which succeeds 99% of the time is known to exist. * We design a deterministic $O(r)$-round, $\tilde{O}(n^{1+1/r})$-OR query algorithm for graph connectivity. We complement this with an $\tildeΩ(n^{1 + 1/r})$-lower bound for any $r$-round deterministic algorithm in the OR-model. * We design a randomized, $2$-round algorithm for the graph connectivity problem which makes $\tilde{O}(n)$-OR queries. In contrast, we prove that any $1$-round algorithm (possibly randomized) requires $\tildeΩ(n^2)$-OR queries.

cs.DS↗

arXiv2021

Fully Dynamic Set Cover via Hypergraph Maximal Matching: An Optimal Approximation Through a Local Approach

In the (fully) dynamic set cover problem, we have a collection of $m$ sets from a universe of size $n$ that undergo element insertions and deletions; the goal is to maintain an approximate set cover of the universe after each update. We give an $O(f^2)$ update time algorithm for this problem that achieves an $f$-approximation, where $f$ is the maximum number of sets that an element belongs to; under the unique games conjecture, this approximation is best possible for any fixed $f$. This is the first algorithm for dynamic set cover with approximation ratio that {exactly} matches $f$ (as opposed to {almost} $f$ in prior work), as well as the first one with runtime \emph{independent of $n,m$} (for any approximation factor of $o(f^3)$). Prior to our work, the state-of-the-art algorithms for this problem were $O(f^2)$ update time algorithms of Gupta et al. [STOC'17] and Bhattacharya et al. [IPCO'17] with $O(f^3)$ approximation, and the recent algorithm of Bhattacharya et al. [FOCS'19] with $O(f \cdot \log{n}/ε^2)$ update time and $(1+ε) \cdot f$ approximation, improving the $O(f^2 \cdot \log{n}/ε^5)$ bound of Abboud et al. [STOC'19]. The key technical ingredient of our work is an algorithm for maintaining a {maximal} matching in a dynamic hypergraph of rank $r$, where each hyperedge has at most $r$ vertices, which undergoes hyperedge insertions and deletions in $O(r^2)$ amortized update time; our algorithm is randomized, and the bound on the update time holds in expectation and with high probability. This result generalizes the maximal matching algorithm of Solomon [FOCS'16] with constant update time in ordinary graphs to hypergraphs, and is of independent merit; the previous state-of-the-art algorithms for set cover do not translate to (integral) matchings for hypergraphs, let alone a maximal one. Our quantitative result for the set cover problem is [...]

cs.DS↗

arXiv2021

Multi-Pass Graph Streaming Lower Bounds for Cycle Counting, MAX-CUT, Matching Size, and Other Problems

Consider the following gap cycle counting problem in the streaming model: The edges of a $2$-regular $n$-vertex graph $G$ are arriving one-by-one in a stream and we are promised that $G$ is a disjoint union of either $k$-cycles or $2k$-cycles for some small $k$; the goal is to distinguish between these two cases. Verbin and Yu [SODA 2011] introduced this problem and showed that any single-pass streaming algorithm solving it requires $n^{1-Ω(\frac{1}{k})}$ space. This result and the technique behind it -- the Boolean Hidden Hypermatching communication problem -- has since been used extensively for proving streaming lower bounds for various problems. Despite its significance and broad range of applications, the lower bound technique of Verbin and Yu comes with a key weakness that is inherited by all subsequent results: the Boolean Hidden Hypermatching problem is hard only if there is exactly one round of communication and can be solved with logarithmic communication in two rounds. Therefore, all streaming lower bounds derived from this problem only hold for single-pass algorithms. We prove the first multi-pass lower bound for the gap cycle counting problem: Any $p$-pass streaming algorithm that can distinguish between disjoint union of $k$-cycles vs $2k$-cycles -- or even $k$-cycles vs one Hamiltonian cycle -- requires $n^{1-\frac{1}{k^{Ω(1/p)}}}$ space. As a corollary of this result, we can extend many of previous lower bounds to multi-pass algorithms. For instance, we can now prove that any streaming algorithm that $(1+ε)$-approximates the value of MAX-CUT, maximum matching size, or rank of an $n$-by-$n$ matrix, requires either $n^{Ω(1)}$ space or $Ω(\log{(\frac{1}ε)})$ passes. For all these problems, prior work left open the possibility of even an $O(\log{n})$ space algorithm in only two passes.

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

Improved Bounds for Distributed Load Balancing

In the load balancing problem, the input is an $n$-vertex bipartite graph $G = (C \cup S, E)$ and a positive weight for each client $c \in C$. The algorithm must assign each client $c \in C$ to an adjacent server $s \in S$. The load of a server is then the weighted sum of all the clients assigned to it, and the goal is to compute an assignment that minimizes some function of the server loads, typically either the maximum server load (i.e., the $\ell_{\infty}$-norm) or the $\ell_p$-norm of the server loads. We study load balancing in the distributed setting. There are two existing results in the CONGEST model. Czygrinow et al. [DISC 2012] showed a 2-approximation for unweighted clients with round-complexity $O(Δ^5)$, where $Δ$ is the maximum degree of the input graph. Halldórsson et al. [SPAA 2015] showed an $O(\log{n}/\log\log{n})$-approximation for unweighted clients and $O(\log^2\!{n}/\log\log{n})$-approximation for weighted clients with round-complexity polylog$(n)$. In this paper, we show the first distributed algorithms to compute an $O(1)$-approximation to the load balancing problem in polylog$(n)$ rounds. In the CONGEST model, we give an $O(1)$-approximation algorithm in polylog$(n)$ rounds for unweighted clients. For weighted clients, the approximation ratio is $O(\log{n})$. In the less constrained LOCAL model, we give an $O(1)$-approximation algorithm for weighted clients in polylog$(n)$ rounds. Our approach also has implications for the standard sequential setting in which we obtain the first $O(1)$-approximation for this problem that runs in near-linear time. A 2-approximation is already known, but it requires solving a linear program and is hence much slower. Finally, we note that all of our results simultaneously approximate all $\ell_p$-norms, including the $\ell_{\infty}$-norm.

cs.DC↗

arXiv2020

Separating the Communication Complexity of Truthful and Non-Truthful Combinatorial Auctions

We provide the first separation in the approximation guarantee achievable by truthful and non-truthful combinatorial auctions with polynomial communication. Specifically, we prove that any truthful mechanism guaranteeing a $(\frac{3}{4}-\frac{1}{240}+\varepsilon)$-approximation for two buyers with XOS valuations over $m$ items requires $\exp(Ω(\varepsilon^2 \cdot m))$ communication, whereas a non-truthful algorithm by Dobzinski and Schapira [SODA 2006] and Feige [2009] is already known to achieve a $\frac{3}{4}$-approximation in $poly(m)$ communication. We obtain our separation by proving that any {simultaneous} protocol ({not} necessarily truthful) which guarantees a $(\frac{3}{4}-\frac{1}{240}+\varepsilon)$-approximation requires communication $\exp(Ω(\varepsilon^2 \cdot m))$. The taxation complexity framework of Dobzinski [FOCS 2016] extends this lower bound to all truthful mechanisms (including interactive truthful mechanisms).

cs.GT↗

arXiv2020

Improved Truthful Mechanisms for Subadditive Combinatorial Auctions: Breaking the Logarithmic Barrier

We present a computationally-efficient truthful mechanism for combinatorial auctions with subadditive bidders that achieves an $O((\log\!\log{m})^3)$-approximation to the maximum welfare in expectation using $O(n)$ demand queries; here $m$ and $n$ are the number of items and bidders, respectively. This breaks the longstanding logarithmic barrier for the problem dating back to the $O(\log{m}\cdot\log\!\log{m})$-approximation mechanism of Dobzinski from 2007. Along the way, we also improve and considerably simplify the state-of-the-art mechanisms for submodular bidders.

cs.GT↗

arXiv2020

Palette Sparsification Beyond $(Δ+1)$ Vertex Coloring

A recent palette sparsification theorem of Assadi, Chen, and Khanna [SODA'19] states that in every $n$-vertex graph $G$ with maximum degree $Δ$, sampling $O(\log{n})$ colors per each vertex independently from $Δ+1$ colors almost certainly allows for proper coloring of $G$ from the sampled colors. Besides being a combinatorial statement of its own independent interest, this theorem was shown to have various applications to design of algorithms for $(Δ+1)$ coloring in different models of computation on massive graphs such as streaming or sublinear-time algorithms. In this paper, we further study palette sparsification problems: * We prove that for $(1+\varepsilon) Δ$ coloring, sampling only $O_{\varepsilon}(\sqrt{\log{n}})$ colors per vertex is sufficient and necessary to obtain a proper coloring from the sampled colors. * A natural family of graphs with chromatic number much smaller than $(Δ+1)$ are triangle-free graphs which are $O(\fracΔ{\lnΔ})$ colorable. We prove that sampling $O(Δ^γ + \sqrt{\log{n}})$ colors per vertex is sufficient and necessary to obtain a proper $O_γ(\fracΔ{\lnΔ})$ coloring of triangle-free graphs. * We show that sampling $O_{\varepsilon}(\log{n})$ colors per vertex is sufficient for proper coloring of any graph with high probability whenever each vertex is sampling from a list of $(1+\varepsilon) \cdot deg(v)$ arbitrary colors, or even only $deg(v)+1$ colors when the lists are the sets $\{1,\ldots,deg(v)+1\}$. Similar to previous work, our new palette sparsification results naturally lead to a host of new and/or improved algorithms for vertex coloring in different models including streaming and sublinear-time algorithms.

cs.DS↗