(Delta+1) Coloring in the Congested Clique Model
I C A L P
(? + 1) Coloring in the Congested Clique Model
Merav Parter Weizmann IS
Rehovot
Israel
In this paper, we present improved algorithms for the (? + 1) (vertex) coloring problem in the Congested Clique model of distributed computing. In this model, the input is a graph on n nodes, initially each node knows only its incident edges, and per round each two nodes can exchange O(log n) bits of information. Our key result is a randomized (? + 1) vertex coloring algorithm that works in O(log log ? ? log? ?)rounds. This is achieved by combining the recent breakthrough result of [ChangLiPettie, STOC'18] in the LOCAL model and a degree reduction technique. We also get the following results with high probability: (1) (? + 1)coloring for ? = O((n/ log n)1? ) for any ? (0, 1), within O(log(1/ ) log? ?) rounds, and (2) (? + ?1/2+o(1))coloring within O(log? ?) rounds. Turning to deterministic algorithms, we show a (?+1)coloring algorithm that works in O(log ?) rounds. Our new bounds provide exponential improvements over the state of the art. 2012 ACM Subject Classification Theory of computation ? Distributed algorithms Related Version A full version of the paper is available at [22], https://arxiv.org/abs/1805. 02457. Acknowledgements I am very grateful to HsinHao Su, Eylon Yogev, Seth Pettie, YiJun Chang and the anonymous reviewers for helpful comments.
and phrases Distributed Graph Algorithms; Coloring; Congested Clique

160:2
technique of [13] to obtain the remarkable and quite extraordinary round complexity of
O(log? n + Detdeg(polylogn)) for the (? + 1)list coloring problem where Detdeg(n0) is the
deterministic round complexity of (deg +1) list coloring algorithm2 in n0vertex graph. Both
of these recent breakthroughs use messages of large size, potentially of ?(n) bits.
In view of these recent advances, the understanding of LCL problems in
bandwidthrestricted models is much more lacking. Among these models, the congested clique model
[19], which allows alltoall communication has attracted a lot of attention in the last decade
and more recently, in the context of LCL problems [4, 15, 14, 5, 12, 24]. In the congested
clique model, each node can send O(log n) bits of information to any node in the network
(i.e., even if they are not connected in the input graph). The ubiquitous of overlay networks
and large scale distributed networks make the congested clique model far more relevant
(compared to the LOCAL and the CONGEST models) in certain settings.
Randomized LCL in the Congested Clique Model. Starting with Barenboim et al. [2],
currently, all efficient randomized algorithms for classical LCL problems have the following
structure: an initial randomized phase and a postshattering deterministic phase. The
shattering effect of the randomized phase which dates back to Beck [3], breaks the graph
into subproblems of poly log n size to be solved deterministically. In the congestedclique
model, the shattering effect has an even more dramatic effect. Usually, a node survives
(i.e., remained undecided) the randomized phase with probability of 1/poly(?). Hence, in
expectation the size of the remaining unsolved graph is3 O(n). At that point, the entire
unsolved subgraph can be solved in O(1) rounds, using standard congested clique tools (e.g.,
the routing algorithm by Lenzen [18]). Thus, as long as the main randomized part uses short
messages, the congested clique model ?immediately" enjoys an improved round complexity
compared to that of the LOCAL model.
In a recent work [12], Ghaffari took it few steps farther and showed an Oe(plog ?)round
randomized algorithm for MIS in the congested clique model, improving upon the
stateoftheart complexity of O(log ? + 2O(?log log n)) rounds in the LOCAL model, also by Ghaffari
[11]. When considering the (? + 1) coloring problem, the picture is somewhat puzzling. On
the one hand, in the LOCAL model, (? + 1) coloring is provably simpler then MIS. However,
since all existing o(log ?)round algorithms for (? + 1) coloring in the LOCAL model, use
large messages, it is not even clear if the power of alltoall communication in the congested
clique model can compensate for its bandwidth limitation and outperform the LOCAL round
complexity, not to say, even just match it. We note that on hindsight, the situation for MIS
in the congested clique was somewhat more hopeful (compared to coloring), for the following
reason. The randomized phase of Ghaffari?s MIS algorithm although being in the LOCAL
model [11], used small messages and hence could be implemented in the CONGEST model
with the same round complexity. To sum up, currently, there is no o(log ?)round algorithm
for (? + 1) coloring in any bandwidth restricted model, not even in the congestedclique.
Derandomization of LCL in the CongestedClique Model. There exists a curious gap
between the known complexities of randomized and deterministic solutions for local problems
in the LOCAL model ([6, 20]). Censor et al. [5] initiated the study of deterministic LCL
algorithms in the congested clique model by means of derandomization. The main take home
message of [5] is as follows: for most of the classical LCL problems there are poly log n round
2 In the (deg +1) list coloring problem, each vertex v is given a palette with deg(v, G) + 1 colors.
3 Using the bounded dependencies between decisions, this holds also with high probability.
randomized algorithms (even in the CONGEST model). For these algorithms, it is usually
sufficient that the random choices made by vertices are almost independent. This implies
that each round of the randomized algorithm can be simulated by giving all nodes a shared
random seed of poly log n bits. To dernadomize a single round of the randomized algorithm,
nodes should compute (deterministically) a seed which is at least as ?good"4 as a random
seed would be. To compute this seed, they need to estimate their ?local progress" when
simulating the random choices using that seed. Combining the techniques of conditional
expectation, pessimistic estimators and bounded independence leads to a simple ?voting"like
algorithm in which the bits of the seed are computed bitbybit. Once all bits of the seed are
computed, it is used to simulate the random choices of that round. For a recent work on
other complexity aspects in the congested clique, see [16].
1.1
Main Results and Our Approach
In this paper, we show that the power of alltoall communication compensates for the
bandwidth restriction of the model:
I Theorem 1. There is a randomized algorithm that computes a (? + 1) coloring in
O(log log ? ? log? n) rounds of the congested clique model, with high probability5.
This significantly improves over the stateoftheart of O(log ?)round algorithm for (? + 1)
in the congested clique model. It should also be compared with the round complexity of
(2O(?log log n)) in the LOCAL model, due to [7]. As noted by the authors, reducing the LOCAL
complexity to below O((log log n)2) requires a radically new approach.
Our O(log log ??log? n) round algorithm is based on a recursive degree reduction technique
which can be used to color any almostclique graph with ? = Oe(n1?o(1)) in essentially
O(log? n) rounds.
I Theorem 2. (i) For every ? (0, 1), there is a randomized algorithm that computes a
(? + 1) coloring in O(log(1/ ) ? log? n) rounds for graphs with ? = O((n/ log n)1? ), (ii)
This also yields a (? + ?1/2+o(1)) coloring in O(log? n) rounds, with high probability.
Claim (ii) improves over the O(?)coloring algorithm of [14] that takes O(log log log n) rounds
in expectation. We also provide fast deterministic algorithms for (? + 1) list coloring. The
statoftheart in the LOCAL model is Oe(??) + log? n rounds due to Fraigniaud, Heinrich,
Marc and Kosowski [10].
I Theorem 3. There is a deterministic algorithm that computes a (? + 1) coloring in
O(log ?) rounds of the congested clique model and an O(?2) coloring in O(1) rounds.
In [5], a deterministic algorithm for (? + 1) coloring in O(log ?) round was shown only
for the case where ? = O(n1/3). Here it is extended for ? = ?(n1/3). This is done by
derandomizing an (? + 1)list coloring algorithm which runs in O(log n) rounds. Similarly
to [5], we first show that this algorithm can be simulated when the random choices made by
the nodes are pairwise independent. Then, we enjoy the small search space and employ the
method of conditional expectations. Instead of computing the seed bit by bit, we compute it
in chunks of blog nc bits at a time, by fully exploiting the alltoall power of the model.
4 The random seed is usually shown provide a large progress in expectation. The deterministically
computed seed should provide a progress at least as large as the expected progress of a random seed.
5 As usual, by high probability we mean 1 ? 1/nc for some constant c ? 1.
?? =
Figure 1 Illustration of the recursive sparsification. Gray boxes correspond to subgraphs with
maximum degree O(??).
The Challenges and the Degree Reduction Technique. Our starting observation is that
the CLP algorithm [7] can be implemented in O(log? n) rounds in congested clique model for
? = O(?n). When ? = O(?n), using Lenzen?s routing algorithm [18], each node can learn
in O(1) rounds, the palettes of all its neighbors along with the neighbors of its neighbors.
Such knowledge is mostly sufficient for the CLP algorithm to go through.
To handle large degree graphs, we design a graph sparsification technique that essentially
reduces the problem of (? + 1) coloring for an arbitrarily large ? = Oe(n1? ) into ` =
O(log(1/ )) (nonindependent) subproblems. In each subproblem, one has to compute
a (?0 + 1) coloring for a subgraph with ?0 = O(?n), which can be done in O(log? n)
rounds, using a modification of the CLP algorithm, that we describe later on. Since there
many dependencies between these ` subproblems, it is required by our algorithm to solve
them onebyone, leading to a round complexity of O(log(1/ ) log? n). See Figure 1 for an
illustration of the recursion levels. To get an intuition into our approach and the challenges
involved, consider an input graph G with maximum degree ? = (n/ log n)1? and a palette
Pal(G) = {1, . . . , ? + 1} given to each node in G. A natural approach (also taken in [14]) for
handling a large degree graph is to decompose it (say, randomly) into k vertex disjoint graphs
G1, G2, . . . , Gk, allocate a distinct set of colors for each of the subgraphs taken from Pal(G)
and solve the problem recursively on each of them, enjoying (hopefully) smaller degrees in
each Gi. Intuitively, assigning a disjoint set of colors to each Gi has the effect of removing
all edges connecting nodes in different subgraphs. Thus, the input graph G is sparsified into
a graph G0 = S Gi such that a legal coloring of G0 (with the corresponding palettes given
to the nodes) is a legal coloring for G. The main obstacle in implementing this approach is
that assigning a distinct set of ?(Gi) + 1 colors to each of the Gi subgraph might be beyond
the budget of ? + 1 colors. Indeed in [14] this approach led to O(?) coloring rather than
(? + 1). To reduce the number of colors allocated to each subgraph Gi, it is desirable that
the maximum degree ?(Gi) would be as small as possible, for each Gi. This is exactly the
problem of (k, p) defective coloring where one needs to color the graph with k colors such that
the number of neighbors with the same color is at most p. To this point, the best defective
coloring algorithm for large degrees is the randomized one: let each node pick a subgraph Gi
(i.e., a color in the defective coloring language) uniformly at random. By a simple application
of Chernoff bound, it is easy to see that the partitioning is ?almost" perfect: w.h.p., for
every i, ?(Gi) ? ?/k + plog n ? ?/k. Hence, allocating ?(Gi) + 1 colors to each subgraphs
consumes ? + Oe(??k) colors. To add insult to injury, this additive penalty of Oe(??k) is
only for one recursion call!
It is interesting to note that the parameter k ? number of subgraphs (colors) ? plays a
key role here. Having a large k has the benefit of sharply decreasing the degree (i.e., from ?
to ?/k). However, it has the drawback of increasing the standard deviation and hence the
total number of colors used. Despite these opposing effects, it seems that for whatever value
of k chosen, increasing the number of colors to ? + ? is unavoidable.
Our approach bypasses this obstacle by partitioning only a large fraction of the vertices
into smalldegree subgraphs but not all of them. Keeping in mind that we can handle
efficiently graphs with maximum degree ?n, in every level of the recursion, roughly 1 ? 1/??
of the vertices are partitioned into subgraphs G1, . . . , Gk. Let ?(Gi) be the maximum degree
of Gi. The remaining vertices join a leftover subgraph G?. The number of subgraphs, k, is
chosen carefully so that allocating ?(Gi) + 1 colors to each of the k subgraphs, consumes
at most ? colors, on the one hand; and that the degree reduction in each recursion level
is large enough on the other hand. These subgraphs are then colored recursively, until all
remaining subgraphs have degree of O(?n). Once all vertices in these subgraphs are colored,
the algorithm turns to color the leftover subgraph G?. Since the maximum degree in G? is
O(?n), it is tempting to use the CLP algorithm to complete the coloring, as this can be
done in O(log? n) rounds for such bound on the maximum degree. This is not so immediate
for the following reasons. Although the degree of v in G? is O(?n), the graph G? cannot be
colored independently (as at that point, we ran out of colors to be solely allocate to G?).
Instead, the coloring of G? should agree with the coloring of the rest of the graph and each v
might have ?(?) = n1? neighbors in G. At first glance, it seems that this obstacle is easily
solved by letting each v ? G? pick a subset of deg(v, G?) = O(?n) colors from its palette
(i.e., removing the colors taken by its neighbors in G \ G?). Now, one can consider only
the graph G? with maximum degree ?n, where each vertex has a palette of deg(v, G?) + 1
colors. Unfortunately, this seemingly plausible approach has a subtle flaw: for the CLP
algorithm it is essential that each vertex receives a palette with exactly ?(G?) + 1 colors.
This is indeed crucial and as noted by the authors adopting their algorithm to a (deg +1)
coloring algorithm is highly nontrivial and probably calls for a different approach.
In our setting, allocating each vertex v ? G the exact same number of colors seems to
be impossible as the number of available colors of each v depends on the number of its
neighbors in G \ G?, and this number has some fluctuations due to the random partitioning
of the vertices. To get out of this impasse, we show that after coloring all vertices in G \ G?,
every vertex v ? G? has rv ? [?(G?) ? (?(G?))3/5] available colors in its palette where
rv ? deg(v, G?). In other words, all vertices can be allocated ?almost" the same number of
colors, but not exactly the same. We then carefully revise the basic definitions of the CLP
algorithm and show that the analysis still goes through (upon minor changes) for this narrow
range of variation in the size of the palettes.
Paper Organization. In Section 2, we explain how the CLP algorithm of [7] can be simulated
in O(log? n) congestedclique rounds when ? = O(?n). In Section 3.1, we illustrate the
degreereduction technique on the case where ? = O((n/ log n)3/4). Section 3.2 extends this
approach for ? = O((n/ log n)1? ) for any ? (0, 1), and Section 3.3 handles the general
case and provides the complete algorithm. Finally, Section 4 discusses deterministic coloring
algorithms. Missing proofs are deferred to the full version.
2
The ChangLiPettie (CLP) Alg. in the Congested Clique
Highlevel Description of the CLP Alg. in the LOCAL Model. In the description below,
we focus on the main randomized part of the CLP algorithm [13].
HarrisSchneiderSu algorithm is based on partitioning the graph into an sparse subgraph
and a collection of vertexdisjoint dense components, for a given input parameter . Since
the CLP algorithm extends this partitioning, we next formally provide the basic definitions
from [13]. For an ? (0, 1), an edge e = (u, v) is an friend if N (u) ? N (v) ? (1 ? ) ? ?.
The endpoints of an friend edge are friends. A vertex v is dense if v has at least (1 ? )?
friends, otherwise it is sparse. A key structure that arises from the definition of dense
vertices is that of almost clique which is a connected component of the subgraph induced
by the dense vertices and friend edges. The dense components, almost cliques, have
some nice properties: each component C has at most (1 + )? many vertices, each vertex
v ? C has O( ?) neighbors outside C (called external neighbors) and O( ?) vertices in
C which are not its neighbors. In addition, C has weak diameter at most 2. Coloring the
dense vertices consists of O(log1/ ?) phases. The efficient coloring of dense regions is made
possible by generating a random proper coloring inside each clique so that each vertex has a
small probability of receiving the same color as one of its external neighbors. To do that, in
each cluster a random permutation is computed and each vertex selects a tentative color
from its palette excluding the colors selected by lower rank vertices. Since each component
has weak diameter at most 2, this process is implemented in 2 rounds of the LOCAL model.
The remaining sparse subgraph is colored using a SchneiderWattenhofer style algorithm [23]
within O(log(1/ )) rounds.
In ChangLiPettie algorithm the vertices are partitioned into ` = dlog log ?e layers
in decreasing level of density. This hierarchical partitioning is based on a sequence of `
sparsity thresholds 1, . . . , ` where i = ? i?1. Roughly speaking, level i consists of the
vertices which are idense but i?1sparse. Instead of coloring the vertices layer by layer, the
algorithm partitions the vertices in level i into large and small components and partitions the
layers into O(log? ?) strata. It then colors the vertices in O(log? ?) phases, giving priority
to vertices in small components. The algorithms used to color these vertices are of the same
flavor of the densecoloring procedure of HarrisSchneiderSu. The key benefit in having the
hierarchical structure is that the densecoloring procedure is applied for O(1) many phases
on each stratum, rather than applying it for O(log1/ ?) phases as in [13].
An O(log? ?)Round Alg. for ? = O(?n) in the Congested Clique. We next observe
that the randomized part of the CLP algorithm [7] can be implemented in the congested
clique model when ? = O(?n) within O(log? ?) rounds. We note that we obtain a round
complexity of O(log ??) rather than O(log? n) as in [7], due to the fact that the only part of
the CLP algorithm that requires O(log? n) rounds was for coloring a subgraph with maximum
constant degree. In the congestedclique model such a step can be implemented in O(1)
rounds using Lenzen?s routing algorithm. We show:
I Theorem 4. For every graph with maximum degree ? = O(?n), there is an O(log?
?)round randomized algorithm that computes (? + 1)list coloring in the congested clique
model.
The main advantage of having small degrees is that it is possible for each node to collect
its 2neighborhood in O(1) rounds (i.e., using Lenzen?s routing [18]). As we will see, this
is sufficient in order to simulate the CLP algorithm in O(log? ?) rounds. The hierarchical
decomposition of the vertices depends on the computation of dense vertices. By collecting
the neighbors of its neighbors, every vertex can learn its dense friends and based on that
deduce if it is an dense vertex for every . In particular, for every edge (u, v), v can
learn the minimum i such that u and v are ifriends. To allow each vertex v compute the
almost cliques to which it belongs, we do as follows. Each vertex v sends to each of its
neighbors N (v), the minimum i such that u, v are ifriends, for every u ? N (v). Since the
weak diameter of each almostclique is at most 2, each vertex has collected all the required
information from its 2nd neighborhood to locally compute its ialmost cliques for every i.
Overall, each vertex sends O(?) messages and receives O(?2) = O(n) messages, collection
this information can be done in O(1) rounds for all nodes, using Lenzen?s routing algorithm.
The next obstacle is the simulation of the algorithm that colors the dense vertices. Since
each almost clique C has (1 + )? = O(?n) vertices, we can make the leader of each
such C learn the palettes of all the vertices in its clique as well as their neighbors in O(1)
rounds. The leader can then locally simulate the densecoloring procedure and notify the
output color to each of its almostclique vertices. Finally, coloring the sparse regions in a
SchneiderWattenhofer style uses messages of size O(?) and hence each vertex is the target
of O(?2) = O(n) messages which again can be implemented in O(1) many rounds. A more
detailed description appears in the full version [22]. By the above description, we also have:
I Corollary 5. Given q vertexdisjoint subgraphs G1, . . . , Gq each with maximum degree
? = O(?n), a (? + 1) coloring can be computed in O(log? ?) rounds, for all subgraphs
simultaneously.
Handling NonEqual Palette Size for ? = O(?n). The CLP algorithm assumes that each
vertex is given a list of exactly (? + 1) colors. Our coloring algorithms requires a more
relaxed setting where each vertex v is allowed to be given a list of rv ? [? ? ?3/5, ? + 1]
colors where rv ? deg(v, G) + 1. In this subsection we show:
I Lemma 6. Given a graph G with ? = O(?n), if every vertex v has a palette with
rv ? deg(v, G) + 1 colors and rv ? [? ? ?3/5, ? + 1] then a list coloring can be computed in
O(log? ?) rounds in the congested clique model.
The key modification for handling nonequal palette sizes is in definition of friend (which
affects the entire decomposition of the graph). Throughout, let q = ?3/5 and say6 that u, v
are ( , q)friends if N (u) ? N (v) ? (1 ? ) ? (? ? q). Clearly, if u, v are friends, they are
also ( , q)friends. A vertex v is an ( , q)dense if it has at least (1 ? ) ? (? ? q) neighbors
which are ( , q)friends. An ( , q)almost clique is a connected component of the subgraph
induced by ( , q)dense vertices and their ( , q) friends edges. We next observe that for the
values used in the CLP algorithm, the converse is also true up to some constant. The full
proof of Theorem 6 is in the full version.
I Observation 7. For any ? [??10, K?1], where K is a large constant, and for q = ?3/5,
it holds that if u, v are ( , q) friends, they are (2 )friends. Also, if v is an ( , q)dense, then
it is 2 dense.
3
(? + 1)Coloring for ? = ?(?n)
In this section, we describe a new recursive degreereduction technique. As a warmup, we
start with ? = O((n/ log n)3/4). We make use of the following fact.
I Theorem 8 (Simple Corollary of Chernoff Bound). Suppose X1, X2, . . . , X` ? [0, 1] are
independent random variables, and let X = Pi`=1 Xi and ? = E[X]. If ? ? 5 log n, then
w.h.p. X ? ? ? ?5? log n, and if ? < 5 log n, then w.h.p. X ? ? + 5 log n.
6 The value of q is chosen to be a bit above the standard deviation of p? log n that will occur in our
algorithm.
3.1
An O(log? ?)round algorithm for ? = O((n/ log n)3/4)
The algorithm partitions G into O(?1/3) subgraphs as follows. Let ` = d?1/3e. We define
` + 1 subsets of vertices V1, . . . , V`, V ?. A vertex joins each Vi with probability
pi = 1/` ? 2p5 log n/(?1/3 ? `),
for every i ? {1, . . . , `}, and it joins V ? with the remaining probability of p? = 2?5 log n/?1/3.
Let Gi = G[Vi] be the induced subgraph for every i ? {1, . . . , `, ?}. Using Chernoff bound
of Theorem 8, the maximum degree ?0 in each subgraph Gi, i ? {1, . . . , `} is w.h.p.:
?0 ? ?/` ? 2?2/3p5 log n/` + p5? log n/` ? ?/` ? 1
In the first phase, all subgraphs G1, . . . , G` are colored independently and simultaneously.
This is done by allocating a distinct set of (?0 + 1) colors for each of these subgraphs.
Overall, we allocate ` ? (?0 + 1) ? ? colors. Since ?0 = O(?2/3) = O(?n), we can apply
the (?0 + 1)coloring algorithm of Theorem 5 on all the graphs G1, . . . , G` simultaneously.
Hence, all the subgraphs G1, . . . , G` are colored in O(log? ?) rounds.
Coloring the remaining leftover subgraph G?. The second phase of the algorithm
completes the coloring for the graph G?. This coloring should agree with the colors computed
for G \ G? computed in the previous phase. Hence, we need to color G? using a list coloring
algorithm. We first show that w.h.p. the maximum degree ?? in G? is O(?n). The
probability of vertex to be in G? is p? = 2?5 log n/?1/3. By Chernoff bound of 8, w.h.p.,
?? ? p? ? ? + p5p? ? ? ? log n. Since ? ? (n/ log n)3/4, ?? = O(?n). To be able to apply
the modified CLP of Theorem 6, we show:
I Lemma 9. Every v ? G? has at least ?? ? (??)3/5 available colors in its palette after
coloring all its neighbors in G \ G?.
Proof. First, consider the case where deg(v, G) ? ??(?? ?p5?? ? log n). In such case, even
after coloring all neighbors of v, it still has an access of ?? ? p5?? ? log n ? ?? ? (??)3/5
colors in its palette after coloring G \ G? in the first phase. Now, consider a vertex v
with deg(v, G) ? ? ? (?? ? p5?? ? log n). Using Chernoff bound, w.h.p., deg(v, G?) >
(? ? (?? ? p?? ? 5 log n)) ? p? ? p5 log n?p? ? ?? ? (??)3/5. J
Also note that a vertex v ? G? has at least deg(v, G?) + 1 available colors, since all its
neighbors in G? are uncolored at the beginning of the second phase and initially it was given
(? + 1) colors. Eventhough, v ? G? might have ?(?) neighbors not in G?, to complete
the coloring of G?, by Theorem 9, after the first phase, each v can find in its palette
r ? [?? ? (??)3/5, ?? + 1] available colors and this subpalette is sufficient for its coloring in
G?. Since ?? = O(?n), to color G? (using these small palettes), one can apply the O(log? ?)
round listcoloring algorithm of Theorem 6.
3.2
An O(log(1/ ) ? log? ?)round algorithm for
? = O((n/ log n)1? )
Let N = n/(5 log n). First assume that ? ? N/2 and partitions the range of relevant
degrees [?n, N/2] into ` = ?(log log ?) classes. The yth range contains all degrees in
[N 1?1/2y , N 1?1/(2y+1)] for every y ? {1, . . . , `}. Given a graph G with maximum degree
? = O(N 1?1/(2y+1)), Algorithm RecursiveColoring colors G in y ? O(log? ?) rounds, w.h.p.
Step (I): Partitioning (DefectiveColoring). For i ? {0, . . . , y ? 1}, in every level i of the
recursion, we are given a graph G0, with maximum degree ?i = O(N 1?1/2y?i+1 ), and a
palette Pali of (?i + 1) colors. For i = 0, ?0 = ? and the palette Pal0 = {1, . . . , ? + 1}.
The algorithm partitions the vertices of G0 into qi + 1 subsets: V10, . . . , Vq0i and a special
leftover set V ?. The partitioning is based on the following parameters. Set x = 2y?i and
qi = d?i1/(2x?1)e and ?i = 2p5 log n ? qi3/2/p?i.
Each vertex v ? V (G0) joins Vj0 with probability pj = 1/qi ? ?i/(qi)2 for every j ?
{1, . . . , qi}, and it joins V ? with probability p? = ?i/qi. Note that p? ? (0, 1) as x ? 2. For
every j ? {1, . . . , qi}, let G0j = G0[Vj0] and let G? = G0[V ?].
Step (II): Recursive coloring of G01, . . . , G0qi . Denote by ?ej to be the maximum degree in
G0j for every j ? {1, . . . , qi} and by ??, the maximum degree in G?. The algorithm allocates
a distinct subset of ( ?ej + 1) colors from Pali for every j ? {1, . . . , qi}. In the analysis, we
show that w.h.p. Pali contains sufficiently many colors for that allocation. The subgraphs
G01, . . . , G0qi are colored recursively and simultaneously, each using its own palette. It is easy
to see that the maximum degree of each G0j is O(N 1?1/2y?i ) (which is indeed the desire
degree for the subgraphs colored in level i + 1 of the recursion).
Step (III): Coloring the leftover graph G?. Since the algorithm already allocated at
most ?i colors for coloring the G0j subgraphs, it might run out of colors to allocate for
G?. This last subgraph is colored using a listcoloring algorithm only after all vertices of
G01, . . . , G0qi are colored. Recall that ?? is the maximum degree of G?. In the analysis,
we show that w.h.p. ?? = O(?n). For every v ? G?, let Pal(v) ? Pali be the remaining
set of available colors after coloring all the vertices in V10, . . . , Vq0i . Each vertex v ? G?
computes a new palette Pal?(v) ? Pal(v) such that: (i) Pal?(v) ? deg(v, G?) + 1, and (ii)
Pal?(v) ? [?? ? ?3/5, ?? + 1]. In the analysis section, we show that w.h.p. this is indeed
possible for every v ? G?. The algorithm then applies the modified CLP algorithm, and G?
gets colored within O(log? ?) rounds.
Example:
?0 = 15/16
1 = ?( 1/16)
?
?1 = 7/8
2 = ?( 1/8)
?? =
?
?2 = 3/4
?3 = 1/2
?
3 = ?( 1/4)
Assume that input graph G has maximum degree ?0 = n15/16. The algorithm partitions G
into k0 = n1/15 subgraphs in the following manner. For sake of clarity, we omit logarithmic
factors in the explanation. With probability 1/(?0)1/2+o(1), v joins a leftover subgraph G?,
and with the remaining probability it picks a subgraph [1, k0] uniformly at random. It is easy
to see that the maximum degree in each of these subgraphs is at most ?1 = n7/8 + n7/16.
A distinct set of ?1 colors from [1, ?0 + 1] is allocated to each of the k subgraphs. Each
such subgraph is now partitioned into k1 = n1/8 subgraphs plus a leftover subgraph. This
continues until all subgraphs have their degrees sharply concentrated around ?n. At that
point, the modified CLP algorithm can be applied on all the subgraphs in the last level `.
Once these subgraphs are colored, the leftover subgraphs in level ` ? 1 are colored, this
continues until the final leftover subgraph of the first level is colored. We next provide a
compact and high level description of the algorithm.
Algorithm 1 RecursiveColoring(G0, Pali)
Input: Graph G0 with maximum degree ?i = O(N 1?1/2y?i+1 ).
A palette Pali of (?i + 1) colors (same for all nodes).
Partitions G0 into qi + 1 vertexdisjoint subgraphs:
qi vertexsubgraphs G01, . . . , G0qi with maximum degree ?i+1 = O(N 1?1/2y?i ).
Leftover subgraph G? with maximum degree ?? = O(?n).
Allocate a distinct palette Palj ? Pali of (?i+1 + 1) colors for each j ? qi.
Apply RecursiveColoring(Gj , Palj ) for every j ? qi simultaneously.
Apply a (?i + 1)list coloring restricted to Pali, to complete the coloring of G[V ?].
Analysis.
I Lemma 10. (i) For every j ? {1, . . . , qi}, w.h.p., ?ej = O(N 1?1/2y?i ). (ii) One can
allocate ( ?ej + 1) distinct colors from Pali for each G0j , j ? {1, . . . , qi}.
Proof. Using Chernoff bound of Theorem 8, w.h.p., for every j ? {1, . . . , qi ? 1}, the
maximum degree ?ej in G0j is at most ?ej = O(?i/qi). Since ?i = O(N 1?2y?i+1 ), claim (i)
follows. We now bound the sum of all colors allocated to these subgraphs:
?ej ? ?i/qi ? (?i ? ?i)/(qi)2 + p5 log n ? ?i/qi ? ?i/qi ? 1 .
where the last inequality follows by the value of ?i. We get that Pjqi=1( ?ej + 1) ? ?i and
since Pali contains ?i + 1 colors, claim (ii) follows. J
We next analyze the final step of the algorithm and begin by showing that, w.h.p., the
maximum degree in the leftover graph G? is O(?n). By Chernoff bound of Theorem 8,
w.h.p., the maximum degree ?? ? ?i ? ?i/qi + plog n ? ?i ? ?i/qi. Since ?i = O(N 1?1/2y?i+1 ),
we get that ?? = O(?n). We now claim:
I Lemma 11. After coloring for all the vertices in G01, . . . , G0qi , each vertex v ? G? has a
palette Pal?(v) of free colors such that (i) Pal?(v) ? deg(u, G?) + 1, and (ii) Pal?(v) ?
[?? ? (??)3/5), ?? + 1].
Proof. Since each vertex v ? G0 has a palette of size (?i + 1) ? deg(v, G0), after coloring all
its neighbors in G01, . . . , G0qi , it has at least deg(v, G?) + 1 free colors in its palette. Claim
(ii) follows the same argument as in Theorem 9. We show that the palette of v has at least
?? ? O(??? ? 5 log n) ? (?? ? (??)3/5) available colors after coloring all the vertices in
G \ G?. First, when deg(v, G0) ? ?i ? (?? ? p?? ? 5 log n), then even after coloring all
neighbors of v in G0, it still has an access of ?? ? p?? ? 5 log n colors in its palette. Consider
a vertex v with deg(v, G0) ? ?i ? (?? ? p?? ? 5 log n). By Chernoff, w.h.p. it holds that:
Hence, by combining with claim (i), the lemma follows.
J
This completes the proof of Theorem 2(i).
(? + ?1/2+ ) Coloring in LogStar Rounds
I Lemma 12. For any fixed ? (0, 1), one can color, w.h.p., a graph with (? + ?1/2+ )
colors in O(log(1/ ) ? log? ?) rounds.
Proof. Due to Theorem 4, it is sufficient to consider the case where ? = ?(?n). Partition
the graph into k = b? c subgraphs G1, . . . , Gk, by letting each vertex independently pick
a subgraph uniformly at random. By Chernoff bound of Theorem 8, the maximum degree
?i in each subgraph Gi is at most ?i ? ?1? + ?1/2? /2 ? ?5 log n. Allocate a distinct set
of ?i + 1 colors Pali to each subgraph Gi. Since ?1? = O((n/ log n)1? /2), we can apply
Alg. RecursiveColoring on each of these subgraphs which takes O(log(1/ ) ? log? ?) rounds.
It is easy to see, that since the subgraphs are vertex disjoint, Alg. RecursiveColoring can be
applied on all k subgraphs simultaneously with the same round complexity. Overall, the
algorithm uses ? + ?1/2+ colors. J
3.3
(? + 1) Coloring Algorithm for General Graphs
For graphs G with ? ? n/(10 log n), we simply apply Alg. RecursiveColoring. Plugging
= 1/ log n in Theorem 2, we get that this is done in O(log log ? ? log? ?) rounds. It remains
to handle graphs with with ? ? [n/(10 log n), n]. We partition the graph into ` = d5 log ne
subgraphs G1, G2, . . . , G` and a leftover graph G? in the following manner. Each v ? V
joins Gi with probability p = 1/` ? 2p5 log n/(? ? `) for every i ? {1, . . . , `}, and it joins G?
with probability p? = 1 ? ` ? p = ?(log n/??). By Chernoff bound, the maximum degree in
Gi for i ? {1, 2, . . . , `} is ?i ? ?/` ? 2p(? ? 5 log n)/` + p? ? 5 log n/` ? ?/` ? 1 . Hence,
we have the budget to allocate a distinct set Pali of ?i colors for each Gi.
The first phase applies Algorithm RecursiveColoring on each (Gi, Pali) simultaneously for
every i. Since ?i = O(n/ log n), and the subgraphs are vertexdisjoint, this can be done in
O(log log ? ? log? ?) rounds for all subgraphs simultaneously (see Theorem 2(i)).
After all the vertices of G \ G? get colored, the second phase colors the leftover subgraph
G?. The probability of a vertex v to be in G? is O(log n/??) = O(log2 n/?n). Hence, G?
contains O(log2 n ? ?n) vertices with high probability. We color G? in two steps. First, we use
the deg +1 list coloring Algorithm OneShotColoring from [2] to reduce the uncoloreddegree
of each vertex to be O(?n/ log2 n) with high probability. This can be done in O(log log n)
rounds. In the second step, the entire uncolored subgraph G00 ? G? has O(n) edges and can
be solved locally in O(1) rounds. Note that for each v ? G00, it is sufficient to consider a
palette with deg(v, G00) + 1 colors, and hence sending all these palettes can be done in O(1)
rounds as well. The complete proof of Theorem 1 is in the fullversion.
Algorithm 2 FastColoring(G)
If ? ? n/(10 log n), call RecursiveColoring(G, [1, ? + 1]).
Else, partition G into vertexsubgraphs as follows:
G01, . . . , G0q with the maximum degree ?(?/ log n), and
a leftover subgraph G? with maximum degree ?? = O(?n).
Allocate a distinct palette Palj ? [1, ? + 1] of (?(Gj ) + 1) colors for each j ? qi.
Apply RecursiveColoring(Gj , Palj ) for all G1, . . . , Gq simultaneously.
Apply a (deg +1)list coloring algorithm on G? for O(log log n) rounds.
Solve the remaining uncolored subgraph locally.
4
Deterministic Coloring Algorithms
In this section, we provide deterministic coloring algorithms using the tools of bounded
inpdendent and conditional expectation introduced in [5].
I Theorem 13. There is a deterministic (? + 1) list coloring using O(log ?) rounds, in the
congested clique model.
In [5], a deterministic (? + 1) coloring was presented only for graphs with maximum degree
? = O(n1/3). Here, we handle the case of ? = ?(n1/3). We derandomize the following
simple (? + 1)algorithm that runs in O(log n) rounds.
Algorithm 3 Round i of Algorithm SimpleRandColor (for node v with palette Palv)
Let Fv be the set of colors taken by the colored neighbors of v.
Pick a color cv uniformly at random from Palv \ Fv.
Send colors to neighbors and if cv 6= 0 and legal, halt.
I Observation 14. The correctness of Algorithm SimpleRandColor is preserved, even if the
coin flips are pairwiseindependent.
The goal of phase i in our algorithm is to compute a seed that would be used to simulate
the random color choices of round i of Alg. SimpleRandColor. This seed will be shown to
be good enough so that at least 1/4 of the currently uncolored vertices, get colored when
picking their color using that seed. Let Vi be the set of uncolored vertices at the beginning
of phase i. We need the following construction of bounded independent hash functions:
I Lemma 15. [25] For every ?, ?, d ? N, there is a family of dwise independent functions
H?,? = nh : {0, 1}? ? {0, 1}? o such that choosing a random function from H?,? takes
d ? max {?, ?} random bits, and evaluating a function from H?,? takes time poly(?, ?, d).
For our purposes, we use Theorem 15 with d = 2, ? = log n, ? = log ? and hence the size of
the random seed is ? ? log n bits for some constant ?. Instead of revealing the seed bit by bit
using the conditional expectation method, we reveal the assignment for a chunk of z = blog nc
variables at a time. To do so, consider the i?th chunk of the seed Yi0 = (y10, . . . , yz0). For
each of the n possible assignments (b01, . . . , b0z) ? {0, 1}z to the z variables in Y 0, we assign a
leader u that represent that assignment and receives the conditional expectation values from
all the uncolored nodes Vi, where the conditional expectation is computed based on assigning
y10 = b01, . . . , yz0 = b0z. Unlike the MIS problem, here the vertex?s success depends only on its
neighbors (i.e., and does not depend on its second neighborhood). Using the partial seed
and the IDs of its neighbors, every vertex v can compute the probability that it gets colored
based on the partial seed. It then sends its probability of being colored using a particular
assignment y10 = b01, . . . , yz0 = b0z to the leader u responsible for that assignment. The leader
node u of each assignment y10 = b01, . . . , yz0 = b0z sums up all the values and obtains the
expected number of colored nodes conditioned on the assignment. Finally, all nodes send to
the leader their computed sum and the leader selects the assignment (b1?, . . . , bz?) ? {0, 1}z of
largest value. After O(1) many rounds, the entire assignment of the O(log n) bits of the seed
are revealed. Every yet uncolored vertex v ? Vi uses this seed to simulate the random choice
of Alg. SimpleRandColor, that is selecting a color in {0, 1, 2, . . . , ? + 1} \ Fv and broadcasts
its decision to its neighbors. If the color cv 6= 0 is legal, v is finally colored and it notifies
its neighbors. By the correctness of the conditional expectation approach, we have that
least 1/4 ? Vi vertices got colored. Hence, after O(log n) = O(log ?) rounds, all vertices are
colored. In the full version, we also show a deterministic O(?2) coloring in O(1) rounds.
1
2
3
4
5
6
7
8
9
10
11
Alkida Balliu , Juho Hirvonen, Janne H. Korhonen , Tuomo Lempi?inen, Dennis Olivetti , and Jukka Suomela . New classes of distributed time complexity . CoRR, abs/1711 . 01871 , 2017 . arXiv: 1711 . 01871 .
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 .
Andrew Berns , James Hegeman, and Sriram V Pemmaraju. Superfast distributed algorithms for metric facility location . In International Colloquium on Automata, Languages, and Programming , pages 428  439 . Springer, 2012 .
Keren CensorHillel , Merav Parter , and Gregory Schwartzman . Derandomizing local distributed algorithms under bandwidth restrictions . In 31st International Symposium on Distributed Computing, DISC 2017, October 1620 , 2017 , Vienna, Austria, pages 11 : 1  11 : 16 , 2017 .
YiJun Chang , Tsvi Kopelowitz , and Seth Pettie . An exponential separation between randomized and deterministic complexity in the LOCAL model . In IEEE 57th Annual Symposium on Foundations of Computer Science, FOCS 2016 , 9  11 October 2016 , Hyatt Regency , New Brunswick, New Jersey, USA, pages 615  624 , 2016 .
YiJun Chang , Wenzheng Li , and Seth Pettie . An optimal distributed (? + 1) coloring algorithm ? arXiv preprint arXiv:1711.01361 , 2018 .
YiJun Chang and Seth Pettie . A time hierarchy theorem for the local model . FOCS , 2017 .
Manuela Fischer and Mohsen Ghaffari . Sublogarithmic distributed algorithms for Lov\'asz local lemma, and the complexity hierarchy . DISC , 2017 .
Pierre Fraigniaud , Marc Heinrich , and Adrian Kosowski . Local conflict coloring . In Foundations of Computer Science (FOCS) , 2016 IEEE 57th Annual Symposium on , pages 625  634 .
IEEE , 2016 .
Mohsen Ghaffari . An improved distributed algorithm for maximal independent set . In Proceedings of the TwentySeventh Annual ACMSIAM Symposium on Discrete Algorithms , pages 270  277 . Society for Industrial and Applied Mathematics, 2016 .
Mohsen Ghaffari . Distributed MIS via alltoall communication . In Proceedings of the ACM Symposium on Principles of Distributed Computing, PODC 2017 , Washington, DC, USA, July 25  27 , 2017 , pages 141  149 , 2017 .
David G Harris , Johannes Schneider, and HsinHao Su . Distributed (? + 1)coloring in sublogarithmic rounds . In Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing , pages 465  478 . ACM, 2016 .
James W Hegeman and Sriram V Pemmaraju . Lessons from the congested clique applied to mapreduce . Theoretical Computer Science , 608 : 268  281 , 2015 .
James W Hegeman , Sriram V Pemmaraju, and Vivek B Sardeshmukh . Nearconstanttime distributed algorithms on a congested clique . In International Symposium on Distributed Computing , pages 514  530 . Springer, 2014 .
Janne H Korhonen and Jukka Suomela . Brief announcement: Towards a complexity theory for the congested clique . In LIPIcsLeibniz International Proceedings in Informatics , volume 91 . Schloss DagstuhlLeibnizZentrum fuer Informatik, 2017 .
Fabian Kuhn , Thomas Moscibroda, and Roger Wattenhofer . Local computation: Lower and upper bounds . Journal of the ACM (JACM) , 63 ( 2 ): 17 , 2016 .
Christoph Lenzen . Optimal deterministic routing and sorting on the congested clique . In PODC , pages 42  50 , 2013 .
Zvi Lotker , Boaz PattShamir, Elan Pavlov , and David Peleg. Minimumweight spanning tree construction in o (log log n) communication rounds . SIAM Journal on Computing , 35 ( 1 ): 120  131 , 2005 .
In Proceedings of the Annual ACM Symposium on Theory of Computing , pages 784  797 , 2017 .
Moni Naor and Larry Stockmeyer . What can be computed locally ? SIAM Journal on Computing , 24 ( 6 ): 1259  1277 , 1995 .
Merav Parter . (? + 1) coloring in the congested clique model . arXiv, 2018 . arXiv: 1805 .
Johannes Schneider and Roger Wattenhofer . A new technique for distributed symmetry breaking . In Proceedings of the 29th ACM SIGACTSIGOPS symposium on Principles of distributed computing , pages 257  266 . ACM, 2010 .
Gregory Schwartzman . Adapting sequential algorithms to the distributed setting . arXiv preprint arXiv:1711.10155 , 2017 .
Salil P. Vadhan . Pseudorandomness. Foundations and Trends in Theoretical Computer Science , 7 ( 1 3): 1  336 , 2012 . doi: 10 .1561/0400000010.