6 research outputs found
Dynamic Streaming Spectral Sparsification in Nearly Linear Time and Space
In this paper we consider the problem of computing spectral approximations to
graphs in the single pass dynamic streaming model. We provide a linear
sketching based solution that given a stream of edge insertions and deletions
to a -node undirected graph, uses space, processes each update
in time, and with high probability recovers a spectral sparsifier
in time. Prior to our work, state of the art results either used
near optimal space complexity, but brute-force
recovery time [Kapralov et al.'14], or with subquadratic runtime, but
polynomially suboptimal space complexity [Ahn et al.'14, Kapralov et al.'19].
Our main technical contribution is a novel method for `bucketing' vertices of
the input graph into clusters that allows fast recovery of edges of
sufficiently large effective resistance. Our algorithm first buckets vertices
of the graph by performing ball-carving using (an approximation to) its
effective resistance metric, and then recovers the high effective resistance
edges from a sketched version of an electrical flow between vertices in a
bucket, taking nearly linear time in the number of vertices overall. This
process is performed at different geometric scales to recover a sample of edges
with probabilities proportional to effective resistances and obtain an actual
sparsifier of the input graph.
This work provides both the first efficient -sparse recovery
algorithm for graphs and new primitives for manipulating the effective
resistance embedding of a graph, both of which we hope have further
applications
Graph Spanners in the Message-Passing Model
Graph spanners are sparse subgraphs which approximately preserve all pairwise
shortest-path distances in an input graph. The notion of approximation can be
additive, multiplicative, or both, and many variants of this problem have been
extensively studied. We study the problem of computing a graph spanner when the
edges of the input graph are distributed across two or more sites in an
arbitrary, possibly worst-case partition, and the goal is for the sites to
minimize the communication used to output a spanner. We assume the
message-passing model of communication, for which there is a point-to-point
link between all pairs of sites as well as a coordinator who is responsible for
producing the output. We stress that the subset of edges that each site has is
not related to the network topology, which is fixed to be point-to-point. While
this model has been extensively studied for related problems such as graph
connectivity, it has not been systematically studied for graph spanners. We
present the first tradeoffs for total communication versus the quality of the
spanners computed, for two or more sites, as well as for additive and
multiplicative notions of distortion. We show separations in the communication
complexity when edges are allowed to occur on multiple sites, versus when each
edge occurs on at most one site. We obtain nearly tight bounds (up to polylog
factors) for the communication of additive -spanners in both the with and
without duplication models, multiplicative -spanners in the with
duplication model, and multiplicative and -spanners in the without
duplication model. Our lower bound for multiplicative -spanners employs
biregular bipartite graphs rather than the usual Erd\H{o}s girth conjecture
graphs and may be of wider interest.Comment: ITCS 202
Two Player Hidden Pointer Chasing and Multi-Pass Lower Bounds in Turnstile Streams
The authors have withdrawn this paper due to an error in the proof of Lemma
3.4.
--------------------------------------------------------------------------------------------
The authors have withdrawn this paper due to an error in the proof of Lemma
3.4z(Assadi, Chen, and Khanna, 2019) define a 4-player hidden-pointer-chasing
(), and using it, give strong multi-pass lower bounds for graph
problems in the streaming model of computation and a lower bound on the query
complexity of sub-modular minimization. We present a two-player version
() of that has matching communication
complexity to . Our formulation allows us to lower bound its
communication complexity with a simple direct-sum argument. Using this lower
bound on the communication complexity of , we retain the
streaming and query complexity lower bounds by (Assadi, Chen, and Khanna,
2019).
Further, by giving reductions from , we prove new multi-pass
space lower bounds for graph problems in turnstile streams. In particular, we
show that any algorithm which computes the exact weight of the maximum weighted
matching in an -vertex graph requires space unless it
makes passes over the turnstile stream, and that any algorithm
which computes the minimum distance in an -vertex graph
requires space unless it makes passes over the
turnstile stream. Our reductions can be modified to use as
well.Comment: The authors have withdrawn this paper due to an error in the proof of
Lemma 3.
Sparsification of Balanced Directed Graphs
Sparsification, where the cut values of an input graph are approximately
preserved by a sparse graph (called a cut sparsifier) or a succinct data
structure (called a cut sketch), has been an influential tool in graph
algorithms. But, this tool is restricted to undirected graphs, because some
directed graphs are known to not admit sparsification. Such examples, however,
are structurally very dissimilar to undirected graphs in that they exhibit
highly unbalanced cuts. This motivates us to ask: can we sparsify a balanced
digraph?
To make this question concrete, we define balance of a digraph as the
maximum ratio of the cut value in the two directions (Ene et al., STOC 2016).
We show the following results:
For-All Sparsification: If all cut values need to be simultaneously preserved
(cf. Bencz\'ur and Karger, STOC 1996), then we show that the size of the
sparsifier (or even cut sketch) must scale linearly with . The upper
bound is a simple extension of sparsification of undirected graphs (formally
stated recently in Ikeda and Tanigawa (WAOA 2018)), so our main contribution
here is to show a matching lower bound.
For-Each Sparsification: If each cut value needs to be individually preserved
(Andoni et al., ITCS 2016), then the situation is more interesting. Here, we
give a cut sketch whose size scales with , thereby beating the
linear lower bound above. We also show that this result is tight by exhibiting
a matching lower bound of on "for-each" cut sketches.
Our upper bounds work for general weighted graphs, while the lower bounds
even hold for unweighted graphs with no parallel edges
Graph Spanners by Sketching in Dynamic Streams and the Simultaneous Communication Model
Graph sketching is a powerful technique introduced by the seminal work of
Ahn, Guha and McGregor'12 on connectivity in dynamic graph streams that has
enjoyed considerable attention in the literature since then, and has led to
near optimal dynamic streaming algorithms for many fundamental problems such as
connectivity, cut and spectral sparsifiers and matchings. Interestingly,
however, the sketching and dynamic streaming complexity of approximating the
shortest path metric of a graph is still far from well-understood. Besides a
direct -pass implementation of classical spanner constructions (recently
improved to -passes by Fernandez, Woodruff and
Yasuda'20) the state of the art amounts to a -pass algorithm of Ahn,
Guha and McGregor'12, and a -pass algorithm of Kapralov and Woodruff'14. In
particular, no single pass algorithm is known, and the optimal tradeoff between
the number of passes, stretch and space complexity is open.
In this paper we introduce several new graph sketching techniques for
approximating the shortest path metric of the input graph. We give the first
{\em single pass} sketching algorithm for constructing graph spanners: we show
how to obtain a -spanner using
space, and in general a -spanner using
space for every , a tradeoff
that we think may be close optimal. We also give new spanner construction
algorithms for any number of passes, simultaneously improving upon all prior
work on this problem. Finally, we study the simultaneous communication model
and propose the first protocols with low per player information
Online Spectral Approximation in Random Order Streams
This paper studies spectral approximation for a positive semidefinite matrix
in the online setting. It is known in [Cohen et al. APPROX 2016] that we can
construct a spectral approximation of a given matrix in the online
setting if an additive error is allowed. In this paper, we propose an online
algorithm that avoids an additive error with the same time and space
complexities as the algorithm of Cohen et al., and provides a better upper
bound on the approximation size when a given matrix has small rank. In
addition, we consider the online random order setting where a row of a given
matrix arrives uniformly at random. In this setting, we propose time and space
efficient algorithms to find a spectral approximation. Moreover, we reveal that
a lower bound on the approximation size in the online random order setting is
, which is larger than the one in the offline
setting by an factor