23 research outputs found
Distributed local approximation algorithms for maximum matching in graphs and hypergraphs
We describe approximation algorithms in Linial's classic LOCAL model of
distributed computing to find maximum-weight matchings in a hypergraph of rank
. Our main result is a deterministic algorithm to generate a matching which
is an -approximation to the maximum weight matching, running in rounds. (Here, the
notations hides and factors).
This is based on a number of new derandomization techniques extending methods
of Ghaffari, Harris & Kuhn (2017).
As a main application, we obtain nearly-optimal algorithms for the
long-studied problem of maximum-weight graph matching. Specifically, we get a
approximation algorithm using randomized time and deterministic time.
The second application is a faster algorithm for hypergraph maximal matching,
a versatile subroutine introduced in Ghaffari et al. (2017) for a variety of
local graph algorithms. This gives an algorithm for -edge-list
coloring in rounds deterministically or
rounds randomly. Another consequence (with
additional optimizations) is an algorithm which generates an edge-orientation
with out-degree at most for a graph of
arboricity ; for fixed this runs in
rounds deterministically or rounds randomly
On the Locality of Nash-Williams Forest Decomposition and Star-Forest Decomposition
Given a graph with arboricity , we study the problem of
decomposing the edges of into disjoint forests in the
distributed LOCAL model. Barenboim and Elkin [PODC `08] gave a LOCAL algorithm
that computes a -forest decomposition using rounds. Ghaffari and Su [SODA `17] made further progress by
computing a -forest decomposition in rounds when ,
i.e. the limit of their algorithm is an -forest decomposition. This algorithm, based on a combinatorial
construction of Alon, McDiarmid \& Reed [Combinatorica `92], in fact provides a
decomposition of the graph into \emph{star-forests}, i.e. each forest is a
collection of stars.
Our main result in this paper is to reduce the threshold of
in -forest decomposition and star-forest decomposition.
This further answers the open question from Barenboim and
Elkin's "Distributed Graph Algorithms" book. Moreover, it gives the first
-orientation algorithms with {\it linear dependencies} on
.
At a high level, our results for forest-decomposition are based on a
combination of network decomposition, load balancing, and a new structural
result on local augmenting sequences. Our result for star-forest decomposition
uses a more careful probabilistic analysis for the construction of Alon,
McDiarmid, \& Reed; the bounds on star-arboricity here were not previously
known, even non-constructively
On Derandomizing Local Distributed Algorithms
The gap between the known randomized and deterministic local distributed
algorithms underlies arguably the most fundamental and central open question in
distributed graph algorithms. In this paper, we develop a generic and clean
recipe for derandomizing LOCAL algorithms. We also exhibit how this simple
recipe leads to significant improvements on a number of problem. Two main
results are:
- An improved distributed hypergraph maximal matching algorithm, improving on
Fischer, Ghaffari, and Kuhn [FOCS'17], and giving improved algorithms for
edge-coloring, maximum matching approximation, and low out-degree edge
orientation. The first gives an improved algorithm for Open Problem 11.4 of the
book of Barenboim and Elkin, and the last gives the first positive resolution
of their Open Problem 11.10.
- An improved distributed algorithm for the Lov\'{a}sz Local Lemma, which
gets closer to a conjecture of Chang and Pettie [FOCS'17], and moreover leads
to improved distributed algorithms for problems such as defective coloring and
-SAT.Comment: 37 page
Algorithmic and enumerative aspects of the Moser-Tardos distribution
Moser & Tardos have developed a powerful algorithmic approach (henceforth
"MT") to the Lovasz Local Lemma (LLL); the basic operation done in MT and its
variants is a search for "bad" events in a current configuration. In the
initial stage of MT, the variables are set independently. We examine the
distributions on these variables which arise during intermediate stages of MT.
We show that these configurations have a more or less "random" form, building
further on the "MT-distribution" concept of Haeupler et al. in understanding
the (intermediate and) output distribution of MT. This has a variety of
algorithmic applications; the most important is that bad events can be found
relatively quickly, improving upon MT across the complexity spectrum: it makes
some polynomial-time algorithms sub-linear (e.g., for Latin transversals, which
are of basic combinatorial interest), gives lower-degree polynomial run-times
in some settings, transforms certain super-polynomial-time algorithms into
polynomial-time ones, and leads to Las Vegas algorithms for some coloring
problems for which only Monte Carlo algorithms were known.
We show that in certain conditions when the LLL condition is violated, a
variant of the MT algorithm can still produce a distribution which avoids most
of the bad events. We show in some cases this MT variant can run faster than
the original MT algorithm itself, and develop the first-known criterion for the
case of the asymmetric LLL. This can be used to find partial Latin transversals
-- improving upon earlier bounds of Stein (1975) -- among other applications.
We furthermore give applications in enumeration, showing that most applications
(where we aim for all or most of the bad events to be avoided) have many more
solutions than known before by proving that the MT-distribution has "large"
min-entropy and hence that its support-size is large
Space-Efficient Algorithms and Verification Schemes for Graph Streams
Structured data-sets are often easy to represent using graphs. The prevalence of massive data-sets in the modern world gives rise to big graphs such as web graphs, social networks, biological networks, and citation graphs. Most of these graphs keep growing continuously and pose two major challenges in their processing: (a) it is infeasible to store them entirely in the memory of a regular server, and (b) even if stored entirely, it is incredibly inefficient to reread the whole graph every time a new query appears. Thus, a natural approach for efficiently processing and analyzing such graphs is reading them as a stream of edge insertions and deletions and maintaining a summary that can be (a) stored in affordable memory (significantly smaller than the input size) and (b) used to detect properties of the original graph. In this thesis, we explore the strengths and limitations of such graph streaming algorithms under three main paradigms: classical or standard streaming, adversarially robust streaming, and streaming verification.
In the classical streaming model, an algorithm needs to process an adversarially chosen input stream using space sublinear in the input size and return a desired output at the end of the stream. Here, we study a collection of fundamental directed graph problems like reachability, acyclicity testing, and topological sorting. Our investigation reveals that while most problems are provably hard for general digraphs, they admit efficient algorithms for the special and widely-studied subclass of tournament graphs. Further, we exhibit certain problems that become drastically easier when the stream elements arrive in random order rather than adversarial order, as well as problems that do not get much easier even under this relaxation. Furthermore, we study the graph coloring problem in this model and design color-efficient algorithms using novel parameterizations and establish complexity separations between different versions of the problem.
The classical streaming setting assumes that the entire input stream is fixed by an adversary before the algorithm reads it. Many randomized algorithms in this setting, however, fail when the stream is extended by an adaptive adversary based on past outputs received. This is the so-called adversarially robust streaming model. We show that graph coloring is significantly harder in the robust setting than in the classical setting, thus establishing the first such separation for a ``natural\u27\u27 problem. We also design a class of efficient robust coloring algorithms using novel techniques.
In classical streaming, many important problems turn out to be ``intractable\u27\u27, i.e., provably impossible to solve in sublinear space. It is then natural to consider an enhanced streaming setting where a space-bounded client outsources the computation to a space-unbounded but untrusted cloud service, who replies with the solution and a supporting ``proof\u27\u27 that the client needs to verify. This is called streaming verification or the annotated streaming model. It allows algorithms or verification schemes for the otherwise intractable problems using both space and proof length sublinear in the input size. We devise efficient schemes that improve upon the state of the art for a variety of fundamental graph problems including triangle counting, maximum matching, topological sorting, maximal independent set, graph connectivity, and shortest paths, as well as for computing frequency-based functions such as distinct items and maximum frequency, which have broad applications in graph streaming. Some of our schemes were conjectured to be impossible, while some others attain smooth and optimal tradeoffs between space and communication costs
Locality of Distributed Graph Problems
Locality is one of the central themes in distributed computing. Suppose in a network each node only has direct communication with its local neighbors, how efficiently can a global task be solved? We aim to investigate the locality of fundamental distributed graph problems. Toward this goal, we consider the following three basic abstract models of distributed computing.
• LOCAL: each device has direct communication links with its neighbors, there is no message size constraint.
• CONGEST: each device has direct communication links with its neighbors, the size of each message is at most O(log n) bits.
• CONGESTED-CLIQUE: each device has direct communication links with all other devices, the size of each message is at most O(log n) bits.
A brief summary of our results is as follows.
1. Complexity Theory for the LOCAL Model: We study the spectrum of natural problem complexities that can exist in the LOCAL model. We provide answers to the following fundamental questions regarding the nature of the LOCAL model: (i) How to classify the distributed problems according to their complexities? (ii) How much does randomness help? (iii) Can we solve more problems given more time?
2. Complexity of Distributed Coloring: The coloring problem is a classical and well-studied problem in distributed computing. We devise distributed algorithms for the edge-coloring problem and the vertex-coloring problem in the LOCAL model that improve upon the previous state of the art.
3. Bandwidth Constraint: We develop a new framework for algorithm design based on expander decompositions that allows us to apply CONGESTED-CLIQUE techniques to the CONGEST model. Using this approach, we provide improved algorithms for the triangle detection and enumeration problem in CONGEST.PHDComputer Science & EngineeringUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttps://deepblue.lib.umich.edu/bitstream/2027.42/149872/1/cyijun_1.pd