Sublogarithmic Distributed Algorithms for Lov\'asz Local Lemma, and the Complexity Hierarchy
D I S C
Sublogarithmic Distributed Algorithms for Lov?sz Local Lemma, and the Complexity Hierarchy?
Manuela Fischer 0
Mohsen Ghaffari 0
0 ETH Zu?rich , Switzerland ETH Zu?rich , Switzerland
Locally Checkable Labeling (LCL) problems include essentially all the classic problems of LOCAL distributed algorithms. In a recent enlightening revelation, Chang and Pettie [FOCS'17] showed that any LCL (on bounded degree graphs) that has an o(log n)round randomized algorithm can be solved in TLLL(n) rounds, which is the randomized complexity of solving (a relaxed variant of) the Lov?sz Local Lemma (LLL) on bounded degree nnode graphs. Currently, the best known upper bound on TLLL(n) is O(log n), by Chung, Pettie, and Su [PODC'14], while the best known lower bound is ?(log log n), by Brandt et al. [STOC'16]. Chang and Pettie conjectured that there should be an O(log log n)round algorithm (on bounded degree graphs). Making the first step of progress towards this conjecture, and providing a significant improvement on the algorithm of Chung et al. [PODC'14], we prove that TLLL(n) = 2O(?log log n). Thus, any o(log n)round randomized distributed algorithm for any LCL problem on bounded degree graphs can be automatically sped up to run in 2O(?log log n) rounds. Using this improvement and a number of other ideas, we also improve the complexity of a number of graph coloring problems (in arbitrary degree graphs) from the O(log n)round results of Chung, Pettie and Su [PODC'14] to 2O(?log log n). These problems include defective coloring, frugal coloring, and list vertexcoloring. The Lov?sz Local Lemma (LLL), introduced by Erd?s and Lov?sz in 1975 [14], is a beautiful result which shows that, for a set of ?bad events? in a probability space that have certain sparse dependencies, there is a nonzero probability that none of them happens. This result has become a central tool in the probabilistic method [2], when proving that certain combinatorial objects exist. Although the LLL itself does not provide an efficient way for finding these objects, and that remained open for about 15 years, a number of efficient centralized algorithms have been developed for it, starting with Beck's breakthrough in 1991 [7], through [1, 13, 26, 28, 33], and leading to the elegant algorithm of Moser and Tardos in 2010 [29]. See also [9, 19, 2124] for some of the related work on that track.
and phrases Distributed Graph Algorithms; the Lov?sz Local Lemma (LLL); Locally Checkable Labeling problems (LCL); Defective Coloring; Frugal Coloring; List VertexColoring

In contrast, distributed algorithms for LLL and the related complexity are less
wellunderstood. This question has gained an extraordinary significance recently, due to revelations
that show that LLL is a ?complete? problem for sublogarithmictime problems. Next, we
first overview the concrete statement of the LLL, and then discuss what is known about its
distributed complexity, and what its special significance is for distributed algorithms. Then
we proceed to presenting our contributions.
1.1
The LLL and its Special Role in Distributed Algorithms
The Lov?sz Local Lemma. Consider a finite set V of independent random variables, and a
finite family X of n (bad) events on these variables. Each event A ? X depends on some subset
vbl(A) ? V of variables. Define the dependency graph GX = (X , {(A, B)  vbl(A) ? vbl(B) 6=
?}) that connects any two events which share at least one variable. Let d be the maximum
degree in this graph, i.e., each event A ? X shares variables with at most d other events
B ? X . Finally, define p = maxA?X Pr[A]. The Lov?sz Local Lemma [14] shows that
Pr[?A?X A?] > 0, under the LLL criterion that epd ? 1. Intuitively, if a local union bound is
satisfied around each node in GX , with some slack, then there is a positive probability to
avoid all bad events.
What?s Known about Distributed LLL? In the standard distributed formulation of LLL,
we consider LOCALmodel [25, 32] algorithms that work on the nnode dependency graph
GX , where per round each node can send a message to each of its neighbors1.
Moser and Tardos [29] provided an O(log2 n)round randomized distributed algorithm.
Chung, Pettie, and Su [12] presented an O(log n ? log2 d)round algorithm, which was later
improved slightly to O(log n?log d) [17]. Perhaps more importantly, under a modestly stronger
criterion that epd2 < 1, which is satisfied in most of the standard applications, they gave an
O(log n)round algorithm [12]. This remains the best known distributed algorithm. On the
other hand, Brandt et al. [8] showed a lower bound of ?(log log n) rounds, which holds even if
a much stronger LLL criterion of p2d < 1 is satisfied. Even under this exponentially stronger
criterion, the best known upper bound changed only slightly to O(log n/ log log n) [12].
Completeness of LLL for Sublogarithmic Distributed Algorithms. Chang and Pettie [11]
showed that any o(log n)round randomized algorithm A for any Locally Checkable Labeling
(LCL) problem P ? a problem whose solution can be checked in O(1) rounds [30], which
includes all the classic local problems ? on bounded degree graphs can be transformed to an
algorithm with complexity O(TLLL(n)). Here, TLLL(n) denotes the randomized complexity
for solving LLL on nnode boundeddegree graphs, with high probability.
In a nutshell, their idea is to ?lie? to the algorithm A and say that the network size is some
much smaller value n? n. This deceived algorithm A may have a substantial probability
to fail, creating an output that violates the requirements of the LCL problem P somewhere.
However, the probability of failure in each local neighborhood is at most 1/n?. Choosing n?
a large enough constant, depending on the complexity of A, the algorithm A provides an
LLL system ? where we have one bad event for violation of each local requirement of P ?
that satisfies the criterion pdc < 1 for a desirably large constant c. Hence, we can solve this
LLL system and thus obtain a solution for the original LCL problem P in O(TLLL(n)) time.
1 One can imagine a few alternative graph formulations, all of which turn out to be essentially equivalent
in the LOCAL model, up to an O(1) overhead in complexity.
This result implies that LLL is important not only for a few special problems, but in
fact for essentially all sublogarithmictime distributed problems. Due to this remarkable
role, Chang and Pettie state that ?understanding the distributed complexity of the LLL is a
significant open problem.? Furthermore, although a wide gap between the best upper bound
O(log n) [12] and lower bound ?(log log n) [8] persists, they conjecture the latter to be tight:
I Conjecture (Chang, Pettie [11]). There exists a sufficiently large constant c such that the
distributed LLL problem can be solved in O(log log n) time on bounded degree graphs, under
the symmetric LLL criterion pdc < 1.2
1.2
Our Contributions
Faster Distributed LLL.
We make a significant step of progress towards this conjecture:
I Theorem 1. There is a 2O(?log log n)round randomized distributed algorithm that, with
high probability3, solves the LLL problem with degree at most d = O(log1/5 log n), under a
symmetric polynomial LLL criterion p(ed)32 < 1.4
This improves over the O(log n)round algorithm of Chung et al. [12]. We note that even
under a significantly stronger exponential LLL criterion ? formally requiring 4ep2dd4 < 1 ?
the best known round complexity was O(log n/ log log n) [12]. Furthermore, we note that
a key ingredient in developing Theorem 1 is a deterministic distributed algorithm for LLL,
which we present in Theorem 11. To the best of our knowledge, this is the first (nontrivial)
deterministic distributed LLL algorithm. In fact, we believe that any conceivable future
improvements on Theorem 1 may have to improve on this deterministic part.
Moreover, our method provides some further supporting evidence for the conjecture of
Chang and Pettie. In particular, if one finds a poly log nround deterministic algorithm for
O(log n), O(log n) network decomposition [31] ? a central problem that has remained open
for a quarter century, but is often perceived as likely to be true ? then, combining that with
our method would prove TLLL(n) = poly(log log n).
A Gap in the Randomized Distributed Complexity Hierarchy.
Theorem 6], we get the following automatic speedup result:
Putting Theorem 1 with [11,
I Corollary 2. Let A be a randomized LOCAL algorithm that solves some LCL problem P
on bounded degree graphs, w.h.p., in o(log n) rounds. Then, it is possible to transform A into
a new randomized LOCAL algorithm A0 that solves P, w.h.p., in 2O(?log log n) rounds.
Using a similar method, and our deterministic LLL algorithm (Theorem 11), we obtain
the following corollary, the proof of which is deferred to the full version [15]. This corollary
shows that any o(log log n)round randomized algorithm for an LCL problem on bounded
degree graphs can be improved to a deterministic O(log? n)round algorithm. This result
seems to be implicit in the recent work of Chang, Kopelowitz, and Pettie [10], though with a
quite different proof, and it can be derived from [10, Corollary 3] and [10, Theorem 3].
2 This statement, as is, has a small imprecision: one should assume either that d ? 2, in which case
pdc < 1 can be replaced with p(ed)c0 < 1 for some other constant c0, or that pdc < 1/2. Otherwise, two
events of head or tail for a fair coin have p = 1/2 and d = 1, thus pdc < 1, but one cannot avoid both.
3 As standard, the phrase with high probability (w.h.p.) indicates that an event has probability at least
1 ? n?c, for a sufficiently large constant c.
4 We remark that we did not try to optimize the constants.
I Corollary 3. Let A be a randomized LOCAL algorithm that solves some LCL problem P
on bounded degree graphs, w.h.p., in o(log log n) rounds. Then, it is possible to transform A
into a new deterministic LOCAL algorithm A0 that solves P in O(log? n) rounds.
Faster Distributed Algorithms for Graph Colorings via LLL. For some distributed graph
problems on bounded degree graphs, we can immediately get faster algorithms by applying
Theorem 1. However, there are two quantifiers which appear to limit the applicability
of Theorem 1: (L1) it requires a stronger form of the LLL criterion, concretely needing
p(ed)32 < 1 instead of epd ? 1; (L2) it applies mainly to bounded degree graphs.
We explain how to overcome these two limitations in most of the LLLbased problems
studied by Chung, Pettie, and Su [12]. Regarding limitation (L1), we show that even though
in many coloring problems the direct LLL formulation would not satisfy the polynomial
criterion p(ed)32 < 1, we can still solve the problem, through a number of iterations of partial
colorings, each satisfying this stronger LLL criterion. Regarding limitation (L2), we explain
how in many problems, the first step of our LLL algorithm, which is its only part that relies
on bounded degrees, can be replaced by a faster randomized step for that coloring.
The end results of our method include algorithms with round complexity 2O(?log log n) for
a number of coloring problems, improving on the corresponding O(log n)round algorithms
of Chung, Pettie, and Su [12]: defective coloring, frugal coloring, and list vertexcoloring.
The first two are presented respectively, in Section 4, Section 5. The third coloring result, as
well as some of the proofs, are deferred to the full version of this article [15].
2
2.1
Preliminaries
Network Decompositions
Roughly speaking, a network decomposition [4, 31] partitions the nodes into a few blocks,
each of which is made of a number of lowdiameter connected components. More formally,
the definition is as follows:
I Definition 4 (Network Decomposition). Given a graph G = (V, E), a partition of the nodes
V into C vertexdisjoint blocks V1, V2, . . . , VC is a (C, D) network decomposition if in each
block?s induced subgraph G[Vi] each connected component has diameter at most D.
I Lemma 5 (The Network Decomposition Algorithm). Given an nnode network G = (V, E),
there is a deterministic distributed algorithm that computes a (?, n1/? ? log n) network
decomposition of G in ? ? n1/? ? 2O(?log n) rounds.
The proof of Lemma 5 is deferred to the full version; it works mainly by putting together
some ideas of Awerbuch and Peleg [5], Panconesi and Srinivasan [31], and Awerbuch et al. [3].
However, we are not aware of this result appearing in prior work.
2.2
Shattering
In a number of our algorithms, we make use of the following lemma which, roughly speaking,
shows that if each node of the graph remains with some small probability and we have
certain independence between these events, the remaining connected components are ?small?.
We remark that this lemma or its variants are key ingredients in Beck?s LLL method
[7], sometimes referred to as the shattering lemma, and analogues of it appear in the
literature [1, 6, 17, 18, 20, 26, 27]. The proof of this lemma is deferred to the full version.
I Lemma 6 (The Shattering Lemma). Let G = (V, E) be a graph with maximum degree ?.
Consider a process which generates a random subset B ? V where P (v ? B) ? ??c1 , for
some constant c1 ? 1, and that the random variables 1(v ? B) depend only on the randomness
of nodes within at most c2 hops from v, for all v ? V , for some constant c2 ? 1. Moreover,
let H = G[2c2+1,4c2+2] be the graph which contains an edge between u and v iff their distance
in G is between 2c2 + 1 and 4c2 + 2. Then with probability at least 1 ? n?c3 , for any constant
c3 < c1 ? 4c2 ? 2, we have the following three properties:
(P1) H[B] has no connected component U with U  ? log? n.
(P2) G[B] has size at most O log? n ? ?2c2 .
(P3) Each connected component of G[B] admits a (?, O(log1/? n ? log2 log n)) network
decomposition, for any integer ? ? 1, which can be computed in ? ? log1/? n ? 2O(?log log n)
rounds, deterministically.
3
Our General Algorithm for Lov?sz Local Lemma
In this section, we explain our sublogarithmictime LLL algorithm of Theorem 1, which solves
LLL in 2O(?log log n) rounds on bounded degree graphs, given the condition that p(ed)32 < 1.
The Lov?sz Local Lemma Setting. We consider a finite set V of independent random
variables, and a finite family X of n bad events on these variables. Each event A ? X depends
on some subset vbl(A) ? V of variables. In fact, essentially without loss of generality, we
assume that each random variable in V is a fair random bit. We note that in practically all
settings of interest, we can rewrite the basic random variables as a function of at most poly(n)
independent random bits, hence transitioning from arbitrary set of random variables to
another space of random variables with just fair random bits. The number of random bits will
impact only the local computations and as such, since we are working in the local model which
does not assume a limited computational power, we can allow the number of random bits to
be arbitrarily large. The distributed algorithms that we describe work on the dependency
graph of the events, defined as GX = (X , {(A, B)  vbl(A) ? vbl(B) 6= ?}). That is, this
graph has one vertex for each event and that connects any two events which share at least
one variable. Then, d denotes the maximum degree in this graph, and p = maxA?X Pr[A].
Our General LLL Algorithm. The algorithm is developed in two stages, as we overview
next. In the first stage, presented in Section 3.1, we explain a randomized algorithm with
complexity ? ? log1/? n ? 2O(?log log n), given that an LLL criterion p(ed)4? < 1 is satisfied.
In the main regime of interest, the best LLL criterion exponent that we will assume is
? = O(1), and thus this (? ? log1/? n ? 2O(?log log n))round algorithm, on its own, would not
get us to our target complexity of 2O(?log log n), although still being an improvement on the
O(log n)round algorithm of [12].
In the second stage, presented in Section 3.2, we improve this complexity to 2O(?log log n).
That improvement works mainly by viewing the sublogarithmictime local algorithm of
Section 3.1 as setting up a new LLL, with a much larger exponent ? in its LLL criterion,
hence allowing us get to a much smaller complexity by (recursively) applying the same
scheme. This speed up is inspired by the ideas of Chung and Pettie [11] which showed that
LLL can be used to speed up sublogarithmictime local algorithms.5
5 Though, we find this recursive application of the idea to speed up the complexity of LLL itself, through
3.1
The Base LLL Algorithm
I Theorem 7. For any integer ? ? 8, there is a randomized distributed algorithm solving the
LLL problem under the symmetric criterion p(ed)4? < 1, in O(d2) + ? ? log1/? n ? 2O(?log log n)
rounds, with high probability.
This algorithm consists of two parts: (1) a randomized algorithm, explained in
Section 3.1.1, which performs some partial sampling in the LLL space, thus setting some of the
variables, in a manner that shatters the graph, hence leaving small connected components
among the unset variables; (2) a deterministic LLL algorithm, explained in Section 3.1.2,
which we use to solve the remaining small connected components. To the best of our
knowledge, this is the first nontrival deterministic distributed LLL algorithm. In Section 3.1.3,
we combine these two parts, concluding the proof of Theorem 7.
This general shattering style for randomized algorithms ? which first performs some
randomized steps to break the graph into small remaining connected components, and then
uses deterministically solves these remaining components ? is rooted in the breakthrough
LLL algorithm of Beck [7], and has been used extensively before [1, 6, 17, 18, 20, 26, 27].
3.1.1
The Randomized Part
We now explain the randomized component of our LLL algorithm for bounded degree graphs,
which performs a partial sampling in the LLL space, thus setting some of the variables, in a
manner that guarantees the following two properties: (1) the conditional probabilities of the
bad events, conditioned on the already set variables, satisfy a polynomial LLL criterion, (2)
the connected components of the events on variables that remain unset are ?small? (e.g., for
bounded degree graphs, they have size at most O(log n)), with high probability.
These two properties together will allow us to invoke the deterministic LLL algorithm that
we present later in Section 3.1.2 on the remaining components of variables that remain unset.
In particular, (1) means that the bad events X form another LLL problem on the variables
that remain unset, where each new bad event has probability at most ?p. Furthermore, (2)
ensures that the components are small enough to make the deterministic algorithm efficient.
Our partial sampling is inspired by a sequential LLL algorithm of Molloy and Reed [26].
I Lemma 8 (Random Partial Setting for the LLL Variables). There is a randomized distributed
algorithm that computes, w.h.p., in O(d2 + log? n) rounds, a partial assignment of values to
variables ? setting the values of the variables in a set V? ? V, hence leaving the variables in
V0 := V \ V? unset ? of an LLL satisfying p(ed)4? < 1, for any integer ? ? 8, such that
(i) P r[A  V?] ? ?p for all A ? X , and
(ii) w.h.p. each connected component of G2X [V0] admits a (?, O(log1/? n ? log2 log n)) network
decomposition, which can be computed in ? ? log1/? n ? 2O(?log log n) rounds,
deterministically.
Proof. We first compute a (d2 + 1)coloring of the square graph G2 on the events, which
X
can be done even deterministically in O?(d) + O(log? n) rounds [16]. Suppose Xi is the set of
events colored with color i, for i ? {1, . . . , d2 + 1}. We process the color classes one by one.
During the process, some variables may get frozen, as we discuss soon. The process
assigns values for all nonfrozen variables, as follows: For each color i ? {1, . . . , d2 + 1}, and
for each node A ? Xi in parallel, we make node A sample values for its (so far nonfrozen)
strengthening the corresponding LLL criterion, somewhat amusing.
variables locally, one by one. Notice that since we are using a coloring of G2 , for each color
X
i, each event B ? X shares variables with at most one event A ? Xi. Hence, during this
iteration, at most one node A is sampling variables of event B. Consider a node A that is
choosing values for some random variables. Each time, when A is choosing a value for a
variable v ? vbl(A), it checks whether this setting makes one of the events B ? X involving
variable v dangerous. We call an event B dangerous if Pr[BVB?] ? ?p/2, where VB? denotes
the already set variables of B up to this point in the sampling process. If the recently set
variable v leads to a dangerous event B, then node A freezes variable v as well as all the
remaining variables of event B. We do not assign values to frozen variables in the remainder
of the randomized sampling process. We have two key observations regarding this process:
I Observation 9. At the end of each iteration, for each event A ? X , the conditional
probability of event A, conditioned on the already made assignments VA?, is at most ?p.
Proof Sketch. The first time that an event A becomes dangerous, all of its remaining
variables get frozen and no other assignment gets made for its variables. By definition, before
A becoming dangerous, the conditional probability of event A, conditioned on the already
made assignments VA?, is at most ?p/2. If A becomes dangerous, that?s because of setting
of one last random variable. Since we have assumed that the random variables are all fair
random bits, at the time of setting one last bit, the conditional probability of event A can
increase by at most a 2 factor. Hence, once A becomes dangerous and all of its remaining
variables get frozen, its conditional probability is at most ?p. J
I Observation 10. For each event A ? X , the probability of A having at least one unset
variable is at most 2(d + 1)?p. Furthermore, this is independent of events that are further
than 2 hops from A.
Proof Sketch. We first claim that for each B ? X , the probability that B ever becomes
dangerous is at most 2?p. This is because otherwise the total probability of B happening
would exceed p. Notice that during the process, some variables get a value assigned to them,
and some variables get frozen, because of B or some other adjacent event becoming dangerous.
More concretely, to focus on just one event B, let us consider two processes for revealing
the samples values for variables of B. In the first process, we sample all the variables in one
shot. Clearly, in this process, P r[B] ? p. The second process has two phases: in the first
phase, we examine the variables of B sequentially, one by one, and each time sample a value
for each variable, with one exception: at each time, an adversary might call some variables
that have not been revealed sofar ?frozen?and moves them to the second phase; any such
frozen variable will not be sampled in the first phase. This adversary can take into account
all the possibilities of neighboring LLLevents making a random variable of B become frozen.
Now in this process, if the conditional probability of event B given the already assigned
variables exceeds ?p/2, or if we run out of nonfrozen variables, the first phase ends. In the
second phase, we simultaneously sample all the variables that have been moved to the second
phase. Now, notice that the probability of event B happening is exactly the same in the
two processes; the second process is just a different order of revealing the sampled values of
the first process. Hence, also in the second process, we have P r[B] ? p. Now, in the second
process, let B0 be the event that the conditional probability of event B at the end of the
first phase (given its assignments variables) exceeds ?p/2. By definition, P r[B0B] ? ?p/2.
Since P r[B] ? p, we have P r[B0] ? ?p/2 = 2?p. Thus, in our LLL sampling process, the
p
probability that each event B ? X ever becomes dangerous is at most 2?p.
Now, an event A ? X can have frozen variables only if at least one of its neighboring
events B, or event A itself, becomes dangerous. Since A has at most d neighboring events,
by a union bound, the latter has probability at most 2(d + 1)?p. J
Observation 9 implies property (i) of Lemma 8. We use Observation 10 to conclude
that the events with at least one unset variable comprise ?small? connected components. In
particular, we apply Lemma 6 to G2X with the random partial setting process generating
a set B ? X of the events that have at least one variable unset. By Observation 10, each
event remains with probability at most 2(d + 1)?p ? 2(d + 1) ? e?2? ? d?2? ? d?15. These
events depend only on events within at most 1 hop in G2X and hence 2 hops in GX . Thus,
Lemma 6 (P3) shows that with probability at least 1 ? n?3 property (ii) holds. J
3.1.2
The Deterministic Part
I Theorem 11. For any integer ? ? 1, the distributed LLL problem can be solved
deterministically in ? ? n1/? ? 2O(?log n) rounds, under the symmetric LLL criterion p(ed)? < 1. If the
algorithm is provided a (?, ?) network decomposition of the square graph G2 , then the LLL
X
algorithm runs in just O(? ? (? + 1)) rounds.
We make a blackbox invocation to the distributed algorithm stated in Lemma 5 for computing
a (?, n1/? ? log n) network decomposition, and then solve the LLL problem on top of this
decomposition, by going through its blocks one by one.
The running time of our deterministic LLL algorithm hence directly depends on the
network decomposition it works with. In particular, if there is a poly log nround deterministic
distributed algorithm that computes a (poly log n, poly log n) network decomposition, then
this algorithm solves any LLL problem satisfying the criterion p(ed)? < 1 (with ? = poly log n)
deterministically in poly log n rounds. This would then directly improve the running time
of the randomized LLL algorithm of Theorem 7 to poly(log log n), proving that TLLL(n) =
poly(log log n), thus almost confirming the conjecture of Chang and Pettie [11].
In fact, we believe that a conceivable future improvement of our LLL algorithm may
need to improve this deterministic component, ideally to complexity O(log n) for proving the
TLLL(n) = O(log log n) conjecture of Chang and Pettie [11].
Proof of Theorem 11. We first compute a (?, n1/? ? log n) network decomposition of G2 ,
X
which decomposes its nodes into ? disjoint blocks X1, . . . , X?, such that each connected
component of G2 [Xi] has diameter at most n1/? ? log n. This decomposition can be computed
X
in ? ? n1/? ? 2O(?log n) rounds, using Lemma 5.
Then, iteratively for i = 1, . . . , ?, we assign values to all variables of events in Xi that
have remained unset. The values are chosen is such a way that, after i steps, the conditional
probability of any event in X , conditioned on all the assignments in variables of events
in Sij=1 Xj, is at most p(ed)i < 1. Once i = ?, since the conditional failure probability is
p(ed)? < 1 but all the variables are already assigned, we know that none of the events occurs.
The base case i = 0 is trivial. In the following, we explain how to set the values for
variables involved in events of Xi in n1/? ? log n rounds. Let Vi be the set of variables
in events of Xi that remain with no assigned value. We form a new LLL problem, as
follows: For each bad event A ? X , we introduce an event BA,i on the space of values of
Vi. This is the event that the values of Vi get chosen such that the conditional probability
of the event A, conditioned on the variables in Sij=1 Vj, is larger than p(ed)i. Notice that
p(ed)i?1
P r[BA,i  Sij?=11 Vj] ? p(ed)i = e1d . This is because, the variables Sij?=21 Vj are set such that
the conditional probability of BA,i given these set values is at most p(ed)i?1, and thus, the
probability that the values of Vi?1 get chosen that the conditional probability given the
set values in Sij?=11 Vj exceeds p(ed)i is at most p(pe(de)di)?i 1 = e1d . Moreover, each event BA,i
depends on at most d other events BA0,i. Hence, the family of events BA,i on the variable
set Vi satisfies the conditions of the tight (symmetric) LLL. Therefore, by the Lov?sz local
lemma, we know that there exists an assignment to variables of Vi which makes no event
BA,i happen. That is, an assignment such that the conditional probability of each event A,
conditioned on the assignments in Sij=1 Vj, is bounded by at most p(ed)i.
Given the existence, we find such an assignment in n1/? ? log n rounds, as follows: each
component of G2 [Xi] first gathers the whole topology of this component (as well as its
X
incident events and the current assignments to any of their variables), in O(n1/? log n) rounds.
Then, it decides about an assignment for its own variables in Vi, by locally bruteforcing all
possibilities. Different components can decide independently as there is no event that shares
variables with two of them, since they are nonadjacent in G2X . J
3.1.3
WrapUp: Base LLL Algorithm
Proof of Theorem 7. We run the randomized algorithm of Lemma 8 for computing a partial
setting of the variables, in O(d2 + log? n) rounds. Then, by Lemma 8 (i), the remaining
events X 0 (those which have at least one unset variable) form a new LLL system on the
unset variables, where each bad event has probability at most ?p.
Moreover, by Lemma 8 (ii), each connected component of the square graph G2X [X 0] of
these remaining events X 0 has a (?, O(log1/? n ? log2 log n)) network decomposition, which
we can compute in ? ? log1/? n ? 2O(?log log n) rounds, deterministically. From now on, we
handle the remaining events in different connected components of G2 [X 0] independently.
X
Since ?p(ed)? < 1, we can now invoke the deterministic LLL algorithm of Theorem 11
on top of the network decomposition of each component. Our deterministic LLL then runs in
? ? log1/? n ? log2 log n additional rounds, and finds assignments for these remaining variables,
without any of the events occurring, hence solving the overall LLL problem. The overall
round complexity is O(d2) + ? ? log1/? n ? 2O(?log log n). J
3.2
Improving the Base LLL Algorithm via Bootstrapping
Proof of Theorem 1. In Theorem 7, we saw an algorithm A that solves any nevent LLL
under the criterion p(ed)32 < 1 in Tn,d = O(d2 + log1/4 n) rounds. We now explain how to
bootstrap this algorithm to run in 2O(?log log n) rounds, on bounded degree graphs.
Inspired by the idea of Chang and Pettie [11], we will lie to A and say that the LLL
graph has n? n nodes, for a value of n? to be fixed later. Then, An? runs in Tn?,d =
O(d2 + log1/4 n?) rounds. In this algorithm, the probability of any local failure (i.e., a bad
event of LLL happening) is at most 1/n?. We can view this as a new system of bad events
which satisfies a much stronger LLL criterion. In particular, we consider each of the previous
bad LLL events as a bad event of the new LLL system, on the space of the random values
used by An? , but now we connect two bad events if their distance is at most 2Tn?,d + 1.
Notice that if two events are not connected in this new LLL, then in algorithm An?,d, they
depend on disjoint sets of random variables and thus they are independent.
The degree of the new LLL system is d0 = d2Tn?,d+1 = dO(d2+log1/4 n?). On the other
hand, the probability of the bad events of the new system is at most p0 = 1/n?. Hence,
the polynomial LLL criterion is satisfied with exponent ?0 = O(d2l+oglodgn1/?4 n?) . We choose
n? = log n, which, for d = O((log log n)1/5), means ?0 = ?(?log log n). Hence, this new LLL
system can be solved using the LLL algorithm of Theorem 7 in time
(d0)2 + ?0 ? log1/?0 n ? 2O(?log log n) =
dO(d2+(log log n)1/4) + plog log n ? (log n)1/?(?log log n) ? 2O(?log log n) = 2O(?log log n).
Hence, the overall complexity is still 2O(?log log n).
We should note that these are rounds on the new LLL system, but each of them can be
performed in 2Tn?,d + 1 = O(d2 + log1/4 n?) = O(?log log n) rounds on the original graph.
J
We next state another result obtained via this speedup method, targeting higher degree
graphs, which we will use in our coloring algorithms. The proof is deferred to the full version.
I Lemma 12. Let A be a randomized LOCAL algorithm that solves some LCL problem P
on nnode graphs with maximum degree d ? 2O(log1/4 log n) in O(log1/4 n) rounds. Then, it is
possible to transform A into a new randomized LOCAL algorithm A0 that solves P, w.h.p.,
in 2O(?log log n) rounds.
4
Defective Coloring
An f defective coloring is a (not necessarily proper) coloring of nodes, where each node has
at most f neighbors with the same color. In other words, in an f defective coloring, each
color class induces a subgraph with maximum degree f . Chung, Pettie, and Su [12] gave
an O(log n)round distributed algorithm for computing an f defective coloring with O(?/f )
colors. We here improve this complexity to 2O ?log log n rounds.
I Theorem 13. There is a 2O ?log log n round randomized distributed algorithm that
computes an f defective O(?/f )coloring in an nnode graph with maximum degree ?, w.h.p.,
for any integer f ? 0.
Direct LLL Formulation of Defective Coloring. Chung, Pettie, and Su [12] give a formula
tion of f defective d2?/f ecoloring as LLL as follows. Each node picks a color uniformly at
random. For each node v, there is a bad event Dv that v has more than f neighbors assigned
the same color as v. The probability of a neighbor u having the same color as v is f /(2?).
Hence, the expected number of neighbors of v with the same color as v is at most f /2. By
a Chernoff bound, the probability of v having more than f neighbors with the same color
is at most e?f/6. Moreover, the dependency degree between the bad events Dv is d ? ?2.
Therefore, p(ed)32 ? e?f/6+32+64 log ? < 1 for f = ?(log ?).
We are unable to directly apply our LLL algorithm of Theorem 1 to this formulation,
because: (A) For f = o(log ?), this LLL formulation does not satisfy the polynomial criterion
p(ed)32 < 1, (B) even if this criterion is satisfied, the dependency degree d may be larger
than what Theorem 1 can handle.
Iterative LLL Formulation of Defective Coloring via Bucketing. Instead of directly finding
an f defective O(?/f )coloring with one LLL problem ? i.e., a partition of G into O(?/f )
buckets with maximum degree f each ? we gradually approach this goal by iteratively
partitioning the graph into buckets, until they have maximum degree f . In other words,
we slow down the process of partitioning. We gradually decrease the degree, moving from
maximum degree x to log5 x in one iteration. We can see each of these bucketing steps ? that
is, the partitioning into subgraphs ? as a partial coloring, which fixes some bits of the final
color. Each of these slower partitioning steps can be formulated as an LLL. The function
x 7? log5 x is chosen large enough for the corresponding LLL to satisfy the polynomial
criterion, and small enough so that decreasing the degree from ? to f does not take too
many iterations, namely O(log? ?) iterations only.
We now explain how a defective coloring problem can be solved using iterated bucketing.
We first formulate the bucketing as an LLL problem satisfying the polynomial LLL criterion,
and present ways for solving this LLL for different ranges of ?. Then, we explain how
iterated application of solving these bucketing LLLs leads to a partition of the graph into
O(?/f ) many degreef buckets.
One Iteration of Bucketing. In one bucketing step, we would like to partition our graph with
degree ? into roughly ?/?0 buckets, each with maximum degree ?0, for a ?0 = ?(log5 ?).
Notice that we can achieve the defective coloring of Theorem 13, by repeating this bucketing
procedure, iteratively. See the proof of Theorem 13, which appears in the full version, for
details of iterative bucketing. Each iteration of bucketing can be formulated as an LLL as
follows.
LLL Formulation of Bucketing. Let k = (1 + ?)?/?0 for ? = log2 ?/??0. We consider
the random variables assigning each node a bucket number in [k]. Then, we introduce a bad
event Dv for node v if more than ?0 neighbors of v are assigned the same number as v. In
expectation, the number of neighbors of a node in the same bucket is at most ?0/(1 + ?). By
a Chernoff bound, the probability of having more than ?0 neighbors in the same bucket is
at most p = e??(?2?0) = e??(log4 ?). Moreover, the dependency degree between these bad
events is d ? ?2. Hence, this LLL satisfies the polynomial criterion.
If ? ? O(log1/10 log n), then d = O(log1/5 log n), and thus we can directly apply the LLL
algorithm of Theorem 1 to compute such a bucketing in 2O(?log log n) rounds. For larger
values of ?, however, we cannot apply Theorem 1. The following lemma discusses how we
handle this range by sacrificing a 2factor in the number of buckets. In a nutshell, the idea is
to just perform one sampling step of bucketing, and then to deal with nodes with too large
degree separately, by setting up another bucketing LLL. While the first LLL on the whole
graph could not be solved directly, the second LLL is formulated only for a ?small? subset of
nodes, which allows an efficient solution. Because of the two trials of solving an LLL, we lose
a 2factor in the total number of buckets.
I Lemma 14. For ? ? ?(log1/10 log n), there is a 2O(?log log n)round randomized distributed
algorithm that computes a bucketing into 2k buckets with maximum degree ?0 each, for
?0 = ?(log5 ?), ? = log ?/??0, and k = (1 + ?)?/?0, with high probability.
5
Frugal coloring
A ?frugal coloring is a proper coloring in which no color appears more than ? times in the
neighborhood of any node. We improve the complexity of ?frugal O(?1+1/? )coloring from
O(log n) by Chung, Pettie, and Su [12] to 2O(?log log n).
I Theorem 15. There is a 2O(?log log n)round randomized distributed algorithm that
computes a ?frugal (120 ? ?1+1/? )coloring6 in a nnode graph with maximum degree ?, w.h.p.,
for any integer ? ? 1.
6 We remark that we have not tried to optimize this constant 120.
Direct LLL Formulation of Frugal Coloring. Molloy and Reed [27, Theorem 19.3] formu
lated frugal coloring as an LLL problem in the following straightforward way: Each node
picks a color uniformly at random. There are two types of bad events: On the one hand, we
have the properness condition, i.e., a bad event Mu,v, for each {u, v} ? E, which happens if
u and v have the same color. On the other hand, the frugality condition ? requiring that
no node has more than ? neighbors of the same color. That is, we have one bad event
Fu1,...,u?+1 for each set u1, . . . , u?+1 ? N (v) of nodes in the neighborhood of some node v,
which happens if all these nodes u1, . . . , u?+1 are assigned the same color. For palettes of
size C, the probability of a bad event is at most 1/C for type 1 and at most 1/C? for type 2.
Each event depends on at most (? + 1)? type 1 and at most (? + 1)? ?? type 2 events.
Iterated LLL Formulation of Frugal Coloring via Partial Frugal Coloring. While the above
formulation is enough to satisfy the asymmetric tight LLL criterion for C = O(?1+1/? ), it
does not satisfy the (symmetric) polynomial LLL. Therefore, the algorithm of Theorem 1
is not directly applicable. We show how to break down the frugal coloring problem into a
sequence of few partial coloring problems, coloring only some of the nodes that have remained
uncolored, each of them satisfying the polynomial LLL criterion.
Roadmap. In Section 5.1, we formalize our notion of partial frugal colorings and present
a method for sampling them. Then, in Section 5.2, we show how to use this sampling to
formulate the problem of finding a partial frugal coloring guaranteeing progress (to be made
precise) as a polynomial LLL and how to solve it. In Section 5.3, we explain how ? after
several iterations of setting up and solving these ?progressguaranteeing? LLLs, gradually
extending the partial frugal coloring ? we can set up and solve one final polynomial LLL for
completing the partial coloring, also based on the sampling method presented in Section 5.1.
5.1
Sampling a Partial Frugal Coloring
I Definition 16 (Partial Frugal Coloring). A partial ?frugal coloring of G = (V, E) is an
assignment of colors to a subset V ? ? V such that it is proper in G[V ?] and no node in V
has more than ? neighbors with the same color. In other words, it is a ?frugal coloring of
G[V ?] with the additional condition that no uncolored node in V 0 := V \ V ? has more than
? neighbors in V ? with the same color.
A partial coloring naturally splits the base graph G into two parts: G[V ?] induced by
colored nodes and G[V 0] induced by uncolored nodes. However, the problem of extending or
completing a partial frugal coloring does not only depend on G[V 0], but also on the base
graph G. That is why we introduce the notion of basegraph degree, a property of the
uncolored set V 0 with respect to the base graph G.
I Definition 17 (BaseGraph Degree of a Partial (Frugal) Coloring). Given a partial coloring,
we call the number d(v, V 0) of neighboring uncolored nodes of a node v ? V its basegraph
degree into the uncolored set V 0. Moreover, we call the maximum basegraph degree ?0 of a
node v ? V into V 0 the basegraph degree of V 0.
In the following, we show how one can sample a partial frugal coloring, thus randomly assign
some of the nodes in a set V 0 of uncolored nodes a color. The main idea of our sampling
process is to pick a color uniformly at random, and then discard it if this choice would lead
to a violation (in terms of properness and frugality). In order to increase the chances of
a node being colored, instead of just sampling one color, each node v samples x different
colors from x different palettes at the same time, for some parameter x ? 1, and then picks
the first color that does not lead to a violation. If v has no such violationfree among its x
choices, then v remains uncolored.
The next lemma, the proof of which is deferred to the full version, analyzes the probability
of two kinds of events: Event (E1) that a node is uncolored. This event is important if we
aim to color all the nodes in V 0. Event (E2) that the basegraph degree of a node into the
set of uncolored nodes in V 0 is too large. This event is important if we do not aim at a
full coloring of all the nodes in V 0, but we want to ensure that we make enough progress in
decreasing the basegraph degree of the uncolored set.
I Lemma 18. Let G = (V, E) be a graph with maximum degree ?, V 0 ? V an uncolored set
with basegraph degree ?0, ? ? [?], and x ? 1. Then there is an O(1)round randomized
distributed algorithm that computes a partial ?frugal (20 ? x ? ?0 ? ?1/? )coloring of some of
the nodes in V 0 such that
(i) the probability that a node in V 0 is uncolored is at most 10?x,
(ii) the probability that the basegraph degree of a node v ? V into the uncolored subset of
V 0 is larger than 5?x ? ?0 is at most e??(5?x??0).
5.2
Iterated Partial Frugal Coloring
In the following, we first show how a ?progressguaranteeing? partial coloring ? that is, a
coloring that decreases the basegraph degree of every node quickly enough ? can be found
based on the sampling process presented in Section 5.1. Then, we prove that by iterating this
algorithm for O(log? ?) repetitions, using different palettes in each iteration, the basegraph
degree reduces to O(??).
In one iteration, given a set V 0 of uncolored nodes, we want to color a subset V ? ? V 0
such that the uncolored nodes V 00 := V 0 \ V ? have a basegraph degree ?00 that is sufficiently
smaller than the basegraph degree ?0 of V 0. Note that the sampling of Section 5.1 only
provides us with a partial coloring where every node is likely to have a decrease in the
basegraph degree. Here, however, we want to enforce that for every node in V there is such
a decrease. To this end, we set up an LLL as follows.
LLL Formulation for ?ProgressGuaranteeing? Coloring. Performing the sampling of
Lemma 18, we have a bad event Dv for every node v ? V that its basegraph degree
into V 00 is larger than ?00 = 5?x ? ?0. By Lemma 18 (ii), we know that the probability of Dv
is at most e??(5?x??0). Moreover, the dependency degree is at most d ? ?2. This LLL thus
satisfies the polynomial criterion.
However, as d might be large, we cannot directly apply the LLL algorithm of Theorem 1.
In the following, we present an alternative way of finding a partial coloring ensuring a
drop in the basegraph degree of every node. In a nutshell, the idea is to just perform one
sampling step of a partial frugal coloring, as described in Section 5.1, and then deal with
nodes associated with bad events (to be made precise) separately, by setting up another
?progressguaranteeing? LLL. While the first LLL on the whole graph could not be solved
directly, the second LLL is formulated only for a ?small? subset of nodes, which allows an
efficient solution. Because of the two trials of solving an LLL, we lose a 2factor in the total
number of colors. The proof of the next lemma appears in the full version.
I Lemma 19. Given a partial ?frugal coloring with uncolored set V 0 with basegraph degree
?0 and a parameter x ? 1 such that 5?x ? ?0 = ?(??), there is a 2O(?log log n)round
randomized distributed algorithm that computes a partial ?frugal (40 ? x ? ?0 ? ?1/? )coloring
such that the uncolored set has basegraph degree at most ?00 = 5?x ? ?0.
The next lemma describes how through iterated application of finding partial colorings,
as supplied by Lemma 19, the basegraph degree of the uncolored set decreases to O(??)
after O(log? ?) rounds and using O(?1+1/? ) colors. The proof appears in the full version.
I Lemma 20. There is a 2O(?log log n)round randomized algorithm that computes a partial
?frugal (80 ? ?1+1/? )coloring such that the uncolored set V 0 has basegraph degree O(??).
In this section, we describe how, once the basegraph degree is O(??), all the remaining
uncolored nodes can be colored, hence completing the partial frugal coloring. We first give a
general formulation for the completion of partial frugal colorings.
LLL Formulation for Completion of Partial Frugal Coloring. Performing the sampling of
Lemma 18, we have a bad event Uv for every node v ? V that it is uncolored. By Lemma 18
(i), the probability of Uv is at most 10?x. Moreover, the dependency degree d is at most ?2.
This LLL satisfies the polynomial criterion if x = ?(log ?).
In the following lemma, the proof of which appears in the full version, we show to solve
this LLL. The idea is to first perform one sampling step (of Lemma 18), which shatters the
graph into ?small? components of uncolored nodes, then to set up an LLL for completing
the partial coloring, and finally to solve it by employing our deterministic LLL algorithm, on
each of the components.
I Lemma 21. Given a partial ?frugal coloring and a set V 0 of uncolored nodes with base
degree ?0 = O(??), there is a 2O(?log log n)round randomized algorithm that completes this
?frugal coloring, by assigning colors to all nodes in V 0, using 40 ? ?1+1/? additional colors.
A wrapup of these results about iterated partial colorings and completing a partial
coloring immediately leads to a proof of Theorem 15.
Proof of Theorem 15. We first apply the iterated coloring algorithm of Lemma 20 with
80 ? ?1+1/? colors, in 2O(?log log n) rounds. Then, we run the algorithms of Lemma 21 to
complete this partial coloring with 40 ? ?1+1/? additional colors, in 2O(?log log n) rounds.
This yields a ?frugal (120 ? ?1+1/? )coloring, in 2O(?log log n) rounds. J
1
2
3
4
5
6
7
Noga Alon . A parallel algorithmic version of the local lemma . In Proc. of the Symp. on Found. of Comp. Sci. (FOCS) , pages 586  593 . IEEE, 1991 .
Noga Alon and Joel H. Spencer . The probabilistic method . John Wiley & Sons, 2004 .
Baruch Awerbuch , Bonnie Berger, Lenore Cowen, and David Peleg . Fast distributed network decompositions and covers . J. of Parallel and Distributed Comp ., 39 ( 2 ): 105  114 , 1996 .
of Comp. Sci. (FOCS) , pages 364  369 , 1989 .
Baruch Awerbuch and David Peleg . Sparse partitions . In Proc. of the Symp. on Found. of Comp. Sci. (FOCS) , pages 503  513 , 1990 .
Leonid Barenboim , Michael Elkin, Seth Pettie, and Johannes Schneider . The locality of distributed symmetry breaking . Journal of the ACM (JACM) , 63 ( 3 ): 20 , 2016 .
J?zsef Beck . An algorithmic approach to the Lov?sz Local Lemma . I. Random Structures & Algorithms , 2 ( 4 ): 343  365 , 1991 .
Sebastian Brandt , Orr Fischer, Juho Hirvonen, Barbara Keller, Tuomo Lempi?inen, Joel Rybicki, Jukka Suomela, and Jara Uitto . A lower bound for the distributed Lov?sz Local Lemma . In Proc. of the Symp. on Theory of Comp. (STOC) , pages 479  488 . ACM, 2016 .
Karthekeyan Chandrasekaran , Navin Goyal, and Bernhard Haeupler . Deterministic algorithms for the Lov?sz local lemma . In Pro. of ACMSIAM Symp. on Disc. Alg. (SODA) , pages 992  1004 , 2010 .
YiJun Chang , Tsvi Kopelowitz , and Seth Pettie . An exponential separation between randomized and deterministic complexity in the local model . In Proc. of the Symp. on Found. of Comp. Sci. (FOCS) , 2016 .
YiJun Chang and Seth Pettie . A time hierarchy theorem for the local model . In Proc. of the Symp. on Found. of Comp. Sci. (FOCS) , 2017 , preprint arXiv: 1704 . 06297 .
(PODC) , pages 134  143 , 2014 .
Artur Czumaj and Christian Scheideler . A new algorithm approach to the general Lov?sz local lemma with applications to scheduling and satisfiability problems . In Proc. of the Symp. on Theory of Comp. (STOC) , pages 38  47 , 2000 .
Paul Erd?s and L?szl? Lov?sz . Problems and results on 3chromatic hypergraphs and some related questions . Infinite and finite sets , 10 ( 2 ): 609  627 , 1975 .
Manuela Fischer and Mohsen Ghaffari . Sublogarithmic distributed algorithms for Lov?sz local lemma, and the complexity hierarchy . preprint arXiv:1705.04840 , 2017 . URL: https: //arxiv.org/abs/1705.04840.
of the Symp. on Found. of Comp. Sci. (FOCS) , pages 625  634 . IEEE, 2016 .
of ACMSIAM Symp. on Disc. Alg. (SODA) , 2016 .
Mohsen Ghaffari and HsinHao Su . Distributed degree splitting, edge coloring, and orientations . In Pro. of ACMSIAM Symp. on Disc. Alg. (SODA) , 2017 .
David G. Harris . Lopsidependency in the MoserTardos framework: Beyond the lopsided Lov?sz local lemma . ACM Trans. Algorithms , 13 ( 1 ): 17 : 1  17 : 26 , December 2016 .
David G. Harris , Johannes Schneider , and HsinHao Su . Distributed (?+ 1)coloring in sublogarithmic rounds . In Proc. of the Symp. on Theory of Comp. (STOC) , pages 465  478 , 2016 .
David G. Harris and Aravind Srinivasan . The MoserTardos framework with partial resampling . In Proc. of the Symp. on Found. of Comp. Sci. (FOCS) , pages 469  478 . IEEE, 2013 .
David G. Harris and Aravind Srinivasan . A constructive algorithm for the Lov?sz local lemma on permutations . In Pro. of ACMSIAM Symp. on Disc. Alg. (SODA) , SODA'14 , pages 907  925 , 2014 .
David G. Harris and Aravind Srinivasan . Algorithmic and enumerative aspects of the MoserTardos distribution . In Pro. of ACMSIAM Symp. on Disc. Alg. (SODA) , pages 2004  2023 , 2016 .
of the Symp. on Theory of Comp. (STOC) , pages 235  244 , 2011 .
of the Symp. on Found. of Comp. Sci. (FOCS) , pages 331  335 . IEEE, 1987 .
of the Symp. on Theory of Comp. (STOC) , pages 524  529 . ACM, 1998 .
Michael Molloy and Bruce Reed . Graph coloring and the probabilistic method , 2002 .
Robin A Moser . A constructive proof of the Lov?sz local lemma . In Proceedings of the fortyfirst annual ACM symposium on Theory of computing , pages 343  350 . ACM, 2009 .
Journal of the ACM (JACM) , 57 ( 2 ): 11 , 2010 .
Moni Naor and Larry Stockmeyer . What can be computed locally ? SIAM Journal on Computing , 24 ( 6 ): 1259  1277 , 1995 .
Alessandro Panconesi and Aravind Srinivasan . Improved distributed algorithms for coloring and network decomposition problems . In Proc. of the Symp. on Theory of Comp. (STOC) , pages 581  592 . ACM, 1992 .
David Peleg . Distributed Computing: A Localitysensitive Approach . Society for Industrial and Applied Mathematics , Philadelphia, PA, USA, 2000 .
of ACMSIAM Symp. on Disc. Alg. (SODA) , pages 611  620 . Society for Industrial and Applied Mathematics, 2008 .