We show that any randomised Monte Carlo distributed algorithm for the Lovász local lemma requires Ω(log log n) communication rounds, assuming that it finds a correct assignment with high probability. Our result holds even in the special case of d = O(1), where d is the maximum degree of the dependency graph. By prior work, there are distributed algorithms for the Lovász local lemma with a running time of O(log n) rounds in bounded-degree graphs, and the best lower bound before our work was Ω(log * n) rounds [Chung et al. 2014].

We present the first conditional hardness results for massively parallel algorithms for some central graph problems including (approximating) maximum matching, vertex cover, maximal independent set, and coloring. In some cases, these hardness results match or get close to the state of the art algorithms. Our hardness results are conditioned on a widely believed conjecture in massively parallel computation about the complexity of the connectivity problem. We also note that it is known that an unconditional variant of such hardness results might be somewhat out of reach for now, as it would lead to considerably improved circuit complexity lower bounds and would concretely imply that NC 1 ⊊ P. We obtain our conditional hardness result via a general method that lifts unconditional lower bounds from the well-studied LOCAL model of distributed computing to the massively parallel computation setting.

We introduce a method for "sparsifying" distributed algorithms and exhibit how it leads to improvements that go past known barriers in two algorithmic settings of large-scale graph processing: Massively Parallel Computation (MPC), and Local Computation Algorithms (LCA). • MPC with Strongly Sublinear Memory: Recently, there has been growing interest in obtaining MPC algorithms that are faster than their classic O(log n)-round parallel (PRAM) counterparts for problems such as Maximal Independent Set (MIS), Maximal Matching, 2-Approximation of Minimum Vertex Cover, and (1+ε)-Approximation of Maximum Matching.Currently, all such MPC algorithms require memory ofΩ(n) per machine: Czumaj et al. [STOC'18] were the first to handleΩ(n) memory, running in O((log log n) 2 ) rounds, who improved on the n 1+Ω(1) memory requirement of the O(1)-round algorithm of Lattanzi et al [SPAA'11]. We obtainÕ( √ log ∆)-round MPC algorithms for all these four problems that work even when each machine has strongly sublinear memory, e.g., n α for any constant α ∈ (0, 1). Here, ∆ denotes the maximum degree. These are the first sublogarithmic-time MPC algorithms for (the general case of) these problems that break the linear memory barrier. • LCAs with Query Complexity Below the Parnas-Ron Paradigm: Currently, the best known LCA for MIS has query complexity ∆ O(log ∆) poly(log n), by Ghaffari [SODA'16], which improved over the ∆ O(log 2 ∆) poly(log n) bound of Levi et al. [Algorithmica'17]. As pointed out by Rubinfeld, obtaining a query complexity of poly(∆ log n) remains a central open question. Ghaffari's bound almost reaches a ∆ Ω( log ∆ log log ∆ ) barrier common to all known MIS LCAs, which simulate a distributed algorithm by learning the full local topology,à la Parnas-Ron [TCS'07]. There is a barrier because the distributed complexity of MIS has a lower bound of Ω log ∆ log log ∆ , by results of Kuhn, et al. [JACM '16], which means this methodology cannot go below query complexity ∆ Ω( log ∆ log log ∆ ) . We break this barrier and obtain an LCA for MIS that has a query complexity ∆ O(log log ∆) poly(log n).

In this paper, we present new randomized algorithms that improve the complexity of the classic (∆+1)-coloring problem, and its generalization (∆+1)-list-coloring, in three well-studied models of distributed, parallel, and centralized computation:Congested Clique: We present an O(1)-round randomized algorithm for (∆ + 1)-list coloring in the congested clique model of distributed computing. This settles the asymptotic complexity of this problem. It moreover improves upon the O(log * ∆)-round randomized algorithms of Parter and Su [DISC'18] and O((log log ∆) · log * ∆)-round randomized algorithm of Parter [ICALP'18]. Massively Parallel Computation: We present a (∆ + 1)-list coloring algorithm with round complexity O( √ log log n) in the Massively Parallel Computation (MPC) model with strongly sublinear memory per machine. This algorithm uses a memory of O(n α ) per machine, for any desirable constant α > 0, and a total memory of O(m), where m is the size of the graph. Notably, this is the first coloring algorithm with sublogarithmic round complexity, in the sublinear memory regime of MPC. For the quasilinear memory regime of MPC, an O(1)-round algorithm was given very recently by Assadi et al. [SODA'19]. Centralized Local Computation: We show that (∆ + 1)-list coloring can be solved with ∆ O(1) ·O(log n) query complexity, in the centralized local computation model. The previous state-of-the-art for (∆ + 1)-list coloring in the centralized local computation model are based on simulation of known LOCAL algorithms. The deterministic O( √ ∆poly log ∆ + log * n)-round LOCAL algorithm of Fraigniaud et al. [FOCS'16] can be implemented in the centralized local computation model with query complexity ∆ O( √ ∆poly log ∆) ·O(log * n); the randomized O(log * ∆) + 2 O( √ log log n) -round LOCAL algorithm of Chang et al. [STOC'18] can be implemented in the centralized local computation model with query complexity ∆ O(log * ∆) · O(log n). a significantly more relaxed problem in comparison to ∆ + 1 coloring. For instance, we have long known a very simple O(∆)-coloring algorithm in LOCAL-model algorithm with round complexity 2 O( √ log log n) [BEPS16], but only recently such a round complexity was achieved for ∆ + 1 coloring [CLP18, HSS18]. Our focus is on the much more stringent ∆ + 1 coloring problem. For this problem, the LOCAL model algorithms of [CLP18, HSS18] need messages of O(∆ 2 log n) bits, and thus do not extend to CONGEST or CONGESTED-CLIQUE. For CONGESTED-CLIQUE model, the main challenge is when ∆ > √ n, as otherwise, one can simulate the algorithm of [CLP18] by leveraging the all-toall communication in CONGESTED-CLIQUE which means each vertex in each round is capable of communicating O(n log n) bits of information. Parter [Par18] designed the first sublogarithmic-time (∆+1) coloring algorithm for CONGESTED-CLIQUE, which runs in O(log log ∆ log * ∆) rounds. The algorithm of [Par18] is able to reduce the maximum degree to O( √ n) in O(log log ∆) iterations, and each iteration invokes the algorithm of [CLP18] on instances...

No abstract

Abstract. We present a distributed 2-approximation algorithm for the minimum vertex cover problem. The algorithm is deterministic, and it runs in (∆ + 1) 2 synchronous communication rounds, where ∆ is the maximum degree of the graph. For ∆ = 3, we give a 2-approximation algorithm also for the weighted version of the problem.

No abstract

The complexity of distributed edge coloring depends heavily on the palette size as a function of the maximum degree ∆. In this paper we explore the complexity of edge coloring in the LOCAL model in different palette size regimes. Our results are as follows.• We simplify the round elimination technique of Brandt et al. [9] and prove that (2∆ − 2)-edge coloring requires Ω(log ∆ log n) time w.h.p. and Ω(log ∆ n) time deterministically, even on trees. The simplified technique is based on two ideas: the notion of an irregular running time (in which network components terminate the algorithm at prescribed, but irregular times) and some general observations that transform weak lower bounds into stronger ones.• We give a randomized edge coloring algorithm that can use palette sizes as small as ∆ +Õ( √ ∆), which is a natural barrier for randomized approaches. The running time of the algorithm is at most O(log ∆ · T LLL ), where T LLL is the complexity of a permissive version of the constructive Lovász local lemma.• We develop a new distributed Lovász local lemma algorithm for tree-structured dependency graphs, which leads to a (1 + )∆-edge coloring algorithm for trees running in O(log log n) time. This algorithm arises from two new results: a deterministic O(log n)-time LLL algorithm for tree-structured instances, and a randomized O(log log n)-time graph shattering method for breaking the dependency graph into independent O(log n)-size LLL instances.• A natural approach to computing (∆ + 1)-edge colorings (Vizing's theorem) is to extend partial colorings by iteratively re-coloring parts of the graph, e.g., via "augmenting paths." We prove that this approach may be viable, but in the worst case requires recoloring subgraphs of diameter Ω(∆ log n). This stands in contrast to distributed algorithms for Brooks' theorem [32], which exploit the existence of O(log ∆ n)-length augmenting paths.