76,114 research outputs found
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
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
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 round algorithm for
maximal matching with space (or even mildly sublinear in using
standard techniques).
As an immediate corollary, we get a 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 round algorithm for
approximate matching. All these results can also be implemented in the
congested clique model within the same number of rounds.Comment: A preliminary version of this paper is to appear in the proceedings
of The 60th Annual IEEE Symposium on Foundations of Computer Science (FOCS
2019
Improved Deterministic Distributed Matching via Rounding
We present improved deterministic distributed algorithms for a number of well-studied matching problems, which are simpler, faster, more accurate, and/or more general than their known counterparts. The common denominator of these results is a deterministic distributed rounding method for certain linear programs, which is the first such rounding method, to our knowledge.
A sampling of our end results is as follows.
- An O(log^2 Delta log n)-round deterministic distributed algorithm for computing a maximal matching, in n-node graphs with maximum degree Delta. This is the first improvement in about 20 years over the celebrated O(log^4 n)-round algorithm of Hanckowiak, Karonski, and Panconesi [SODA\u2798, PODC\u2799].
- A deterministic distributed algorithm for computing a (2+epsilon)-approximation of maximum matching in O(log^2 Delta log(1/epsilon) + log^* n) rounds. This is exponentially faster than the classic O(Delta + log^* n)-round 2-approximation of Panconesi and Rizzi [DIST\u2701]. With some modifications, the algorithm can also find an epsilon-maximal matching which leaves only an epsilon-fraction of the edges on unmatched nodes.
- An O(log^2 Delta log(1/epsilon) + log^* n)-round deterministic distributed algorithm for computing a (2+epsilon)-approximation of a maximum weighted matching, and also for the more general problem of maximum weighted b-matching. These improve over the O(log^4 n log_(1+epsilon) W)-round (6+epsilon)-approximation algorithm of Panconesi and Sozio [DIST\u2710], where W denotes the maximum normalized weight.
- A deterministic local computation algorithm for a (2+epsilon)-approximation of maximum matching with 2^O(log^2 Delta) log^* n queries. This improves almost exponentially over the previous deterministic constant approximations which have query-complexity of 2^Omega(Delta log Delta) log^* n
Beating the Folklore Algorithm for Dynamic Matching
The maximum matching problem in dynamic graphs subject to edge updates (insertions and deletions) has received much attention over the last few years; a multitude of approximation/time tradeoffs were obtained, improving upon the folklore algorithm, which maintains a maximal (and hence 2-approximate) matching in O(n) worst-case update time in n-node graphs.
We present the first deterministic algorithm which outperforms the folklore algorithm in terms of both approximation ratio and worst-case update time. Specifically, we give a (2-?(1))-approximate algorithm with O(m^{3/8}) = O(n^{3/4}) worst-case update time in n-node, m-edge graphs. For sufficiently small constant ? > 0, no deterministic (2+?)-approximate algorithm with worst-case update time O(n^{0.99}) was known. Our second result is the first deterministic (2+?)-approximate weighted matching algorithm with O_?(1)? O(?{m}) = O_?(1)? O(?n) worst-case update time. Neither of our results were previously known to be achievable by a randomized algorithm against an adaptive adversary.
Our main technical contributions are threefold: first, we characterize the tight cases for kernels, which are the well-studied matching sparsifiers underlying much of the (2+?)-approximate dynamic matching literature. This characterization, together with multiple ideas - old and new - underlies our result for breaking the approximation barrier of 2. Our second technical contribution is the first example of a dynamic matching algorithm whose running time is improved due to improving the recourse of other dynamic matching algorithms. Finally, we show how to use dynamic bipartite matching algorithms as black-box subroutines for dynamic matching in general graphs without incurring the natural 3/2 factor in the approximation ratio which such approaches naturally incur (reminiscent of the integrality gap of the fractional matching polytope in general graphs)
Fully Dynamic Almost-Maximal Matching: Breaking the Polynomial Worst-Case Time Barrier
The state-of-the-art algorithm for maintaining an approximate maximum matching in fully dynamic graphs has a polynomial worst-case update time, even for poor approximation guarantees. Bhattacharya, Henzinger and Nanongkai showed how to maintain a constant approximation to the minimum vertex cover, and thus also a constant-factor estimate of the maximum matching size, with polylogarithmic worst-case update time. Later (in SODA\u2717 Proc.) they improved the approximation to 2+epsilon. Nevertheless, the fundamental problem of maintaining an approximate matching with sub-polynomial worst-case time bounds remained open.
We present a randomized algorithm for maintaining an almost-maximal matching in fully dynamic graphs with polylogarithmic worst-case update time. Such a matching provides (2+epsilon)-approximations for both maximum matching and minimum vertex cover, for any epsilon > 0. The worst-case update time of our algorithm, O(poly(log n,epsilon^{-1})), holds deterministically, while the almost-maximality guarantee holds with high probability. Our result was done independently of the (2+epsilon)-approximation result of Bhattacharya et al., thus settling the aforementioned problem on dynamic matchings and providing essentially the best possible approximation guarantee for dynamic vertex cover (assuming the unique games conjecture).
To prove this result, we exploit a connection between the standard oblivious adversarial model, which can be viewed as inherently "online", and an "offline" model where some (limited) information on the future can be revealed efficiently upon demand. Our randomized algorithm is derived from a deterministic algorithm in this offline model. This approach gives an elegant way to analyze randomized dynamic algorithms, and is of independent interest
Adaptive Out-Orientations with Applications
We give simple algorithms for maintaining edge-orientations of a
fully-dynamic graph, such that the out-degree of each vertex is bounded. On one
hand, we show how to orient the edges such that the out-degree of each vertex
is proportional to the arboricity of the graph, in a worst-case update
time of . On the other hand, motivated by applications
in dynamic maximal matching, we obtain a different trade-off, namely the
improved worst case update time of for the problem of
maintaining an edge-orientation with at most out-edges per
vertex. Since our algorithms have update times with worst-case guarantees, the
number of changes to the solution (i.e. the recourse) is naturally limited.
Our algorithms make choices based entirely on local information, which makes
them automatically adaptive to the current arboricity of the graph. In other
words, they are arboricity-oblivious, while they are arboricity-sensitive. This
both simplifies and improves upon previous work, by having fewer assumptions or
better asymptotic guarantees.
As a consequence, one obtains an algorithm with improved efficiency for
maintaining a approximation of the maximum subgraph density,
and an algorithm for dynamic maximal matching whose worst-case update time is
guaranteed to be upper bounded by , where
is the arboricity at the time of the update
Distributed Approximation of Maximum Independent Set and Maximum Matching
We present a simple distributed -approximation algorithm for maximum
weight independent set (MaxIS) in the model which completes
in rounds, where is the maximum
degree, is the number of rounds needed to compute a maximal
independent set (MIS) on , and is the maximum weight of a node. %Whether
our algorithm is randomized or deterministic depends on the \texttt{MIS}
algorithm used as a black-box.
Plugging in the best known algorithm for MIS gives a randomized solution in
rounds, where is the number of nodes.
We also present a deterministic -round algorithm based
on coloring.
We then show how to use our MaxIS approximation algorithms to compute a
-approximation for maximum weight matching without incurring any additional
round penalty in the model. We use a known reduction for
simulating algorithms on the line graph while incurring congestion, but we show
our algorithm is part of a broad family of \emph{local aggregation algorithms}
for which we describe a mechanism that allows the simulation to run in the
model without an additional overhead.
Next, we show that for maximum weight matching, relaxing the approximation
factor to () allows us to devise a distributed algorithm
requiring rounds for any constant
. For the unweighted case, we can even obtain a
-approximation in this number of rounds. These algorithms are
the first to achieve the provably optimal round complexity with respect to
dependency on
- …