Distributed Graph Coloring:

Fundamentals and Recent

Developments

Leonid Barenboim and Michael Elkin

Ben-Gurion University of the Negev

SYNTHESIS LECTURES ON SAMPLE SERIES #1

M
&C Morgan & cLaypool publishers
ABSTRACT
The focus of this monograph is on symmetry breaking problems in the message-passing
model of distributed computing. In this model a communication network is represented by
a n-vertex graph G = (V, E), whose vertices host autonomous processors. The processors
communicate over the edges of G in discrete rounds. The goal is to devise algorithms that
use as few rounds as possible.
A typical symmetry breaking problem is the problem of graph coloring. Denote by ∆
the maximum degree of G. While coloring G with ∆ + 1 colors is trivial in the centralized
setting, the problem becomes much more challenging in the distributed one. One can also
compromise on the number of colors, if this allows for more efficient algorithms. Other
typical symmetry-breaking problems are the problems of computing a maximal independent
set (MIS) and a maximal matching (MM). The study of these problems dates back to the
very early days of distributed computing. The founding fathers of distributed computing
(see [60, 61, 39, 40, 18, 55, 31, 5]) laid firm foundations for the area of distributed symmetry
breaking already in the eighties. In particualr, they showed that all these problems can be
solved in randomized logarithmic time. Also, Linial [55] showed that an O(∆2 )-coloring can
be solved very efficiently deterministically.
However, fundamental questions were left open for decades. In particular, it is not
known if the MIS or the (∆ + 1)-coloring can be solved in deterministic polylogarithmic
time. Moreover, until recently it was not known if in deterministic polylogarithmic time
one can color a graph with significantly less than ∆2 colors. Additionally, it was open (and
still open to some extent) if one can have sublogarithmic randomized algorithms for the
symmetry breaking problems.
Recently, significant progress was achieved in the study of these questions. More
efficient deterministic and randomized (∆ + 1)-coloring algorithms were achieved in [8,
48, 78, 11]. Deterministic ∆1+o(1) -coloring algorithms with polylogarithmic running time
were devised in [9]. Improved (and often sublogarithmic-time) randomized algorithms were
devised in [47, 78, 11]. Drastically improved lower bounds were given in [50, 52]. Wide
families of graphs in which these problems are solvable much faster than on general graphs
were identified in [49, 51, 30, 77, 7, 9].
The objective of our monograph is to cover most of these developments, and as a
result to provide a treatise on theoretical foundations of distributed symmetry breaking in
the message-passing model. We hope that our monograph will stimulate further progress
in this exciting area.

KEYWORDS
Distributed Symmetry Breaking, Maximal Independent Set, Maximal Match-
ing, Coloring, Deterministic Algorithms, Randomized Algorithms, Arboricity
To Lena,
Yonatan and Tal Avraham,
and my parents Leonid Lipman and Marina.

M.E.

To my parents Yevgenia and Michael,

my grandmother Sofia, my uncle Misha,
Valeria, and Arik.

L.B.
iv

Contents
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

2 Basics of Graph Theory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.1 Graphs with Large Girth and Large Chromatic Number . . . . . . . . . . . . . . . . . . . 6

2.2 Planar Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Arboricity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.1 Nash-Williams Theorem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.2 Degeneracy and Arboricity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4 Defective Coloring. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .24
2.5 Edge-Coloring and Matchings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3 Basic Distributed Graph Coloring Algorithns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.1 The Distirubuted Message-Passing LOCAL Model. . . . . . . . . . . . . . . . . . . . . . . .28

3.2 Basic Color Reduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3 Orientations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29
3.4 The Algorithm of Cole and Vishkin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.5 Extensions to graphs with bounded maximum degree . . . . . . . . . . . . . . . . . . . . . 33
3.6 An Improved Coloring Algorithm for Graphs with Bounded Maximum
Degree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.7 A Faster (∆ + 1)-Coloring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.8 Kuhn-Wattenhofer Color Reduction Technique and its Applications. . . . . . .37
3.9 A reduction from (∆ + 1)-coloring to MIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.10 Linial’s Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

4 Lower Bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

4.1 Coloring Unoriented Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

4.1.1 The First Proof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
 4.1.2 The Second Proof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.2 Coloring the n-path Pn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

5 Forest-Decomposition Algorithms and Applications . . . . . . . . . . . . . . . . . . . . . . . . . 52

5.1 H-Partition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.2 An O(a)-coloring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.3 Faster Coloring. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59
5.4 MIS algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

6 Defective Coloring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

6.1 Employing Defective Coloring for Computing Legal Coloring . . . . . . . . . . . . . 64

6.2 Defective Coloring Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
6.2.1 Procedure Refine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .70
6.2.2 Procedure Defective-Color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

7 Arbdefective Coloring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

7.1 Small Arboricity Decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

7.2 Efficient Coloring Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

8 Edge-Coloring and Maximal Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

8.1 Edge-Coloring and Maximal Matching using Forest-Decomposition . . . . . . . 89

8.2 Edge-Coloring using Bounded Neighborhood Independence . . . . . . . . . . . . . . . 93

9 Network Decompositions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

9.1 Applications of Network Decompositions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

9.2 Ruling Sets and Forests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
9.3 Constructing Network Decompositions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

10 Introduction to Distributed Randomized Algorithms. . . . . . . . . . . . . . . . . . . . . . .108

10.1 Simple Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

10.2 A Faster O(∆)-Coloring Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
10.3 Randomized MIS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
10.3.1 A High-Level Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
 10.3.2 Procedure Decide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
10.4 Randomized Maximal Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
10.5 Graphs with Bounded Arboricity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

11 Conclusion and Open Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

11.1 Problems that can be Solved in Polylogarithmic Time . . . . . . . . . . . . . . . . . . . 140

11.2 Problems that can be Solved in (Sub)linear in ∆ Time . . . . . . . . . . . . . . . . . . 142
11.3 Algorithms for Restricted Graph Families . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
11.4 Randomized Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

Bibliography

Authors’ Biographies
 vii

Acknowledgements
The authors are grateful to Kishore Kothapalli, Alessandro Panconesi and Sriram
Pemmaraju for providing them with valuable feedback on a preliminary draft of this mono-
graph.
Leonid Barenboim was supported by the Adams Fellowship Program of the Israel
Academy of Sciences and Humanities.
Michael Elkin was supported by the Israeli Science Foundation grant No 87209011,
and by the US-Israel Binational Science Foundation grant No 2008390.
 1

CHAPTER 1

Introduction
Distributed Computing is a large and growing field of study, which is concerned with
various settings in which there are several processors working in parallel, typically on a
joint problem. The area is roughly forty years old, and by now there are a number of
excellent treatises that cover different aspects of Distributed Computing [67, 62, 4, 73].
The most relevant to this monograph is the book of Peleg [67], that describes the
message-passing model of distributed computation. In this model a communication network
is represented by an n-vertex graph G = (V, E), whose vertices host autonomous processors.
The processors communicate over the edges of G in discrete rounds.1 In each of these
rounds each processor (equivalently, each vertex) can send messages to all its neighbors in
G. The running time of an algorithm in this model is the (worst-case) number of rounds
of distributed communication that this algorithm requires. Note that local computation
comes for free in this model. One also assumes that vertices have distinct identity numbers
(or, shortly, Ids) from the range [n] = {1, 2, ..., n} at the beginning of the computation.
Messages are of unbounded size.2
The message-passing model of distributed computing has been a subject of inten-
sive research since the beginning of the eighties. Most important results in this area that
were known at the turn of the 21st century were systematically and thorougly covered in
Peleg’s book [67]. However, the area has been extremely active since then, and some of
the developments in this area call for a new monograph. Most notably, there is an area
of symmetry breaking and distributed graph coloring, within the message-passing model of
distributed computing. It deals with problems such as computing a maximal independent
set, or, shortly, an MIS. A set U ⊆ V of vertices in a graph G is independent, if no two
vertices u, v ∈ U are connected by an edge. It is an MIS if U ∪ {v} is not independent for
every vertex v ∈ V \ U . Other closely related problems include Maximal Matching, which
is an edge analogue of MIS, and the coloring problems. In a graph G of maximum degree
∆, in the distributed coloring problem one typically seeks to compute a (∆ + 1)-coloring of
G. One is often prepared to compromise on the number of colors, if this allows for more ef-

1 We only describe the synchronous variant of the message-passing model here. For details about the asynchronous
model we refer the reader to [67].
2 This is the so-called Linial’s LOCAL model of computation [55]. The bounded-message variant of this model

is called in [67] CON GEST . In this monograph for simplicity we will always assume the LOCAL model. On
the other hand, most of the algorithms that we will discuss can be implemented within the same running time
in the CON GEST model as well.
2 1. INTRODUCTION

ficient algorithms. One can also aim at O(a)-coloring of G, where a = a(G) is the arboricity
of the graph G.3
The study of these problems was initiated at the very early days of Distributed
Computing. Papers by Luby [60, 61], Israeli and Itai [39], Israeli and Shiloach [40], Cole and
Vishkin [18], Linial [55], Goldberg, Plotkin and Shannon [31], and by Awerbuch, Goldberg,
Luby and Plotkin [5] built the firm foundation of this area back in the eighties. These papers
[60, 61, 39, 40] showed that all these problems (we will henceforth call them the symmetry
breaking problems) can be solved by randomized algorithms that require O(log n) time.
Goldberg et al. [31] also showed that in planar graphs one can solve them in deterministic
logarithmic time. Cole and Vishkin [18] devised an algorithm that solves the symmetry
breaking problems in deterministic log∗ n + O(1) time on some basic graphs such as paths,
rings, rooted trees, and alike.1 Goldberg et al. [31] extended the result of [18] and showed
that the symmetry breaking problems can be solved in deterministic O(∆2 ) + log∗ n time.
Linial [55] devised an O(∆2 )-coloring algorithm that runs in deterministic log∗ n + O(1)
time. He also showed fundamental nearly-tight lower bounds for the symmetry breaking
problems in rings, paths and trees. These lower bounds match the upper bounds of Cole
and Vishkin [18].
For general graphs Awerbuch et al. [5] and Panconesi√ and Srinivasan [69] devised
deterministic algorithms for these problems that require 2O( log n) time. These algorithms
are based on constructions of ruling sets. Ruling sets are relaxations of MIS, and can be
computed much faster. Specifically, in [5] ruling sets with certain parameters are computed
in logarithmic time. Recently, Kothapalli and Pemmaraju [46] devised algorithms for certain
ruling sets that require O(log log n) time. However, currently it is unknown whether this
construction can be used to speed up coloring and MIS computations.
These results (mostly covered in Peleg’s monograph [67]) left open a number of fun-
damental open questions. Among the most notable of them are:

1. Can these problems be solved in deterministic polylogarithmic time?

In particular, Linial [55] asked whether one can compute a coloring that employs
o(∆2 ) colors in deterministic polylogarithmic time.

2. Can the O(log n) time bound for randomized algorithms be improved?

3. Are there special graph families for which far more efficient algorithms exist?

4. How fast can these problems be solved in terms of the maximum degree ∆, when the
dependence on n is as mild as O(log∗ n)?
3 The arboricity is the minimum number of forests into which the edge-set of G can be decomposed. This
parameter will be discussed in Section 2.3. Up to a factor 2 this parameter is equal to the degeneracy of the
graph G.
1 log∗ n is a very slowly growing function. log(0) n = n, and for i = 1, 2, ..., log(i) n = log log(i−1) n. log∗ n is the
2
smallest value of i such that log(i) n ≤ 2.
 3
For all these questions significant progress has been made. Specifically, with regards to
the first question Hanckowiack, Karonski and Panconesi [35] showed that the Maximal
Matching problem can be solved in deterministic polylogarithmic time. In [9] the authors
of this monograph answered Linial’s question in the affirmative, and showed that ∆1+o(1) -
coloring can be computed in deterministic polylogarithmic time.
With regards to the second question, Kothapalli et al. [47] came up with a random-
√
ized O(∆)-coloring algorithm that requires O( log n) time. Their results were improved
by Schneider and Wattenhofer [78], and the latter results were subsequently improved by
Barenboim et al. [11]. Specifically, Barenboim et al. [11] showed that an MIS can be com-
√ √
puted in O( log n · log ∆) time, a (∆ + 1)-coloring in 2O( log log n) + O(log ∆) time, and
a Maximal Matching in O((log log n)4 + log ∆) time. (See Sections 10.3 and 10.4 in the
current monograph.)
With regards to the third question there were two remarkable developments. First
Kuhn et al. [49] identified the family of graphs with bounded growth. These are graphs
G = (V, E) in which for every vertex v ∈ V , the 2-neighborhood of v (i.e., the set of vertices
at distance at most 2 from v) does not contain more than a certain pre-defined number
of independent vertices. A sequence of papers [49, 51, 30, 77] that studied the symmetry
breaking problems in these graphs culminated in the work by Schneider and Wattenhofer
[77]. The latter authors extended the result of Cole and Vishkin [18], and showed that the
aformentioned symmetry breaking problems can be solved in O(log∗ n) time in graphs of
bounded growth.
The second development in the context of the third question was the study of graphs
with bounded arboricity (see Chapter 5), initiated in [7]. We showed there that symmetry
breaking problems can be solved in O( logloglogn n ) deterministic time in graphs of constant
arboricity (including planar graphs), and in deterministic polylogarithmic time whenever
arboricity is at most polylogarithmic in n. The methodology developed in [7] was also used
in [9] for devising a ∆1+o(1) -coloring in deterministic polylogarithmic time.
With regards to the fourth question Szegedy and Vishwanathan [74] proved a lower
bound that shows that any coloring algorithm of a certain type (called a locally-iterative1
algorithm) requires Ω(∆ log ∆ + log∗ n) rounds for (∆ + 1)-coloring. The state-of-the-art
(∆ + 1)-coloring algorithm at that time was a locally-iterative algorithm by [31], that re-
quires O(∆2 ) + log∗ n time. This result was improved to O(∆ log ∆) + log∗ n by Kuhn and
Wattenhofer [53]. The algorithm in [53] can also be viewed as locally-iterative, and thus
their result is tight for locally-iterative algorithms. However, recently the authors of the
current monograph [8] and independently Kuhn [48] devised (∆ + 1)-coloring algorithms
that run in O(∆) + log∗ n time, breaking the barrier of Szegedy and Vishwanathan [74].

1 Roughly speaking, an algorithm in which every vertex v in every round selects a new color based only on its
previous color and on colors of its neighbors is called locally-iterative. See also Section 3.8.
4 1. INTRODUCTION

The algorithms of [8] and [48] are not locally-iterative. Instead they are based on the notion
of defective coloring (see Section 2.4, and Chapter 6).
The goal of the current monograph is to cover most of these developments, and
as a result to provide a treatise on theoretical foundations of distributed graph coloring,
MIS, and related problems. To make the monograph suitable also for readers that are not
familiar with the field of distributed coloring, we provide the required background in the
first chapters. We start (Chapter 2) with providing some basics of Graph Theory that
are necessary for understanding the following chapters. We then proceed (Chapter 3) to
describing the basic distributed graph coloring algorithms, such as the algorithms of Cole
and Vishkin [18], Goldberg et al. [31] and Linial’s algorithm [55]. This chapter also contains
a section about more recent Kuhn-Wattenhofer’s color reduction technique. Even though
it was discovered in the last decade, we feel that it ”morally” belongs to the basics of
distributed graph coloring theory. Additional fundamental results are discussed in Chapter
4 which deals with Linial’s lower bounds [55].
The rest of the monograph deals with recent developments. Chapter 5 is devoted
to algorithms that compute forest decompositions, and use them for coloring graphs of
bounded arboricity. It is mostly based on the paper [7] by the authors of the current mono-
graph. Chapter 6 is devoted to defective coloring, and to its applications to the computation
of (∆ + 1)-coloring in O(∆) + log∗ n time. This chapter is based on the papers [8, 48]. In
Chapter 7 we introduce the notion of arbdefective coloring, which is an extension of the
notion of defective coloring. We then show how to compute arbdefective coloring efficiently,
and how to use them to compute a ∆1+o(1) -coloring in deterministic polylogarithmic time.
As was mentioned above, this result answers Linial’s open question in the affirmative. This
chapter is based on our paper [9].
In chapter 8 we turn our attention to edge-coloring. We start with presenting the
classical algorithm by Panconesi and Rizzi [68] that computes (2∆ − 1)-edge-coloring and
maximal matching in O(∆) + log∗ n time. We then show that in graphs with bounded
arboricity these objects can be computed in O( logloglogn n ) time [7]. Finally, we describe our
∆1+o(1) -edge-coloring algorithm from [10] that requires O(log ∆) + log∗ n time. The latter
algorithm is based on the notions of defective and arbdefective colorings, described in
Chapters 6 and 7. Another feature of this algorithm is the utilization of the notion of
“bounded neighborhood independence”. This graph parameter is presented and discussed
in Section 8.2.
In chapter 9 we describe the Network-Decomposition technique that was introduced
by Awerbuch et al. [5] and its applications. Roughly speaking, network-decompositions are
partitions of the input graph into a bounded number of subgraphs with bounded diameters.
These partitiones turned out to be extremely useful for solving a variety of problems in-
cluding (∆ + 1)-coloring and MIS. Currently, the best-known deterministic algorithms for
these problems in general graphs are based on network-decompositions [69]. We describe
 5
algorithms for computing network-decompositions and for using them to solve coloring
problems.
While Chapters 3 - 9 deal with deterministic algorithms, in Chapter 10 we turn our at-
tention to randomized ones. We start with presenting some classical logarithmic algorithms
√
[60, 61]. Next we describe a more recent O(∆)-coloring algorithm that runs in O( log n)
time. This algorithm is a variant of an algorithm presented by Kothapalli et al. [47]. We
then proceed to more advanced distributed MIS and maximal matching algorithms, that
are based on the recent work by Barenboim et al. [11]. Finally, in Chapter 11 we overview
the numerous open problems in this field.
Distributed graph coloring and symmetry breaking is a vast area, and we could not
cover it entirely in this monograph. The most notable omissions are:

1. We do not present the recent lower bounds by Kuhn, Moscibroda and Wattenhofer
[50, 52]. In a major breakthrough, Kuhn et al. [50, 52] showed that MIS and maximal
√
matching require Ω(min{ log n, log ∆}) time.

2. The entire theory of distributed symmetry breaking in graphs of bounded growth

[49, 51, 30, 77] was left out of our monograph. We feel that this subject justifies a
separate monograph.

3. The string of beautiful papers of Panconesi and his co-authors [24, 32, 33, 71, 70] and
by Chierichetti and Vattani [16] about randomized edge-coloring and Brooks-Vizing
vertex coloring is not covered in our monograph. This fascinating subject is, however,
partially covered in the excellent monograph by Dubhashi and Panconesi [25].

In part, the monograph evolved from lectures that the second-named author gave in
Ben-Gurion University in the Distributed Algorithms class in Autumn 2012. However, it
contains more material than can be covered in one semester. Depending on the level of the
course and the teacher’s taste, one can skip Chapter 4 or/and Chapters 6 - 8, and still give
the students quite a coherent picture of the field. Our intention is that the monograph will
be used both for self-study and for teaching graduate courses. We hope that it will further
stimulate the progress in this vivid research area.
6

CHAPTER 2

Basics of Graph Theory

In this chapter we provide the background in Graph Theory which is most relevant to this
monograph. We make no attempt to survey this entire area. Many books are devoted to
this subject. See, e.g., [13, 23].

2.1 GRAPHS WITH LARGE GIRTH AND LARGE

CHROMATIC NUMBER
The girth of a graph G = (V, E) is the minimum length of a simpe cycle in G. A legal
coloring ϕ of a graph G = (V, E) is a function ϕ : V → IIN from its vertex set to natural
numbers that satisfy that ϕ(v) 6= ϕ(u), for every edge (v, u) ∈ E. The coloring ϕ is called
a k-coloring, for an integer k ≥ 2, if the image of ϕ is the set {1, 2, ..., k} = [k].
The chromatic or coloring number of a graph G, denoted χ(G), is the minimum k for
which there exists a legal k-coloring of G. The problem of finding an optimal legal coloring
(a legal coloring that employs χ(G) colors) is NP-hard [43, 29]. Moreover, providing even
a loose n1−ǫ -approximation to this problem is NP-hard as well [12, 38, 79]. In the context
of distributed algorithms we are mostly interested in a much simpler problem, specifically,
in (∆ + 1)-coloring, where ∆ = ∆(G) is the maximum degree of a vertex in G.

Lemma 2.1 For every graph G = (V, E), it holds that χ(G) ≤ ∆ + 1.

Proof. Let V = (v1 , v2 , ..., vn ) be an arbitrary ordering of vertices of G. The proof is

by induction on n. The base (n = 1) is immediate. For the induction step suppose that
v1 , v2 , ..., vn−1 are already legally (∆ + 1)-colored. The vertex vn has at most ∆ neighbors,
and thus, there are at most ∆ forbidden colors for vn . Therefore, there always exists an
available color for vn (which is different from the colors of all neighbors of vn ) from the set
[∆ + 1]. 2

The algorithm described in this proof is inherently sequential. One of the main challenges
of distributed graph algorithms is to devise efficient distributed algorithms for (∆ + 1)-
coloring. Another closely related challenge is to construct a Maximal Independent Set
(henceforth, MIS).
A set U ⊆ V of vertices is independent if there is no edge (u, w) ∈ E with u, w ∈ U . An
independent set U is said to be maximal if for every vertex v ∈ V \ U , the set U ∪ {v} is
not an independent set.
 2.1. GRAPHS WITH LARGE GIRTH AND LARGE CHROMATIC NUMBER 7
Note that similarly to (∆ + 1)-coloring, an MIS can also be constructed greedily. To
describe a greedy algorithm for computing an MIS we need to introduce some notation. For
a vertex v, denote by Γ̂(v) (respectively, Γ(v)) the set of neighbors of v including (resp.,
S
not including) v. For a vertex set U ⊆ V , let Γ̂(U ) = u∈U Γ̂(u). To compute an MIS,
initialize U = ∅. Pick an arbitrary vertex v ∈ V \ Γ̂(U ), and add it to U . Continue as long
as V \ Γ̂(U ) 6= ∅. It is easy to verify that this simple algorithm constructs an MIS. However,
it is also inherently sequential. Finding efficient distributed MIS and coloring algorithms is
the subject of this monograph.
A natural way to construct a graph with chromatic number k is to use a k-clique Kk .
This example suggests that the requirement to have large chromatic number is contradictory
to having large girth. (The girth of a graph G is the length of the shortest cycle in G.)
Nevertheless, we will next show that one can construct graphs which simultaneously have
arbitrarily large girth and chromatic number. We will start with explicit constructions
of triangle-free graphs with arbitrary large chromatic number. We will then proceed to
constructing graphs with girth at least 6 and arbitrarily large chromatic number. Finally,
we will describe Erdős’s classical proof that graphs with arbitrarily large girth and chromatic
number exist. The latter proof is a celebrated example of using the Probabilistic Method.
See [2] for a comprehensive treatis on this subject.
It is easy to construct a triangle-free graph (i.e., a graph with girth at least 4) with
chromatic number 3. This is a 5-cycle C5 , or, more generally, any odd cycle. Constructing
a triangle-free graph with chromatic number 4 is already more challenging. See Figure 2.1
for the Grotzsch graph [34]. The Grotzsch graph G = (V, E) has 11 vertices. It consists of a
5-cycle (x1 , x2 , x3 , x4 , x5 ). For every pair i, j ∈ [5], i 6= j, of distinct not consecutive indices
(5 and 1 are consecutive), add a vertex yij , and connect it to xi and to xj by two edges
(xi , yij ), (yij , xj ). Finally, add a vertex z and connect it to all the five vertices yij . It is
easy to verify that G is triangle-free.
8 2. BASICS OF GRAPH THEORY

Figure 2.1: Grotsch graph.

Lemma 2.2 χ(G) = 4.

Proof. To show that χ(G) ≤ 4 it is enough to construct a legal 4-coloring ρ of G. This is

a straight-forward exercise.
Next we argue that χ(G) ≥ 4. Any legal 3-coloring ϕ of the cycle C =
(x1 , x2 , x3 , x4 , x5 ) is such that one vertex is colored by a unique color, and each of the other
two colors is employed by two vertices. Denote the unique color by 3, and suppose without
loss of generality that ϕ(x5 ) = 3. Then ϕ(y14 ) = 3, as {ϕ(x1 ), ϕ(x4 )} = {1, 2}. If ϕ(x1 ) = 1
and ϕ(x4 ) = 2 then ϕ(y25 ) = 1, ϕ(y35 ) = 2, and ϕ(y14 ) = 3. Hence ϕ(z) ∈ / {1, 2, 3}. Sim-
ilarly, if ϕ(x1 ) = 2 and ϕ( x4 ) = 1 then ϕ(y35 ) = 1, ϕ(y25 ) = 2, and ϕ(y14 ) = 3, and so
ϕ(z) ∈ / {1, 2, 3}. Hence ϕ employs at least 4 colors. 2

Next we describe Mycielski’s construction [64]. This construction generalizes Grotzsch

graph. It provides a way to obtain triangle-free graphs with χ(G) = k, for an arbitrarily
large integer k. Suppose that we are given a triangle-free graph G = Gk with χ(G) = k.
Let V = {v1 , v2 , ..., vn } denote its vertex set. We construct the graph G′ = Gk+1 in the
following way. Let V ′ = V ∪ U ∪ {u}, U = {u1 , u2 , ..., un }. The vertex u is called the center
vertex of Gk+1 . The graph G(V ) is isomorphic to G. Also, we add a star (u, ui ), for every
 2.1. GRAPHS WITH LARGE GIRTH AND LARGE CHROMATIC NUMBER 9
i ∈ [n]. Finally, each vertex ui is connected to all vertices in Γ(vi ). Observe that Grotzsch
graph is obtained from Mycielski’s construction applied to C5 .

Lemma 2.3 G′ is triangle-free.

Proof. The center vertex is not a part of any triangle, because it is connected only to
vertices of U , and there are no edges between vertices of U . Triangles that contain a single U -
vertex (i.e., (ui , vp , vq )) are impossible, because if such a triangle exists then vp , vq ∈ Γ(vi ),
i.e., there is a triangle in G. This is a contradiction. Triangles that contain a single vertex
from V are impossible, because there are no edges between U -vertices. 2
Obviously, χ(Gk+1 ) ≤ k + 1. Indeed, we can color G with k colors. Each ui can be colored
by the same color as vi , and then the center u can be colored by the color k + 1.

Lemma 2.4 χ(G′ ) ≥ k + 1.

Proof. Suppose for contradiction that there exists a legal k-coloring ϕ of G′ . Suppose
without loss of generality that ϕ(u) = k. Denote by Ṽ the subset of V with vertices colored
by color k. For each vertex vi ∈ Ṽ we recolor it by setting ϕ′ (vi ) = ϕ(ui ). All other vertices
retain their colors, i.e., set ϕ′ (w) = ϕ(w). Consider an edge (vi , vj ) ∈ E. If vi , vj ∈ / Ṽ , then
′ ′
ϕ (vi ) = ϕ(vi ) 6= ϕ(vj ) = ϕ (vj ). Otherwise, suppose without loss of generality that vi ∈ Ṽ .
Then vj ∈ / Ṽ . Since (ui , vj ) is an edge in G′ , it follows that ϕ′ (vi ) = ϕ(ui ) 6= ϕ(vj ) = ϕ′ (vj ).
′
Hence ϕ is a legal coloring of G, and it employs at most k − 1 colors. This is a contradiction
to χ(G) = k. Hence there is no legal k-coloring of G′ , i.e., χ(G′ ) ≥ k + 1. 2
To summarize, we have shown that G′ = Gk+1 is a triangle-free graph with coloring number
k + 1. Denote by nk the number of vertices in Gk . It follows that nk+1 = 2 · nk + 1, i.e.,
nk = 6 · 2k−3 − 1, for k ≥ 3. Therefore, Mycielski’s construction provides (explicit) n-vertex
triangle-free graphs with chromatic number Ω(log n).
Next we describe another explicit construction due to Tutte [22], of graphs G with
girth at least 6, and arbitrarily large chromatic number χ(G) = k. This construction will be
referred to as Descartes’s construction1 . The number of vertices in these graphs is, however,
very large in terms of k. (Even much larger than exponential in k, which is the dependence in
Mycielski’s construction.) Similarly to Mycielski’s construction, Descartes’s construction is
inductive as well. We are given a graph G = Gk with girth(G) ≥ 6, χ(G) = k, and construct
a graph G′ = Gk+1 with girth(G′ ) ≥ 6 and χ(G′ ) = k + 1.
Denote n = nk = |V (Gk )| the number of vertices in Gk . Let T , T ≫ n, be a number
that will be determined in the sequel. Let U be a set of T vertices, which we will call
”groundset”. For every n-vertex subset of the groundset, we create a (new) copy of G. The
n vertices of the copy are connected to the vertices of the subset via an arbitrary perfect
matching. This completes the description of the graph G′ = Gk+1 . Its chromatic number
1 Tutte used the pseudonym ”Descartes” in his note [22] which described this construction.
10 2. BASICS OF GRAPH THEORY

Figure 2.2: Descartes’s construction.

is obviously at most k + 1. (Just color all copies of G by k colors, and use color k + 1 for
vertices in the groundset U .)
Also, the shortest cycles that cross between different copies of G are of the form
(vi , vj , u1 , vp′ , vq′ , u2 , vi ), with vi , vj belonging to one copy of G, vp′ and vq′ belonging to
another copy, and u1 , u2 ∈ U . (See Figure 2.3.) Hence girth(G′ ) ≥ 6. It remains to argue
that G′ cannot be colored by k colors.
 2.1. GRAPHS WITH LARGE GIRTH AND LARGE CHROMATIC NUMBER 11

Figure 2.3: Shortest cycles in a graph G′ , obtained via Descartes’s construction.

Lemma 2.5 For T ≥ (n − 1) · k + 1, it holds that χ(G′ ) ≥ k + 1.

Proof. Consider a k-coloring ϕ of G′ . There exists a subset U ′ ⊆ U of the groundset U with

|U ′ | ≥ ⌈T /k⌉ vertices, that are all colored by ϕ with the same color. Set T = (n − 1) · k + 1,
i.e., |U ′ | = ⌈T /k⌉ = n. (If |U ′ | > n, remove arbitrary |U ′ | − n vertices from U ′ .) Suppose
without loss of generality that all vertices of U ′ are colored by k. There is copy of G that
corresponds to the subset U ′ . This copy is connected to U ′ via a perfect matching. Thus,
no vertex in this copy is colored by color k. Thus, vertices of this copy are colored by colors
from the palette [k − 1]. However, χ(G) ≥ k, and thus ϕ is not a legal coloring of this copy.
Hence ϕ is not a legal coloring of G′ . 2


The number of vertices in G′ satisfies the recursion nk+1 ≈ nnkk·k · nk ≈ k nk · nk . In other
words, it is a huge number that can be expressed by a tower function. To summarize:

Theorem 2.6 Descartes’s constructions provides (explicit) n-vertex graphs G with

girth(G) ≥ 6 and χ(G) = ω(1).

There are known much better (and far more complicated) explicit constructions of graphs
with high girth and chromatic number. (See [59]. They are based on Ramanujan graphs,
and are outside the scope of this monograph.) Next, we describe Erdős’s probabilistic (and,
therefore, not explicit) proof of existence of such graphs.
12 2. BASICS OF GRAPH THEORY

Theorem 2.7 [26]: For every k, ℓ, there exists a graph G with girth(G) > k and χ(G) ≥ ℓ.
Remark: This theorem means that chromatic number is not a local property. Indeed, a
graph with high girth looks locally like a tree. On the other hand, a tree has chromatic
number 2, while a graph with high girth may have an arbitrarily large chromatic number.
Proof. Set ϑ < 1/k, and p = nϑ /n. Consider the distribution G(n, p) of n-vertex graphs,
in which every edge appears with probability p, independently of other edges. (We refer
the readers to [14, 41] for extensive treatment of random graph theory.) Denote by X the
random variable that counts cycles of length at most k in a graph G selected from the
distribution G(n, p). Then the expectation IIE(X) of X is given by
k
X (n)i
IIE(X) = · pi .
i=3
2i

Here (n)i is the number of possibilities to choose i vertices from n vertices, where the order
is important. The expression is divided by i because any sequence of i distinct vertices can
be arbitrarily rotated, and the rotated sequence gives rise to the same cycle. Similarly, it is
divided by 2, because any such sequence can be reversed, while still giving rise to the same
cycle in the n-clique Kn . Hence
k
X k
ni 1 X nϑi
IIE(X) ≤ · n(ϑ−1)i = = o(n),
i=3
2i 2 i=3 i

n/2
because ϑ < 1/k. By Markov’s inequality, IIP(X ≥ n/2) = IIP(X ≥ o(n) · o(n)) < o(n)
n/2 =
o(1). In other words, with high probability, the selected graph has only a small number
of short cycles.
The second part of the proof shows that with high probability there are l no large
m
independent sets, and thus, the chromatic number is not too small. Set x = p3 · ln n =
 
3 · n1−ϑ · ln n . Denote by α(G) the size of the maximum independent set in the graph G.
(Notice that in contrast to a maximal independent set, a maximum independent set is an
independent set of maximum cardinality in G.) For a given set Q ⊆ V of x vertices, denote
by I(Q) the indicator random variable of the event {Q is an independent set}. Then
X
IIP(α(G) ≥ x) ≤ IIP(I(Q)).
Q⊆V,|Q|=x

x

Also, IIP(I(Q)) = (1 − p)(2) . (For each of the x2 pairs of vertices from Q, there is no edge
between them with probability (1 − p), independently of other pairs.) Hence,
   e · n x  x
n x
IIP(α(G) ≥ x) ≤ · (1 − p)(2) ≤ · e−p·x·(x−1)/2 < n · e−p·(x−1)/2 .
x x
 2.1. GRAPHS WITH LARGE GIRTH AND LARGE CHROMATIC NUMBER 13
 1−ϑ

(The last inequality requires x = 3 · n ln n > e, which, of course, holds for a sufficiently
large n.) Since p · (x − 1)/2 > 2 ln n − p/2 ≥ 43 ln n, it also holds that n · e−p·(x−1)/2 ≤
3

1/n1/3 .
Thus IIP(α(G) ≥ x) ≤ (1/n1/3 )x = o(1), and IIP(χ(G) ≤ nx ) ≤ IIP(α(G) ≥ x) = o(1).
Hence IIP((α(G) ≥ x) or (X ≥ n/2)) = o(1), and so IIP((α(G) < x) and (X < n/2)) =
 − 1−ϑ
1 o(1) > 0.
 Consider a graph G that satisfies these two properties, i.e., α(G) < x =
3n ln n , and it has less than n/2 short cycles (i.e., cycles of length at most k). Remove
one vertex from each of these short cycles. Denote the graph induced on surviving vertices by
G′ . The number n′ of vertices in G′ satisfies n′ > n/2. Moreover, girth(G′ ) > k. Finally, any

independent set in G′ is an independent set in G too, and so α(G′ ) < x = 3n1−ϑ ln n ≤
 ′(1−ϑ)  ′ϑ
6n · (ln n′ + 1) = O(n′(1−ϑ) ln n′ ). Hence χ(G′ ) = Ω( lnn n′ ), as required. 2

Therefore, we proved that for every positive integer k there exists an n-vertex graph
nϑ
G with girth(G) > k and chromatic number almost n1/k . (Specifically, Ω( ln n ), for ϑ < 1/k
being arbitrarily close to 1/k.) By a more careful analysis one can also guarantee χ(G) =
1/k
Ω( n k ) in this proof. By modifying the construction slightly one can also ensure that the
maximum degree ∆(G) of this graph is upper bounded by O(n1/k ).
We finish this section by showing that any graph G with girth(G) > k is quite sparse.
We will later use this lemma to show that the condition girth(G) > k implies χ(G) ≤
O(n2/k ), i.e., the dependencies between girth and chromatic number in Erdős’s theorem is
at the right ballpark.
Before stating the lemma we introduce a few definitions.

Definition 2.8 In an unoriented graph G = (V, E), the distance between a pair of vertices
u, v ∈ V , denoted distG (u, v), is the number of edges in the shortest path connecting u and v
in G. Denote also by δ(G) the minimum degree of a vertex in G. For a vertex v, denote by
deg(v) = degG (v) = |Γ(v)| the degree of a vertex v. Then δ(G) = min{deg(v) | v ∈ V } and
∆(G) = max{deg(v) | v ∈ V }. Also, for a positive integer ℓ, let Γ̂ℓ (v) (respectively, Γℓ (v))
denote the ℓ-neighborhood of a vertex v including (resp., not including) v, i.e., the set of
all vertices at distance at most ℓ including v (resp., not including v).

Lemma 2.9 For an even positive integer k, and a graph G = (V, E) with girth(G) > k, it
holds that m ≤ n1+2/k + n, where m = |E|, n = |V |.
′ ′
Proof.
m
  m for any graph G, there exists an induced subgraph G with δ(G ) ≥
We argue that
n + 1. If δ(G) ≥ m n + 1 then we are done.
 m Otherwise iteratively remove from G a vertex
′
v with deg(v) ≤ n . We stop if δ(G ) ≥ n + 1; otherwise continue removing vertices.
Suppose for contradiction that we removed all vertices. Observe that after (n − 1) iterations,
all edges are eliminated.  m is at most n − 1. In each iteration
 m  Thus the number of iterations
we removed at most n edges. Hence m ≤ (n − 1) · n , contradiction.  mTherefore,
 G′ does
′ ′
contain some vertices. Hence G is a non-empty graph with δ(G ) ≥ n + 1. Also, since
14 2. BASICS OF GRAPH THEORY

G is an induced subgraph of G, it follows that girth(G′ ) ≥ girth(G) > k. Denote by n′ the

′

number of vertices in G′ . To provide a lower bound for n′ , consider a k2 -neighborhood of

a vertex v in G′ . Since girth(G′ ) > k, it follows that n ≥ n′ ≥ |Γ̂k/2 (v)| ≥ (δ(G′ ) − 1)k/2 =
 m k/2
n . Hence n2/k ≥ mn − 1, and the lemma follows. 2

2.2 PLANAR GRAPHS

In this section we provide some background about planar graphs. This is a large area;
see, e.g., [63] for an extensive treatise. The discussion below follows to a large extent, the
monograph of Bollobas [13], Chapter I.4.
Definition 2.10 A planar graph is a graph that can be drawn on the surface of a sphere
in such a way that no two edges of it intersect (except for intersections in vertices).
Definition 2.11 A plane graph is a specific drawing of a planar graph.
A face of a plane graph G is a polygon whose boundary is a chordless cycle, i.e., a cycle
(v0 , v1 , ..., vℓ = v0 ) in G, such that there is no edge (vi , vj ) between a pair of non-consecutive
vi and vj which crosses the cycle. See Figure 2.4.

Figure 2.4: An example of a plane graph drawn in the plane.

 2.2. PLANAR GRAPHS 15
It is often more convenient to think about planar graphs as drawn in the plane, rather
than on a sphere. When a planar graph is drawn in a plane one of its faces becomes the
outer face. On the other hand, in a drawing on a sphere, all faces play the same role.
Observation 2.12 A subgraph of a planar graph is a planar graph as well.
Theorem 2.13 (Euler’s formula) In a connected plane graph with n vertices, m edges, and
f faces, it holds that n − m + f = 2.
Before we prove the theorem, we provide one more definition and observation.
Definition 2.14 An edge e is a bridge edge in a graph G if G \ {e} is not connected.
Observation 2.15 In a bridgefree plane graph, every edge is adjacent to exactly two faces.
On the other hand, a bridge edge is adjacent only to the outer face.
Proof. (of Theorem 2.13) The proof is by induction on the number of faces f .
Base: If f = 1 then G has no cycles. (Its only face is the outer face.) Hence G is a tree,
i.e., n = m + 1, and n − m + f = 2.
Step: Suppose that f ≥ 2. Then G contains a cycle. Let e = (u, v) be an edge in some cycle
in G. The edge lies on a boundary of two faces, S and T . If the edge e is removed from
the graph G, we obtain a graph G′ = G \ {e} with f ′ = f − 1 faces, n′ = n vertices, and
m′ = m − 1 edges. By the induction hypothesis, n′ − m′ + f ′ = 2, and so n − (m − 1) +
(f − 1) = n − m + f = 2. 2
An interesting consequence of Euler’s characteristic is that every drawing of a planar graph
(such that no two edges intersect) has exactly the same number of faces.
Fix a plane graph G. Denote by fi , for every i ≥ 1, the number of faces
α in G that have exactly i edges on their boundaries, i.e., Fi = {α is a face of G:
P
α has i edges on its boundary}, and fi = |Fi |. Obviously i≥1 fi = f . Denote by F the
set of all faces of G.
P
Lemma 2.16 Suppose that G is bridgefree. Then i≥3 ifi = 2m.
Proof. Let N denote the number of pairs (e, α) such that the edge e lies on the
boundary of the face α. Denote also by I(e, α) the indicator variable of the event
{e lies on the boundary of α}. Then, since G is bridgefree,
XX XX X
N= I(e, α) = I(e, α) = 2 = 2m.
α∈F e∈E e∈E α∈F e∈E

Also, XX XXX XX X
N= I(e, α) = I(e, α) = i= ifi .
α∈F e∈E i≥3 α∈Fi e∈α i≥3 α∈Fi i≥3
2
16 2. BASICS OF GRAPH THEORY

Next, we prove a useful bound on the number of edges in a planar graph.

Theorem 2.17 In an n-vertex planar graph G, n ≥ 3, the number of edges m satisfies

g
m ≤ 3n − 6. Moreover, if girth(G) ≥ g (and g ≥ 3), then m ≤ max{ g−2 · (n − 2), n − 1}.

Proof. The proof is by induction on n.

Base: If n ≤ g − 1, then the graph G has no cycles. In this case m ≤ n − 1, as required.
Suppose now that n ≥ g.
Step: First consider the case that G contains a bridge e = (u, v). Then G \ {e} is a union
of two vertex-disjoint graphs G1 , G2 . Denote n1 = |V (G1 )|, n2 = |V (G2 )|, m1 = |E(G1 )|,
m2 = |E(G2 )|. By induction hypothesis
g g
m = m1 + m2 + 1 ≤ max{ (n1 − 2), n1 − 1} + max{ (n2 − 2), n2 − 1} + 1.
g−2 g−2
(2.1)
The proof splits into three cases.
g g
Case 1: g−2 (n1 − 2) ≤ n1 − 1 and g−2 (n2 − 2) ≤ n2 − 1. Then the right-hand-side of (2.1)
is equal to n − 1, as required.
g g
Case 2: g−2 (n1 − 2) > n1 − 1 and g−2 (n2 − 2) > n2 − 1. Then the right-hand-side of (2.1)
g g g+2 g
is equal to g−2 (n − 4) + 1 = g−2 (n − 2) − g−2 < g−2 (n − 2), as required.
g g
Case 3: g−2 (n1 − 2) > n1 − 1 and g−2 (n2 − 2) ≤ n2 − 1. (The remaining case is symmetric
g 2
to Case 3.) Then the right hand side of (2.1) is equal to g−2 (n1 − 2) + n2 = n + g−2 n1 −
2g g g 2g
g−2 ≤ g−2 (n − 2) = g−2 n − g−2 . This completes the analysis of the case that G contains
a bridge. Next, we turn to the complimentary case (that G is bridgefree).
P P
In this case, by Lemma 2.16, 2m = i≥3 ifi = i≥g ifi , because there are no faces
P P
with less than g edges incident on them. It holds that i≥g ifi ≥ g i≥g fi = g · f , and so
f ≤ g2 · m. By Euler’s formula (Theorem 2.13), 2 = n − m + f ≤ n − m + g2 m = n − g−2 g m,
g
and so m ≤ g−2 (n − 2). In particular, for g = 3 we get the bound m ≤ 3n − 6. 2

The upper bound from Theorem 2.17 on the number of edges of a planar graph has
an important application to colorability of planar graphs.

Theorem 2.18 Every planar graph is 6-colorable.

Proof. Observe that there exists a vertex v with deg(v) ≤ 5. Indeed, otherwise all vertices
P
have degree at least 6, and so 2|E| = v∈V deg(v) ≥ 6n, i.e., |E| ≥ 3n. The latter, however
contradicts Euler’s formula.
Denote the vertex v as above by vn . Let G = Gn , and Gn−1 = Gn \ {vn }. Gn−1 is a
planar graph as well. Let vn−1 be a vertex of degree at most 5 in Gn−1 , etc. We end up
constructing a sequence of vertices v1 , v2 , ..., vn , so that for every index i ∈ [n], vi has at
most 5 neighbors vj with index j < i. Now we color the vertices one after another using
the palette [6] = {1, 2, ..., 6}. Suppose we have already colored v1 , v2 , ..., vi−1 , for some i,
 2.3. ARBORICITY 17
1 ≤ i ≤ n. To color vi we note that it has at most 5 neighbors that are already colored, and
thus, there is necessarily a color in our palette which is available for vi . We color vi by this
color. 2
It is known that any planar graph is, in fact, 4-colorable [3]. The proof of this is, however,
far beyond the scope of this monograph.

2.3 ARBORICITY
In this section we introduce the graph parameter called arboricity, and prove some basic
properties of this parameter. As we shall see in the sequel (Chapters 5 and 7), arboricity
and its properties play a central role in the theory of distributed graph coloring.

2.3.1 NASH-WILLIAMS THEOREM

There are two ways to define arboricity. The density of a graph G = (V, E), denoted ρ(G)
is defined by  
|E(H)|
ρ(G) = max ,
H⊆V,|H|>2 |H| − 1

where the maximum is over all possible subsets H ⊆ V with at least 2 vertices. The second
(and the more intuitive) way to define arboricity a(G) of a graph G = (V, E) is the following
one. The arboricity a(G) is the minimum number a of edge-disjoint forests F1 , F2 , ..., Fa ,
whose union covers the entire edge set E of the graph G = (V, E). Such a decomposition is
called an a-forest-decomposition of G.
A classical result in Graph Theory, which was proved by Nash-Williams [66] in 1961,
states that the two notions are equivalent.

Theorem 2.19 [66] For every graph G = (V, E), ρ(G) = a(G).

We start with proving a straightforward direction of this theorem.

Lemma 2.20 a(G) ≥ ρ(G)

l m
Proof. Consider the subset H ⊆ V of vertices that maximizes |E(H)| |H|−1 , i.e., ρ(G) =
l m
|E(H)|
|H|−1 .
a = a(G) edge-disjoint forests restricted to the vertex set H contain at most a · (|H| −
1) edges. Since the union of some a edge-disjoint forests covers the entire edge set E, it
follows that |E(H)| ≤ a · (|H| − 1). Hence a ≥ |E(H)|
|H|−1 . Since a is an integer it follows that
l m
|E(H)|
a ≥ |H|−1 = ρ(G). 2

Before we turn to the proof of the non-trivial direction of the Nash-Williams theorem, we
prove a number of basic properties of arboricity.
18 2. BASICS OF GRAPH THEORY
|E(H)|
Lemma 2.21 The subset H ⊆ V whith at least two vertices which maximizes |H|−1 , is
contained in a single connected component of G.

Proof. Suppose that G(H) decomposes into connected components

G(H1 ), G(H2 ), ..., G(Ht ), for some integer t ≥ 1. Then we argue that
Pt  
|E(H)| |E(Hi )| |E(Hi )|
= Pti=1 ≤ max , (2.2)
|H| − 1 ( i=1 |Hi |) − 1 1≤i≤t |Hi | − 1

and, moreover, the equality is attained only if t = 1. (Observe that each Hi contains at
least two vertices. Otherwise single-vertex ′
components can be removed, and as a result a
subset H ′ ⊆ H with a larger ratio |E(H
|H |−1
′
)|
will be obtained, contradiction.)
Denote |E(Hi )| = αi , |H | =
n io i β , |H i | − 1 = γi , for every
Pt
i ∈ [t]. Suppose without loss
αi
αi
of generality taht max1≤i≤t γi = γ1 . The proof that Pt γi ≤ αγ11 is by induction on i.
α1 i=1
i=1
The base is trivial. For the induction step write
Pt+1 Pt+1
i=1 αi αi + α1
Pt+1 = Pi=2
t+1 ,
i=1 γi i=2 γi + γ1
Pt+1 Pt+1 α1 +α′2
and denote α2′ = ′
i=2 αi , γ2 = i=2 γi . Now the right-hand side is equal to γ1 +γ2′ . By in-
n o
α′
duction hypothesis, γ ′2 ≤ αγ22 . Without loss of generality, let αγ22 = max2≤i≤t+1 αγii . Hence
2
α1 α2 α′2 α1 +α′2 α1
γ1 ≥ γ2 ≥ γ2
′ , and so γ1 +γ2′ ≤ γ1 . This completes the proof of inequality (2.2). Moreover,
for t > 1, Pt Pt
i=1 αi i=1 αi α1
Pt < Pt ≤ .
( i=1 βi ) − 1 i=1 (βi − 1) β1 − 1
Hence the equality in (2.2) is attained only if t = 1.
Hence if G(H) consists of more than one connected component then there exists a
connected components G(H1 ) of G(H) that satisfies
Pt
|E(Hi )| |E(H1 )|
Pti=1 < ,
( i=1 |Hi |) − 1 |H1 | − 1

contradicting the maximality of H. 2

Note that Lemma 2.21 implies that ρ(G) = max1≤i≤t ρ(Gi ), where G1 , G2 , ..., Gt are con-
nected components of G. Next we proof the non-trivial direction of the Nash-Williams
theorem. Our proof is based on [15].

Lemma 2.22 ρ(G) ≥ a(G),

Proof. Let G be a counter-example that minimizes |V | + |E|. G satisfies a(G) > ρ(G).
 2.3. ARBORICITY 19
Claim 2.23 G is connected.
Proof. Suppose for contradiction that G consists of t > 1 connected components
G1 , G2 , ..., Gt . We have seen that ρ(G) = max1≤i≤t ρ(Gi ). Also, clearly, a(G) =
max1≤i≤t a(Gi ). If ρ(Gi ) ≥ a(Gi ) for every i ∈ [t], then a(G) = max1≤i≤t a(Gi ) ≤
max1≤i≤t ρ(Gi ) = ρ(G). This is a contradiction to a(G) > ρ(G).
Hence there exists an index i ∈ [t] with a(Gi ) > ρ(Gi ), contradicting the minimality
of G. This completes the proof of the claim that G is connected. 2
Observe that |V | > 1, because otherwise a(G) = 0.
Claim 2.24 G is critical with respect to arboricity, i.e., a(G \ e) < a(G) holds for every
edge e ∈ E.
Proof. Indeed, otherwise, there exists an edge e ∈ E such that a(G \ e) = a(G). Also,
ρ(G \ e) ≤ ρ(G). Hence a(G \ e) = a(G) > ρ(G) ≥ ρ(G \ e), contradicting the maximality
of G. This completes the proof of the claim that G is critical with respect to arboricity.
2
For a graph G′ that satisfies the assertion of Claim 2.24, we will say that G′ is a(G)-arb-
critical. For a graph G′ = (V ′ , E ′ ) and its forest-decomposition E = (F1 , F2 , ..., Ft ), E ′ =
St ′
i=1 Fi , and Fi ∩ Fj = ∅ for every i 6= j, we say that E is a t-forest-decomposition of G .

Claim 2.25 Let G = (V, E) ba a connected and a(G)-arb-critical graph, and |V | > 1. Let
a = a(G). Then for every edge e ∈ E, any (a − 1)-forest-decomposition of (G \ e) is a de-
composition into (a − 1) spanning trees of G.
Before we prove this claim, we argue that it implies Lemma 2.22. Denote n = |V |. Since
(a − 1) edge-disjoint spanning trees contain (n − 1)(a − 1) edges, it follows that |E| − 1 =
|E(G \ e)| = (n − 1) · (a − 1), for every edge e. But,
 
|E(H)|
a(G) > ρ(G) = max .
H⊆V,|H|≥2 |H| − 1
l m l m
|E|
Hence a = a(G) > n−1 = (n−1)(a−1)+1
n−1 = a. This is a contradiction to a(G) > ρ(G).
So we only need to prove Claim 2.25 to complete the proof of Lemma 2.22 (and of Nash-
Williams theorem).
Proof. (of Claim 2.25): Suppose for contradiction that there exists an edge e = (u, v) ∈ E
and the decomposition of the edge set E \ e into (a − 1) edge-disjoint forests E1 , E2 , ..., Ea−1
in which E1 is not a spanning tree.
The edge set E1 ∪ {e} contains a cycle, as otherwise we get a decomposition of E into
a − 1 edge disjoint forests, E1 ∪ {e}, E2 , ..., Ea−1 . (This is, however, a contradiction to the
assumption that a(G) = a.) Hence both endpoints u and v of e are in a connected component
20 2. BASICS OF GRAPH THEORY

Figure 2.5: An illustration for Case 1 (i.e., t = 1).

T of E1 . Let U = G(V (T )) be the subgraph induced by V (T ) in G. Note that e ∈ E(U ).

Since E1 is not a spanning tree, V (T ) 6= V (G). Since G is connected, E(G) \ E(U ) 6= ∅.
Since G is a-arb-critical, it follows that U has a decomposition into (a − 1) edge-disjoint
forests E(U ) = A1 ∪ A2 ∪ ... ∪ Aa−1 .
Consider the set S of all a-forest-decompositions of G of the form (E1′ , ..., Ea−1 ′
, {e′ }),
with e′ ∈ E(U ) and such that a connected component of E1′ is a spanning tree of U . Observe
that (E1 , ..., Ea−1 , {e}) ∈ S. Let E = (Ē1 , ..., Ēa−1 , {ē}) ∈ S be an a-forest-decomposition
of G that maximizes
a−1
X
J (E) = |Ai ∩ Ēi |.
i=1

Recall that (A1 , A2 , ..., Aa−1 ) is a fixed (a − 1)-forest-decomposition of U . Since ē ∈ E(U ),

it follows that ē ∈ At for some t ∈ [a − 1]. Fix an index t such that ē ∈ At . The edge set
Ēt ∪ {ē} contains a cycle C which contains the edge ē. (Indeed, otherwise (Ē1 , ..., Ēt−1 , Ēt ∪
{ē}, Ēt+1 , ..., Ēa−1 ) is an (a − 1)-forest-decomposition of G, contradiction.)
Claim 2.26 All edges of C are in E(U ), i.e., E(C) ⊆ E(U ).
Proof. The proof splits into two cases, depending on the volume of t.
Case 1:(t = 1). Since E ∈ S, it follows that a connected component T of Ē1 is a spanning
tree for U . Also, Ē1 ∪ {ē} contains the cycle C, with ē ∈ C. Hence T ∪ {ē} contains C.
Finally, ē ∈ E(U ). Hence E(C) ⊆ T ⊆ E(U ).
Case 2:(t 6= 1). Suppose that E(C) is not contained in E(U ). E =
(Ē1 , Ē2 , ..., Ēa−1 , {ē}) is an a-forest-decomposition of G. A connected component T
of Ē1 is a spanning tree for U , and ē ∈ E(U ). Also ē ∈ At for some t ∈ [a − 1], where
E(U ) = A1 ∪ ... ∪ Aa−1 . Finally, Ēt ∪ {ē} contains a cycle C, ē ∈ C. Let f ∈ E(C) be
 2.3. ARBORICITY 21

Figure 2.6: An illustration for Case 2 (i.e., t 6= 1).

an edge with one endpoint in V (U ) = T and the other point in V (G) \ V (U ). (It exists
because E(C) * E(U ).)
Since a connected component of Ē1 spans U , it follows that Ē1 ∪ {f } is acyclic. Thus
(Ē1 ∪ {f }, ..., Ēt−1 , Ēt ∪ {e} \ {f }, Ēt+1 , ..., Ēa−1 ) is an (a − 1)-forest-decomposition of G,
contradiction. This completes the proof of Claim 2.26. 2
Now we return to the proof of Claim 2.25. Recall that ē ∈ At , and (A1 , A2 , ..., Aa−1 ) is an
(a − 1)-forest-decomposition of U . Since At is a forest (i.e., acyclic), there exists an edge
f ∈ E(C) \ At ⊆ E(U ). But Ẽ = (Ē1 , ..., Ēt−1 , Ẽt = Ēt ∪ {ē} \ {f }, Ēt+1 , ..., Ēa−1 , {f }) is a
decomposition in S. Note that
J (Ẽ) = J (E) + 1. (2.3)
To see it, observe that Ẽt ∩ At contains also the edge ē (which also belongs to At ), while
ē ∈
/ Ēt .
But (2.3) is a contradiction to the maximality of J (E). 2
This completes the proof of Claim 2.25, and hence of Nash-Williams theorem. 2
Next, we present several bounds on the number of edges and high-degree vertices in
graphs of bounded arboricity. We need the following definition.

Definition 2.27 For a pair of vertex sets A, B ⊆ V in a graph G = (V, E), denote by
E(A, B) the set of edges {(a, b) ∈ E | a ∈ A, b ∈ B}.

Lemma 2.28 Let G be a graph with m edges, n vertices and arboricity a. Then
(1) m ≤ a · n.
m a·n
(2) The number of vertices with degree at least t ≥ a + 1 is at most t−a ≤ t−a .
22 2. BASICS OF GRAPH THEORY

(3) The number of edges whose endpoints both have degree at least t ≥ a + 1 is at most
a·m
t−a .

Proof. (1) follows from the definition of arboricity. Denote U = {u | deg(u) ≥ t}. By def-
inition of arboricity, |E(U )| ≤ a · |U |. Thus, (1) and (2) implies (3). So it remains to prove
(2).
P
Also by definition of U , it holds that u∈U deg(u) ≥ t · |U |. For a fixed vertex u ∈ U , let
deg(u, U ) denote the number of neighbors it has in U . Since deg(u) ≥ t, it follows that

deg(u, V \ U ) = deg(u) − deg(u, U ) ≥ t − deg(u, U ).

Hence X X
|E(U, V \ U )| = deg(u, V \ U ) ≥ (t − deg(u, U )).
u∈U u∈U

Also,
X 1X
m ≥ |E(U, V \ U )| + |E(U )| ≥ (t − deg(u, U )) + deg(u, U )
2
u∈U u∈U
1X
= t · |U | − deg(u, U ) = t · |U | − |E(U )| ≥ (t − a)|U |.
2
u∈U

a·n
Since a · n ≥ m, we conclude that U ≤ t−a , as required. 2

2.3.2 DEGENERACY AND ARBORICITY

In this section we define the notion of degeneracy, which is closely related to the notion of
arboricity.

Definition 2.29 For a graph G = (V, E), the degeneracy degen(G) is the minimum integer
number d so that there exists an ordering of the vertex set of G, V = (v1 , v2 , ..., vn ), such
that for every index i ∈ [n − 1], vi has at most d neighbors with greater index. For a vertex
v and a vertex set U , let deg(v, U ) denote the number of neighbors that v has in U .

By a previous argument (see Theorem 2.18), χ(G) ≤ degen(G) + 1. (Once {v2 , v3 , ..., vn }
are all colored by d + 1 colors, d = degen(G), there is necessarily an available color for v1
in the palette [d + 1].) We have seen (Section 2.2) that for a planar graph G, degen(G) ≤ 5,
and thus, χ(G) ≤ 6.
Also, there exist graphs G with degen(G) = d and χ(G) = d + 1, for every value of
d. A clique Kd+1 with d + 1 vertices is an example of such a graph. Next, we analyze the
relationship between arboricity and degeneracy in general.

Lemma 2.30 For a graph G = (V, E), degen(G) ≤ 2a(G) − 1.

 2.3. ARBORICITY 23
Proof. Consider the following process. If there exists a vertex v with degG (v) ≤ 2a(G) − 1,
set v1 = v, and remove v (and all edges incident on v) from G. Iterate up until there is no
vertex with degree at most 2a(G) − 1. (Each new vertex that we adde, was appended to the
end of the sequence.) If this process eliminated all graph vertices, then we have obtained an
ordering (v1 , v2 , ..., vn ), such that for every i ∈ [n − 1], the vertex vi has at most 2a(G) − 1
neighbors with greater index. This proves that degen(G) ≤ 2a(G) − 1.
Hence it remains to consider the case that some vertices are left. In this case there
exists a subset U ⊆ V of vertices such that the minimum degree δ(G(U )) of a vertex in the
graph G(U ) induced by U is at least 2a(G). Note that |U | ≥ 2. But then
     
|E(U )| 2a(G) · |U |/2 a(G) · |U |
≥ = ≥ a + 1.
|U | − 1 |U | − 1 |U | − 1
But  
|E(H)|
a(G) = max ,
H⊆V,|H|≥2 |H| − 1
contradiction. 2
Lemma 2.30 implies that χ(G) ≤ degen(G) + 1 ≤ 2a(G). The linequality mdegen(G) ≤
2a(G) − 1 is tight, because degen(K2a ) = 2a − 1 and a(K2a ) = 2a·(2a−1)/2
2a−1 = a. Also,
χ(K2a ) = 2a. The next lemma provides a lower bound on the degeneracy in terms of the
arboricity.

Lemma 2.31 For every graph G = (V, E), it holds that degen(G) ≥ a(G).

Proof. Let U ⊆ V , |U | ≥ 2, be a subset of vertices. Let σ = (v1 , v2 , ..., vn ) be an ordering

of vertices which satisfies that vi has at most d neighbors with greater index, for every
i ∈ [n − 1]. Let U = (u1 , u2 , ..., uk ) be the set U ordered according to σ. Denote by deg(u, U )
the number of neighbors that a vertex u has within a vertex set U . It follows that
k−1
X
|E(U )| = deg(ui , {ui+1 , ui+2 , ..., uk }) ≤ d · (k − 1).
i=1

|E(U )| d(k−1)
Hence |U |−1 ≤ k−1 = d. Hence
 
|E(U )|
a(G) = max ≤ d = degen(G).
U ⊆V,|U |≥2 |U | − 1
2
√
This inequality is also tight as long as a(G) ≤ c n, for a sufficiently small constant c. To
summarize, a(G) ≤ degen(G) ≤ 2a(G) − 1, i.e., these two parameters are equivalent up to a
factor of 2. An example with a(G) = degen(G) is the graph G = (V, E), V = (v1 , v2 , ., , , vn ),
24 2. BASICS OF GRAPH THEORY

Figure 2.7: An example of a graph G with degen(G) = a(G). Here both parameters are equal
to 3.

in which each vertex vi is connected to vi−1 , vi−2 , ..., vmax{1,i−a} , for every i ∈ [n]. Its de-
generacy is clearly a. Its arboricity is given by
     
1 + 2 + ... + (a − 1) + (n − a) · a (n − 1)a − (a − 1)a/2 (a − 1)a
a(G) = = =a− .
n−1 n−1 2(n − 1)
√
For a < c n, for a sufficiently small constant c, it holds that (a − 1)a < 2(n − 1), and the
right-hand-side is equal to a.
The next simple lemma provides an upper bound for arboricity in terms of the max-
imum degree.
Lemma 2.32 a(G) ≤ ∆(G), for every graph G.
l m l m
Proof. For a set U ⊆ V , |U | ≥ 2, it holds that |E(U )| ∆·|U |
|U |−1 = 2(|U |−1) ≤ ∆. 2

It is equally easy to see that degen(G) ≤ ∆(G). Indeed, there is clearly an ordering
(v1 , v2 , ..., vn ) such that deg(vi , {vi+1 , ..., vn }) ≤ ∆ for all i ∈ [n − 1].

2.4 DEFECTIVE COLORING

In this section we introduce and discuss a relaxed notion of coloring, called defective col-
oring. It was formally defined in mid-eighties by [19, 20, 36], but was implicitly studied
already in the mid-sixties [58]. Quite recently defective coloring was shown to be very use-
ful for computing legal colorings in the distributed setting [8, 9, 10, 48]. We will discuss
this relationship in detail in Chapters 6 - 7, and in Section 8.2.
Definition 2.33 For a coloring ϕ of a graph G = (V, E), the defect of a vertex v ∈ V
under the coloring ϕ, denoted defϕ (v), is the number of neighbors u ∈ Γ(v) that satisfy
ϕ(u) = ϕ(v).
 2.4. DEFECTIVE COLORING 25
Note that for any vertex v and any coloring ϕ, defϕ (v) ≤ deg(v) ≤ ∆. Observe also that for
a legal coloring ϕ, every vertex v has defect zero under ϕ.

Definition 2.34 The defect of a coloring ϕ of a graph G = (V, E) is the maximum defect
of its vertices, i.e., def(ϕ) = maxv∈V defϕ (v).
For a pair of non-negative integer parameters p, q, a coloring ϕ is said to be q-defective
p-coloring if it employs colors only from the palette [p] and its defect is at most q.

We next state and prove a fundamental (though very simple) fact (due to Lovasz [58])
about defective colorings.

Lemma 2.35 For a graph G = (V, E) with maximum degree ∆ and an integer parameter
p ∈ [∆], there exists a ∆
p -defective p-coloring of G.

Proof. We describe an iterative process that, as we argue, ends up producing a desired

coloring. It starts with an arbitrary p-coloring ϕ0 of G. Let B0 denote the set of edges
e = (u, v) which are colored monochromatically (i.e., ϕ(u) = ϕ0 (v)) by ϕ0 . For i = 1, 2, ...,
let ϕi denote the coloring produced by this iterative process after i th iteration, and Bi be
the set of edges colored monochromatically by ϕi .
The iteration i of the process, for i = 1, 2, ..., proceeds as follows. If for every vertex
v ∈ V , defϕi (v) ≤ ∆ p , then the process terminates, and returns the coloring ϕi . Otherwise
we pick an arbitrary vertex v ∈ V with defϕi (v) > ∆ p . Denote α = ϕi (v). There exists a
∆
color β ∈ [p] \ {α} such that at most p neighbors u of v satisfy ϕi (u) = β. We recolor v by
the color β. In other words, the new coloring ϕi+1 agrees with ϕi in every vertex, except
for the vertex v. The new color ϕi+1 (v) is set to β. This completes the description of the
iterative process.
Denote by vi , for i = 1, 2, ..., the vertex which is recolored in the i th iteration of
the process. Let A(vi ) = {(vi , u) ∈ E | ϕi (vi ) = ϕi (u)} (respectively, A′ (vi ) = {(vi , u) ∈
E | ϕi+1 (vi ) = ϕi+1 (u)}) denote the set of edges incident on vi which are colored
monochromatically by ϕi (resp., ϕi+1 ). Observe that Bi+1 = (Bi \ A(vi )) ∪ A′ (vi ). More-
over, A(vi ) ∩ A′ (vi ) = ∅, and thus |Bi+1 | = |Bi | − |A(vi )| + |A′ (vi )|. Recall that |A(vi ) > ∆ p,
and |A′ (vi )| ≤ ∆ p . Hence |B i+1 | < |B i |. Since both |B i+1 | and |B i | are integers, |B i+1 ≤
|
|Bi | − 1. Recall that |B0 | ≤ |E|, and thus the process cannot continue for more than |E|
iterations. Hence after at most |E| iterations the cardinality of the set Bi cannot decrease
further, and the process returns a ∆ p -defective coloring. Note also that all the colorings
ϕ0 , ϕ1 , ϕ2 , ..., employ p colors, and we are done. 2
Next we present a notion of arbefective coloring, which is closely related to defective coloring.
It was introduced in [9] in the context of distributed graph coloring. (See Chapter 7.)

Definition 2.36 Consider a graph G = (V, E) with arboricity a, and a pair of integer non-
negative parameters p and q. A p-coloring ϕ of G is called q-arbdefective if for every index
26 2. BASICS OF GRAPH THEORY

i ∈ [p], the subset Vi = {v ∈ V | ϕ(v) = i} induces a subgraph G(Vi ) of arboricity at most

q.
Lemma 2.37 Let d and p be a pair of positive integers, p ≤ d. For a graph G = (V, E)
with degeneracy d, there exists a p-coloring ϕ that satisfies that for every index i ∈ [p], the
subset Vi = {v ∈ V | ϕ(v) = i} induces a subgraph G(Vi ) with degeneracy at most dp .
Proof. Let V = (v1 , v2 , ..., vn ) be an ordering of the vertex set of G that satisfies that for ev-
ery index j ∈ [n], deg(vj , {v1 , v2 , ..., vj−1 ) ≤ d. Such an ordering exists because G has degen-
eracy at most d. Suppose that we have already computed a p-coloring ϕ of {v1 , v2 , ..., vj−1 }
that satisfies that for every index k ∈ [j − 1], the vertex vk has at most dp neighbors in
{v1 , v2 , ..., vk−1 } with the same ϕ-color. (The induction base, j = 1, holds vacuously.) By
pigeonhole principle there exists a color α ∈ [p] such that vj has at most dp neighbors in
{v1 , v2 , ..., vj−1 } colored by α. We set ϕ(vj ) = α.
For some index i ∈ [p], consider the subsequence U = (u1 , u2 , ..., uh ) of (v1 , v2 , ..., vn )
which contains only the vertices of Vi (i.e., vertices ϕ-colored by the color i). Each vertex
uj , j ∈ [h], in this subsequence has at most dp neighbors with smaller index in U . Thus
G(Vi ) has degeneracy at most dp , for every i ∈ [p]. 2
Consider a graph G = (V, E) with arboricity a, and an integer parameter p, p ∈ [2a − 1]. By
Lemma 2.30, degen(G) ≤ 2a − 1. Hence, by Lemma 2.37, there exists a p-coloring ϕ of G
such that for every index i ∈ [p], degen(G(Vi )) ≤ 2a−1
p . Hence a(G(Vi )) ≤ degen(G(Vi )) ≤
2a−1
p .

Corollary 2.38 For a graph G = (V, E) with arboricity a = a(G), and an integer param-
eter p ∈ [2a − 1], there exists a ( 2a−1
p )-arbdefective p-coloring ϕ of G.

2.5 EDGE-COLORING AND MATCHINGS

In this section we describe some basic results concerning edge-coloring. Edge-coloring is
closely related to vertex-coloring, and it is an interesting primitive on its own right. Given
a graph G = (V, E), an edge-coloring ϕ : E → {1, 2, ...} is a function from the edges set
E of the graph to positive integers. It is called legal if any two adjacent edges e1 and e2
(i.e., e1 ∩ e2 6= ∅) are colored by different colors. Observe that each color class of a legal
edge-coloring is a matching. (An edges set M ⊆ E is called a matching if for every pair of
edges e, e′ ∈ M , e 6= e′ implies e ∩ e′ = ∅. A matching M is called maximal if M ∪ {e} is
not a matching, for every edge e ∈ E \ M .)
A useful notion in this context is the notion of line graphs. For the graph G = (V, E),
the linge graph L(G) = (E, E) is defined as follows. The vertices of the line graph correspond
to edges of the original graph. Two distinct vertices e, e′ ∈ E of L(G) are connected by an
edge in L(G) if the respective edges e, e′ in G incident to one another (i.e., (e, e′ ) ∈ E if
e ∩ e′ 6= ∅). Observe that an MIS in L(G) is a maximal matching (shortly, MM) in G. Also,
 2.5. EDGE-COLORING AND MATCHINGS 27

Figure 2.8: Each of the endpoints of e is incident to up to ∆ − 1 edges other than e.

a legal vertex-coloring of L(G) is a legal edge-coloring of G. The chromatic index χ′ (G) of

a graph G = (V, E) is the minimum possible number of colors in a legal edge-coloring of G.
It is straightforward to verify that χ′ (G) = χ(L(G)).
Consider a graph G = (V, E) with maximum degree ∆. Every edge e ∈ E is incident
on up to 2(∆ − 1) other edges of G. Hence the maximum degree ∆(L(G)) of the line
graph L(G) is ∆(L(G)) ≤ 2(∆ − 1). (See Figure 2.8.) Hence the chromatic number χ(L(G))
of the line graph satisfies χ′ (G) = χ(L(G)) ≤ ∆(L(G)) + 1 ≤ 2∆ − 1. On the other hand,
obviously χ′ (G) ≥ ∆. (Because for a vertex v ∈ V with degree deg(v) = ∆, the ∆ edges
incident on v require ∆ distinct colors.)
Therefore, ∆ ≤ χ′ (G) ≤ 2∆ − 1. However, a stronger bound is known. A seminal theorem
by Vizing [75], states that χ′ (G) ≤ ∆ + 1. The proof can be found e.g., in [13] pages 153-154.
As a corollary of Vizing’s theorem, for every graph G either χ′ (G) = ∆ or χ′ (G) = ∆ + 1.
Distinguishing between these two cases is NP-hard even for cubic (i.e., 3-regular) graphs.
However, interestingly, for many families of graphs it holds that χ′ (G) = ∆. In particular,
this is the case for bipartite graphs (see, e.g., [13] page 152), and for planar graphs with
∆ ≥ 7. (The latter was shown by Vizing [76] for ∆ ≥ 8. He also showed that this is not
the case for ∆ ≤ 5. The case ∆ = 7 was settled by Sanders and Zhao [72]. Finally, the case
∆ = 6 is open. See [17], and the reference therein.)
28

CHAPTER 3

Basic Distributed Graph

Coloring Algorithns
In this section we turn to the distributed model, and describe the classical algorithms for
graph coloring and computing an MIS. We start with the formal definition of the model.

3.1 THE DISTIRUBUTED MESSAGE-PASSING LOCAL

MODEL
In the message-passing LOCAL model of distributed computing a communication network
is modeled by an n-vertex undirected unweighted graph G = (V, E). The network is static,
and so its topology does not change during an execution of an algorithm. The processors in
the network are represented by the vertices of G. For each two vertices u, v ∈ V , there is an
edge (u, v) ∈ E if and only if the two processors corresponding to u and v in the network
are connected by a communication link. Each vertex has a unique identity number. These
numbers are assumed to belong to the range {1, 2, ..., n}. (However, all algorithms described
in this monograph are applicable also for wider ranges of identity numbers. Specifically, it is
sufficient that the identity number can be represented as a bit sequence of length O(log n).)
Initially, each vertex v knows only its identity number Id(v). The vertices commu-
nicate over the edges of E in the synchronous manner. Specifically, a computation (or
equivalently, an algorithm) starts simultaneously in all vertices, and proceeds in discrete
rounds. In each round each vertex v is allowed to send a message (of unbounded size) to
each of its neighbors. A vertex is allowed to send distinct messages to distinct neighbors. All
messages that are sent in a certain round arrive to their destinations before the next round
starts. The number of rounds that elapse from the beginning of the algorithm until its end
is called the running time of the algorithm. Vertices are allowed to perform unbounded
local computations. Computations that are performed locally are not taken into account in
the running time analisys of distributed algorithms in this model.

3.2 BASIC COLOR REDUCTION

In this section we describe a few simple and most fundamental algorithms for coloring
and computing a maximal independent set. Suppose we have a graph G = (V, E) with
maximum degree ∆, which is legally α-colored by a coloring ϕ, for some α ≥ ∆ + 1. The
 3.3. ORIENTATIONS 29
following routine reduces the number of colors to (∆ + 1) within α − (∆ + 1) rounds. In
the beginning of each round each vertex sends its current color to all its neighbors. In the
first round each vertex v of color α recolors itself in parallel into an available color from
the palette [∆ + 1]. Specifically, the set Γ(v) of neighbors of v is colored with at most ∆
colors, i.e., |ϕ(Γ(v))| ≤ ∆. Hence there exists an available color β ∈ [∆ + 1] \ {ϕ(Γ(v))}.
Observe that the set of vertices that are colored by color α form an independent set. Thus,
the resulting coloring ϕ1 is legal as well, and it employs just α − 1 colors. (The coloring
ϕ1 is legal since for each edge (u, v) ∈ E, at most one endpoint has selected a new color.
Suppose without loss of generality that this endpoint is u. Then ϕ1 (u) 6= ϕ(v) = ϕ1 (v).)
Repeating this procedure for colors α − 1, α − 2, ..., ∆ + 2 results in a legal (∆ + 1)-coloring
ψ = ϕα−(∆+1) . This coloring is computed within α − (∆ + 1) rounds.
A similar procedure enables one to use an α-coloring ϕ for computing an MIS within
α rounds. Initialize a set U as an empty set. For i = 1, 2, ..., α, each vertex v with ϕ(v) = i
checks in parallel if it has a neighbor in U . If it does not, it joins U , and sends a message
to its neighbors to inform them about this. By induction on i, it is easy to verify that after
i rounds the set U is an MIS for the graph G({v | 1 ≤ ϕ(v) ≤ i}), for each i ≤ α. Hence
after α rounds, U is an MIS for G. Moreover, it is possible to employ an α-edge-coloring
ψ for computing a maximal matching within α rounds using the same idea. Specifically,
for i = 1, 2, ..., α, in round i all edges e with ψ(e) = i that have no incident edges in the
matching join it. It is easy to verify that after α rounds a maximal matching is constructed.
(The last procedure is, essentially, an MIS computation on the line graph that is initially
α-vertex-colored. See Chapter 2.5 for the definition of line graphs, and more details.)

3.3 ORIENTATIONS
An orientation µ is an assignment of directions to the edges of G, where each edge (u, v) is
directed either towards u or towards v. If an orientation does not contain any consistently
oriented cycles (i.e., simple cycles in which each vertex has out-degree 1 and in-degree 1)
it is said to be an acyclic orientation. Acyclic orientations turn out to be very useful for
graph coloring. In this section we present several helpful properties of acyclic orientations.

Definition 3.1 (1) The out-degree of an acyclic orientation µ of G (or, shortly, µ-out-
degree) is the maximum out-degree of a vertex in G with respect to µ.
(2) The length of an acyclic orientation µ of G is the length of the longest directed (with
respect to µ) path in G. (A directed path is a path P = hv0 , v1 , ..., vℓ i, such that for all
i ∈ {1, 2, ..., ℓ}, the edge (vi−1 , vi ) is oriented towards vi .)
(3) For an edge (u, v) oriented towards v by µ, the vertex v is called the parent of u under
µ. The vertex u is called the child of v under µ.

Property 3.2 [28] A graph G with an acyclic orientation µ of length k can be colored
using k + 1 colors in k + 1 rounds.
30 3. BASIC DISTRIBUTED GRAPH COLORING ALGORITHNS

Proof. In round i, for i = 1, 2, ..., k + 1, we color by color i the vertices whose all parents
have been already colored in previous rounds. Since the orientation is acyclic, in each round
at least one vertex is colored. (In particular, in the first round there must be a vertex with
no outgoing edges, and it is colored by color 1.) Since each edge is oriented, its endpoints are
colored in different rounds. The parent endpoint is colored before the child endpoint. Thus
the endpoints are colored with different colors. Consequently, in the end of this procedure,
if all vertices are colored then we obtain a legal (k + 1)-coloring.
Next, we argue that indeed all vertices obtain a color within k + 1 rounds. Consider
any vertex v ∈ V . Each directed path that emanates from this vertex has length at most
k. By induction on i it is easy to see that if all paths that emanate from a vertex v have
length at most i, then v is colored in round i + 1 or before. Hence all vertices obtain a color
within k + 1 rounds. 2
Property 3.3 [28] A graph G with an acyclic orientation µ of length k and out-degree d
can be colored with d + 1 colors in k + 1 rounds.
Proof. Similarly to the proof of Property 3.2, in round i, for i = 1, 2, ..., k + 1, we color
the vertices whose all parents have been already colored in previous rounds. However, the
color of a vertex v is selected in a different way. Specifically, it is a color from the range
{1, 2, ..., d + 1} which is not used by any of the parents of v. Since v has at most d parents,
such a color can always be found. The resulting coloring is legal, since for any pair of
neighbors u and v, the child endpoint selects a color that is different from its parent’s color.
Similarly to the argument in the proof of Property 3.2, all vertices obtain a color within
k + 1 rounds. 2
Properties 3.2 - 3.3 demonstrate that acyclic orientations are very helpful for comput-
ing colorings. But the opposite direction is also true: colorings can be used for computing
acyclic orientations.
Property 3.4 A graph G with a legal k-coloring ϕ can be assigned an acyclic orientation
µ with length k − 1.
Proof. We orient each edge (u, v) ∈ E towards the endpoint which is colored by a greater
color. (Since the coloring is legal, the color of u is necessarily different from the color of
v.) Now each directed path contains vertices whose colors appear in (strictly) ascending
order. Therefore, the orientation is acyclic. Moreover, each directed path contains at most
k vertices, i.e., its length is at most k − 1. 2
For an orientation µ which was obtained from a coloring ϕ by the rule described
in the proof of Property 3.4, we say that µ is an induced orientation of the coloring ϕ.
Consider a graph G = (V, E) in which some of the edges are oriented. Denote by E ′ ⊆ E
the subset of oriented edges. The edges from E \ E ′ are not oriented. Such an orientation is
called a partial orientation of G. If there are no consistently oriented cycles, the orientation
 3.4. THE ALGORITHM OF COLE AND VISHKIN 31
is called acyclic partial orientation. Such orientations turn out to be very useful as well.
We demonstrate how to use them in Chapters 7 and 8, but for now we provide several
definitions.
Definition 3.5 Suppose that µ is an acyclic orientation of a subset E ′ ⊆ E. Then µ is an
acyclic partial orientation of G = (V, E), and it holds that:
(1) The out-degree of µ is the maximum out-degree of a vertex in G with respect to µ.
(2) The length of µ is the length of the longest directed path in G′ = (V, E ′ ).
(3) The deficit of µ is the maximum number of edges in E \ E ′ (i.e., unoriented edges) that
share a common vertex in V .
(4) For an edge (u, v) oriented towards v by µ, we say that v is a parent of u under µ, or
shortly µ-parent, and that u is a child of v under µ, or shortly, µ-child.

3.4 THE ALGORITHM OF COLE AND VISHKIN

One of the simplest configurations in the distributed setting is an oriented tree. An oriented
tree T = (V, E) is rooted at a vertex r ∈ V , and every vertex v ∈ V , v 6= r, knows the
identity of its parent π(v) in the rooted tree (T, r). On the other hand, in an unoriented tree
there is no distinguished root, and there is no parent-child relationship between neighbors.
Notice that in oriented trees each vertex has information that allows it to orient the edges
adjacent on it towards the parents. (For each edge (u, v) exactly one of the endpoints is
the parent of the other one. Thus each edge can be oriented towards the parent endpoint.)
Consequently, an acyclic orientation of out-degree at most 1 is obtained. Therefore, an
oriented tree can be 2-colored using property 3.3. Unoriented trees can be 2-colored as well,
since trees are bipartite. However, 2-coloring a tree (even an oriented one) in the distributed
model requires Ω(n) time [55]. (See also Section 4.2.) Moreover, if the tree is unoriented,
then even with a larger number of colors one still needs at least Ω(log n) time to color a
tree [55]. (We provide a proof of this in Section 4.2.) However, an oriented tree can be
3-colored within just log∗ n + O(1) time. (See the definition of log∗ n function below.) This
is a fundamental result by Cole and Vishkin [18], and Goldberg, Plotking and Shannon
[31].
For a parameter n, log∗ n stands for the number of times that one needs to apply the
logarithm on the base 2 starting with n before reaching a number smaller or equal than
2, i.e., log∗ n = min{i | log(i) n ≤ 2}. (Here log(0) n = n and log(i+1) n = log2 log(i) n, for
any non-negative integer i.) This is a very slowly growing function. For example, log∗ 216 =
16 16
1 + log∗ 16 = 2 + log∗ 4 = 3. Hence for every n ≤ 22 , log∗ n ≤ 4. The threshold 22 is
much larger than the number of particles in the known universe.
We start with describing a 6-coloring algorithm for oriented trees. It will be later
refined to a 3-coloring one. Initially, each vertex v has an identity number Id(v) from the
set [n], where n is the number of vertices. It initializes its color ϕv to be equal to its identity
number Id(v). Denote by |ϕv | the number of bits used to represent the color ϕv of v, i.e.,
32 3. BASIC DISTRIBUTED GRAPH COLORING ALGORITHNS

|ϕv | = ⌈log2 ϕv ⌉. Also, for each index i, 1 ≤ i ≤ |ϕv |, let ϕv [i] denote the i th leftmost bit
of the bit string ϕv .
The algorithm works iteratively. In each iteration each vertex v 6= r compares the bit
string ϕv which represents its current color with the bit string ϕπ(v) which represents the
color of its parent. It finds an index i such that ϕv [i] 6= ϕπ(v) [i], and sets ϕ′v = hi, ϕv [i]i.
Specifically, ϕ′v is the new color of the vertex v, and it consists of two fields. The first field
contains the binary representation of the bit string i, and the second field contains the
single bit ϕv [i]. The color ϕ′v is the concatenation of these two fields. The root r of the tree
T picks an arbitrary index i and sets ϕ′r = hi, ϕr [i]i. The algorithm is executed for log∗ n
iterations. (For simplicity we assume that all vertices know the value of n. However, this
assumption can be omitted using a slightly more dlicate argument.)
Next we analyze the algorithm.

Lemma 3.6 Given a legal coloring ϕ, the resulting coloring ϕ′ is legal as well.

Proof. Consider an edge (v, u) ∈ E, and suppose without loss of generality that u = π(v).
By the assumption of the lemma, ϕv 6= ϕu . Let i(v) (respectively, i(u)) be the index selected
by v (resp., by u). If i(v) 6= i(u) then the first fields of ϕ′v and ϕ′u are different. Otherwise,
by the choice of i = i(v), it holds that ϕv [i] 6= ϕu [i]. Hence in this case the second fields of
ϕ′v and ϕ′u are different. In either case ϕ′v 6= ϕ′u .
Denote by α and β the first and the second fields of ϕ′v , respectively. Analogously,
let γ and δ be the first and the second fields of ϕ′u , respectively. A-priori it can happen
that α 6= γ, β 6= δ, but the concatenations α ◦ β and γ ◦ δ of the respective bit strings are
equal. However, both β and δ are one-bit strings, and thus (α 6= γ or β 6= δ) implies that
ϕ′v = α ◦ β 6= γ ◦ δ = ϕ′u . 2

Denote by Nj , for every j = 1, 2, ..., the maximum number of bits used by a color ϕv , for
some v ∈ V , after iteration j. For convenience, let N0 = ⌈log n⌉ denote the number of bits
used for the initial coloring of the algorithm. Then Nj+1 ≤ ⌈log Nj ⌉ + 1 ≤ log Nj + 2. Hence
N1 ≤ log N0 + 2, and N2 ≤ log(log N0 + 2) + 2 ≤ log log N0 + 3, assuming that log N0 ≥ 2.
Also, N3 ≤ log N2 + 2 ≤ log(log log N0 + 3) + 2 ≤ log(3) N0 + 3, assuming that log log N0 ≥
3. Generally, for j = 1, 2, ..., such that log(j) N0 ≥ 3, it holds that Nj ≤ log(j) N0 + 3. In
particular, for j = log∗ N0 we get Nj ≤ 5. Since N0 = ⌈log n⌉, it follows that after at most
log∗ n iterations the number |ϕv | of bits used in each color ϕv is at most 5. At this point
two more iterations of the algorithm decreases the maximum number of bits used for the
color to 3, i.e., the palette size reduces to 8. Moreover, one more iteration of the algorithm
reduces the palette size further to 6, because the first field of the color has just 3 possible
values.
Next, the number of colors is further reduced to 3 by a different technique, called the
shift-down. This phase of the algorithm requires 3 additional iterations, with O(1) rounds
each. (Generally, it can be used to reduce the number of colors from α to 3 within α − 3
 3.5. EXTENSIONS TO GRAPHS WITH BOUNDED MAXIMUM DEGREE 33
iterations, for any α. This implies Theorem 3.8.) In each iteration the number of colors
is reduced by 1 within two steps. Denote by ϕ the initial 6-coloring. In the first step of
the first iteration each vertex v 6= r adopts the color ϕ(π(v)) of its parent π(v), i.e., it sets
ϕ′ (v) → ϕ(π(v)). The root changes its color to an arbitrary color from {1, 2, 3}, different
from the color it used to have.

Lemma 3.7 ϕ′ is a legal 6-coloring.

Proof. Consider an edge (v, π(v)) in the tree. First, suppose that π(v) = r is the root of the
tree. Then ϕ′ (v) = ϕ(r), and ϕ′ (r) 6= ϕ(r), as desired. Otherwise, denote u = π(v). Then
ϕ′ (v) = ϕ(u), ϕ′ (u) = ϕ(π(u)), and ϕ(u) 6= ϕ(π(u)), because ϕ is a legal coloring. 2
The new coloring ϕ′ satisfies a helpful property: for each vertex v, all its children are colored
by the same color. Hence the number of forbidden (i.e., not available) colors for u is at most
2. In the second step of the first iteration each vertex v with ϕ′ (v) = 6 finds in parallel an
available color from {1, 2, 3}, and colors itself by this color. As a result we obtain a legal
5-coloring. Two more iterations (each with two steps) reduce the number of colors to 3.
We summarize this section by the following theorem.

Theorem 3.8 [18, 31] An oriented n-vertex tree can be 3-colored within log∗ n + O(1)
time.

Interestingly, for oriented paths and cycles the running time can be further improved to
1 ∗
2 log n + O(1) [74]. This results is tight up to the additive term O(1), in view of Linial
lower bound [55]. Specifically, Linial showed that O(1)-coloring an oriented path requires
1 ∗
2 log n − O(1) rounds. (See Section 4.2.) The tightness of these bounds is remarkable. In
particular, it shows that the log∗ function is not an artifact of the specific algorithm of Cole
and Vishkin [18] or its analysis, but rather it is inherent in the complexity of this problem.

3.5 EXTENSIONS TO GRAPHS WITH BOUNDED MAXIMUM

DEGREE
In this section we describe a few extensions of the Cole-Vishkin algorithm (henceforth, the
CV algorithm) to graphs with maximum degree at most ∆. In the first extension, each
vertex v views each of its d = deg(v) ≤ ∆ neighbors u1 , u2 , ..., ud as its parents (in the
sense of the CV algorithm). Specifically, suppose that we are given a legal coloring ϕ of the
graph. The new coloring ϕ′ is formed in the following way. The new color ϕ′ (v) of v will
consist of d fields, ϕ′ (v) = hϕ′1 (v), ϕ′2 (v), ..., ϕ′d (v)i. For each j ∈ [d], the field ϕ′j (v) is the
new color that the vertex v would get in Cole-Vishkin’s algorithm if uj were the parent of
v. In other words, ϕ′j (v) = hi, ϕ(v)[i]i, i.e., ϕ′j consists of two subfields. The first subfield
is an index i = i(j) of a bit such that ϕ(v)[i] 6= ϕ(uj )[i], and the second subfield is the bit
ϕ(v)[i]. For now the reader can think of different fields and subfields as being concatenated
34 3. BASIC DISTRIBUTED GRAPH COLORING ALGORITHNS

one after another. Later we will specify some special delimiters that separate various fields.
These delimiters will guarantee that if ϕ′ (x) = ϕ′ (y) for some two vertices x and y, then
necessarily ϕ′ (x) and ϕ′ (y) have the same number d of fields, and for every j ∈ [d], it holds
that ϕ′j (x) = ϕ′j (y).
Lemma 3.9 ϕ′ is a legal coloring.
Proof. Consider an edge (v, w) ∈ E, and suppose that w = uj is the j th neighbor of v.
Consider the j th fields ϕ′j (v) and ϕ′j (w) in the two new colors ϕ′ (v) and ϕ′ (w), respectively.
(If ϕ′ (w) has less than j fields, then ϕ′ (v) 6= ϕ′ (w).) Let iv (respectively, iw ) be the index
selected by v (resp., by w) for its j th field. If iv 6= iw then the first subfield of ϕ′ (v) is
different from the first subfield of ϕ′j (w). Otherwise their second subfields are different. In
any case ϕ′j (v) 6= ϕ′j (w), and so ϕ′ (v) 6= ϕ′ (w). 2
Denote by Ni , i = 1, 2, ..., the maximum number of bits used by a color after the i th
recoloring phase of this algorithm. Denote also by N0 the number of bits used for colors
before the algorithm starts. Since initially the identity numbers serve as colors, it follows
that N0 = ⌈log n⌉. By Lemma 3.9, Ni+1 ≤ ∆ · (⌈log Ni ⌉ + 1). It is straightforward to verify
that for i = log∗ n + O(1), Ni ≤ ∆ · (log ∆ + O(log log ∆)). At this point the maximum
color used by a vertex is at most exp{∆ · (log ∆ + O(log log ∆))}, i.e., at most ∆O(∆) .
Corollary 3.10 An extension of the CV algorithm computes a ∆O(∆) -coloring within
log∗ n + O(1) time.
Finally, we address the subtlety that has to do with bit representations. Specifically, since
fields may have different lengths, it may happen that for a pair of vertices v, u, and an index
j, ϕ′j (v) 6= ϕ′j (u), but still ϕ′ (v) = ϕ′1 (v) ◦ ... ◦ ϕ′deg(v) (v) = ϕ′1 (u) ◦ ... ◦ ϕ′deg(u) (u) = ϕ′ (u),
where ◦ stands for concatenation between bit strings. One way to handle this issue is by
encoding each bit in ϕ′ (x), for every vertex x ∈ V , by two bits. Specifically, 0 will be encoded
as 00, and 1 as 01. On the other hand, as a delimiter between different fields we use 10,
and at the end of the bit sequence we write 11. With these delimiters, if ϕ′j (v) 6= ϕ′j (u) for
some index j and pair of vertices v and u then ϕ′ (v) 6= ϕ′ (u), as desired.
The number of bits in the resulting bit strings will grow by a factor of 2, i.e., the
number of colors used will grow quadratically. However, this is swallowed in the (giant)
estimation of ∆O(∆) for the number of colors (see Corollary 3.10). Observe that Corollary
3.10 with the trivial color reduction technique that reduces one color in each round (see
Section 3.2) provides a (∆ + 1)-coloring algorithm which requires ∆O(∆) + log∗ n time.

3.6 AN IMPROVED COLORING ALGORITHM FOR GRAPHS

WITH BOUNDED MAXIMUM DEGREE
In this section we demonstrate that the CV algorithm can be used in a different, more
efficient, way to compute a coloring of a graph G = (V, E) with maximum degree at most
3.6. AN IMPROVED COLORING ALGORITHM FOR GRAPHS WITH BOUNDED MAXIMUM D
∆. The new algorithm starts with computing a decomposition F = (F1 , F2 , ..., F∆ ) into ∆
forests. This decomposition, due to Panconesi and Rizzi [68], is computed within O(1) time,
and it is valuable for a variety of applications, in addition to the one that we will describe
in the current section. In the first step of the forest-decomposition procedure every vertex
v orients all edges (v, u) such that Id(v) < Id(u) towards the endpoint with the greater
Id (that is, the vertex u). In the second step each vertex v labels all outgoing edges (v, u)
incident on v by distinct labels 1, 2, .... The two steps can be executed within one single
round of communication.

Lemma 3.11 For each i ∈ [∆], the set Fi of edges labeled by i is acyclic.

Proof. Suppose for contradiction that Fi contains a cycle C. Let v be the vertex with the
smallest identity in C, and let u, u′ be its two distinct neighbors in C. Then both edges
(v, u), (v, u′ ) are oriented outwards from v. Hence v oriented two distinct outgoing edges
e = (v, u) and e′ = (v, u′ ) incident on it by the same label i, contradiction. 2

The number of labels that are used by the algorithm is obviously at most ∆. Observe
also that each of the trees in the forest-decomposition F = (F1 , F2 , ..., F∆ ) is oriented.
Specifically, for each edge (v, u) ∈ Fi , for some i ∈ [∆], oriented from v to u, the vertex u is
designated as the parent π(u) of v. A vertex r that has no outgoing edges in Fi is a root of
one of the trees of the forest Fi . Since each vertex v in Fi has at most one outgoing edge,
it follows that each tree (connected component) T in Fi has exactly one root r, and all
oriented paths in T lead to r.
To summarize:

Theorem 3.12 [68] For a graph G = (V, E) with maximum degree ∆, a forest-
decomposition F with at most ∆ oriented forests can be computed within one communication
round.

Remark: An oriented forest is a collection of vertex-disjoint oriented trees.

Given this forest-decomposition, the algorithm proceeds as follows. In each forest
Fi ∈ F in parallel we run the CV algorithm. This algorithm produces a 3-coloring ϕi of
the forest Fi within log∗ n + O(1) rounds. Finally, each vertex v forms its color ϕ(v) =
hϕ1 (v), ϕ2 (v), ..., ϕ∆ (v)i. That is, ϕ(v) consists of ∆ fields each of which is from {1, 2, 3}.
For an index i ∈ [∆] with no incident edges in the forest Fi , the vertex v can be seen as a
single-vertex tree in Fi . Thus ϕi (v) can be set to an arbitrary color from {1, 2, 3}.

Lemma 3.13 ϕ is a legal 3∆ -coloring of G.

Proof. Consider an edge (v, u) ∈ E. Since F is a forest-decomposition of G, there exists

an index i ∈ [∆] such that (v, u) ∈ E(Fi ). Hence ϕi (v) 6= ϕi (u), i.e., ϕ(v) 6= ϕ(u). Finally,
ϕ consists of ∆ fields, with 3 options for each field. Hence ϕ employs 3∆ colors. 2
36 3. BASIC DISTRIBUTED GRAPH COLORING ALGORITHNS

Corollary 3.14 3∆ -coloring of an n-vertex graph with maximum degree ∆ can be computed
within log∗ n + O(1) time.

By the basic color reduction technique, this corollary also implies that a (∆ + 1)-coloring
can be computed within 3∆ + log∗ n + O(1) time. This improves upon the result derived in
Section 3.5.

3.7 A FASTER (∆ + 1)-COLORING

In sections 3.5 and 3.6 we analyzed algorithms that produce ∆O(∆) - and 3∆ - colorings,
respectively, in log∗ n + O(1) time. As a corollary we concluded that (∆ + 1)-coloring can
be computed within 3∆ + log∗ n + O(1) time. In this section we present a much faster
(∆ + 1)-coloring algorithm due to Goldberg, Plotkin and Shannon [31].
The algorithm starts with computing a forest F = (F1 , F2 , ..., F∆ ) of the input graph
G = (V, E). Each Fi is an oriented forest, and so Cole-Vishkin’s algorithm is applicable to
it. It is applied in parallel in each forest, to obtain a 3-coloring ϕi for each forest Fi . Next,
the colorings ϕ1 , ϕ2 , ..., ϕ∆ are merged into a unified coloring ϕ̂ for G in ∆ iterations. In the
first iteration, ϕ̂(v) = ϕ̂1 (v) is set as ϕ1 (v), for every v ∈ V . (We assume here that every
vertex v belongs to each forest Fi . If there are no edges of a forest Fi adjacent on v, then v is
considered to be a single-vertex tree in Fi .) Consider the i th iteration, for some i ∈ [2, ∆].
Every vertex v forms a color ψ(v) = hϕ̂i−1 (v), ϕi (v)i, where ϕ̂i−1 (v) is the coloring ϕ̂ which
was formed in the previous iteration. Inductively we will guarantee that ϕ̂i−1 (v) ∈ [∆ + 1],
Si−1
for every v ∈ V , and that ϕ̂i−1 is a legal coloring of j=1 Fj . Also, ϕi (v) ∈ {1, 2, 3}. Hence
ψ is a legal 3(∆ + 1)-coloring of ∪ij=1 Fj . The maximum degree of ∪ij=1 Fi is at most ∆.
Thus, in 2(∆ + 1) rounds the coloring ψ can be converted into a legal (∆ + 1)-coloring ϕ̂i
for ∪ij=1 Fj via the basic color reduction technique (see Section 3.2). This completes the
description of the i th iteration, and thus, of the entire algorithm.
The running time of this algorithm consists of three parts. In the first part of the
algorithm the forest-decomposition is computed within O(1) time. The second part, i.e., the
application of the CV algorithm in each forest, requires log∗ n + O(1) time. Finally, each
of the ∆ − 1 iterations of the recoloring step requires 2(∆ + 1) rounds. Hence the overall
running time is O(∆2 ) + log∗ n.
To summarize:

Corollary 3.15 [31] (∆ + 1)-coloring of an n-vertex graph G = (V, E) can be computed

within O(∆2 ) + log∗ n time.

This result does not improve the bound of Corollary 3.14 that says that 3∆ -coloring
can be computed within log∗ n + O(1) time. Improving this bound will be the subject of
Chapter 3.10.
3.8. KUHN-WATTENHOFER COLOR REDUCTION TECHNIQUE AND ITS APPLICATIONS 3

3.8 KUHN-WATTENHOFER COLOR REDUCTION

TECHNIQUE AND ITS APPLICATIONS
In Section 3.2 we presented the basic color reduction technique. This technique converts
an α-coloring ϕ of a graph G = (V, E) with maximum degree ∆ into a (∆ + 1)-coloring,
within α − (∆ + 1) rounds. In this section we describe a far more efficient
 technique  due to

α
Kuhn and Wattenhofer [53] for this task. This technique requires O (log ∆+1 ) + 1 · ∆
time. Suppose that α ≥ 2(∆ + 1). Otherwise a (∆ + 1)-coloring can be computed within
(∆ + 1) rounds via the standard color reduction technique.
Kuhn-Wattenhofer (henceforth,
l m KW) reduction technique starts with partitioning the
α
vertex set V of G into k = ∆+1 sets V1 , V2 , ..., Vk in the following way. For each i ∈ [k],
Vi will contain the vertices v with (i − 1)(∆ + 1) + 1 ≤ ϕ(v) ≤ i · (∆ + 1). Consider the
coloring ϕ restricted to the vertex set V1 ∪ V2 . It is a (2(∆ + 1))-coloring of G(V1 ∪ V2 ). By
the standard color reduction technique, it can be converted into a (∆ + 1)-coloring ψ12 for
G(V1 ∪ V2 ) within (∆ + 1) rounds. The same applies to the set V3 ∪ V4 , and the set V5 ∪ V6 ,
etc. (In case that k is odd, we group the last three sets Vk−2 , Vk−1 and Vk , rather than
leaving the set Vk ungrouped.) In all these sets the standard reduction technique is applied in
parallel. As a result we obtain a (∆ + 1)-coloring ψ12 for V1 ∪ V2 , a (∆ + 1)-coloring ψ34 for
V3 ∪ V4 , etc. Overall, the number of colors used by all the colorings ψ12 , ψ34 , ψ56 , ... is at most
α/2. (Because in each vertex set Vi ∪ Vi+1 , i = 1, 3, 5, ..., the palette size decreased from at
least 2(∆ + 1) to (∆ + 1). In the last vertex set, if k is odd, it decreased by an even greater
factor than 2.) Note also that the new coloring of G can use the palette [1, α/2]. Specifically,
V1 ∪ V2 uses the palette [1, ∆ + 1], and V3 ∪ V4 uses the palette [∆ + 2, 2(∆ + 1)], etc. The
running time of this halving step is O(∆).

Theorem 3.16 Given a graph G = (V, E) and an α-coloring ϕ of G, with α ≥ 2(∆ + 1),
an (α/2)-coloring ψ of G can be computed within at most 2(∆ + 1) rounds.

This halving step is applied repeatedly, up until the resulting number of colors is smaller
than 2(∆ + 1). At that point the coloring can be converted into a (∆ + 1)-coloring within
additional at mostl∆ +l 1 rounds.
mm The number of times that the halving step is invoked is
α α
at most ⌈log k⌉ = log ∆+1 . Hence the overall running time is O(∆ · log ∆+1 ).

Corollary 3.17 [53] An α-coloring can be converted into a (∆ + 1)-coloring within O(∆ ·
α
log ∆+1 ) deterministic time.

One simple application of this result is the following one. As was mentioned above, the
identities of vertices can be used as an initial n-coloring of the input graph. Apply Corollary
3.17 to this initial coloring. We obtain a (∆ + 1)-coloring in O(∆ log n) time. This result
is due to Goldberg, Plotkin and Shannon [31]. Also we saw (Corollary 3.14) that 3∆ -
coloring can be computed within log∗ n + O(1) time. By using this coloring as an input
38 3. BASIC DISTRIBUTED GRAPH COLORING ALGORITHNS

to Corollary 3.17 we obtain a (∆ + 1)-coloring within O(∆2 ) additional time. The overall
time for (∆ + 1)-coloring in this algorithm is O(∆2 ) + log∗ n, that matches the one that
was achieved in Section 3.7 by a different technique. Moreover, in Chapter 3.10 we will
see an algorithm for O(∆2 )-coloring that requires only log∗ n + O(1) time, due to Linial
[55]. The KW color reduction technique in conjunction with Linial’s algorithm produces a
(∆ + 1)-coloring within O(∆ log ∆) + log∗ n time.
In the sequel we will refer to the algorithm that computes a (∆ + 1)-coloring from
scratch in O(∆ log ∆) + log∗ n time as the Kuhn and Wattenhofer algorithm, or shortly,
the KW algorithm. On the other hand, the variant that starts from a legal α-coloring and
α
produces a (∆ + 1)-coloring within O(∆ · log ∆+1 ) time (Corollary 3.17) will be referred as
the KW iterative procedure.
We finish this section by presenting a slightly different view of the KW iterative
procedure. Consider again the CV algorithm. It starts with an α1 -coloring, for some number
α1 . After one iteration (that lasts for one round) it produces an α2 -coloring, for some
α2 ≤ α1 . After one more iteration it produces an α3 -coloring, α3 ≤ α2 ≤ α1 , etc.
Szegedy and Vishwanathan [74] identified the family of algorithms that on each round
gradually improve the coloring at hand, where each vertex selects a new color based only
on its current color, and the current colors of its neighbors. Such algorithms are called
locally-iterative coloring algorithms. Not only the CV algorithm is of this kind, but also the
aforementioned Linial’s O(∆2 )-coloring algorithm for general graphs. Szegedy and Vish-
wanathan showed that any (∆ + 1)-coloring locally-iterative algorithm requires Ω(∆ log ∆)
time.
Interestingly, Linial’s algorithm can be combined with the KW iterative procedure
to produce a locally-iterative (∆ + 1)-coloring algorithm that requires O(∆ log ∆) + log∗ n
time. This result is tight in view of the lower bound of [74]. On the other hand, in Chapter
6 we will show (the results are due to [8, 48]) that by algorithm of a different type one can
break the Szegedy-Vishwanathan’s barrier of Ω(∆ log ∆), and obtain a (∆ + 1)-coloring in
O(∆) + log∗ n time. (In fact, even O(∆) + 21 log∗ n time. The term 12 log∗ n is tight in view
of Linial’s lower bound from [55]. See Chapter 4.)
Next, we show how the KW iterative procedure can be stated as a locally-iterative
algorithm. (The fact that Linial’s algorithm is locally-iterative will be apparent when we
describe it in Chapter 3.10.) Consider the α-coloring ϕ, which is the input for the KW
iterative procedure. Suppose that the colors are in the range [0, α − 1]. Group all verices of
colors [0, ∆ + 1] into the set V1 , all vertices
l mof colors [∆ + 1, 2∆ + 3] into the set V2 , etc.
α
Within each vertex set Vj , j = 1, 2, ..., ∆+2 , for each index i ∈ [0, ∆ + 1], let Uji = {v ∈
Vj | ϕ(v) ≡ i (mod ∆ + 2)}.
In each vertex set Vj in parallel all vertices of the set Uj∆+1 recolor themselves into
an available color for them from the palette [(j − 1)(∆ + 2), j(∆ + 2) − 2]. Such available
colors necessarily exist, because the palette is of size (∆ + 1), while the maximum degree
 3.9. A REDUCTION FROM (∆ + 1)-COLORING TO MIS 39

Figure 3.1: A Cartesian product of an edge (v, u) with K3 .

in each G(Vj ) is at most ∆(G) = ∆. Hence, roughly speaking, in each round the employed
number of colors decays by a factor ∆+1
∆+2 . (We suppress here some technical details regard-
ing the way to “eliminate spaces” from the resulting coloring ψ. The latter is required to
∆+1
guarantee that ψ is a ∆+2 · α-coloring. Other suppressed technicalities have to do with the
fact that, in general, α needs not to be divisible by ∆ + 2.) Applying this recoloring iter-
atively to the O(∆2 )-coloring produced by Linial’s algorithm results in a (∆ + 1)-coloring
within O(∆ log ∆) additional rounds (i.e., total of O(∆ log ∆) + log∗ n rounds).

3.9 A REDUCTION FROM (∆ + 1)-COLORING TO MIS

In Section 3.2 we showed that given an α-coloring of a graph G = (V, E) one can compute
an MIS of G within α rounds. In this section we show a reduction in the opposite direction:
given an algorithm for computing an MIS we show how it can be translated into an algorithm
with the same running time for employing a (∆ + 1)-coloring. This reduction is due to Luby
[60] (see also [55].)
Denote by K∆+1 the clique with ∆ + 1 vertices, and by G′ = G × K∆+1 the Cartesian
product of G by K∆+1 . The vertex set V ′ of G′ is V ′ = V × [∆ + 1], i.e., every vertex
v ∈ V translates into (∆ + 1) vertices (v, 1), (v, 2), ..., (v, ∆ + 1). All vertices (v, i), (v, j) are
interconnected, and so essentially each vertex v ∈ V is replaced by a clique that connects its
(∆ + 1) copies. For distinct vertices v, u ∈ V , connect (v, i) and (v, j) in G′ (i, j ∈ [∆ + 1])
iff ((v, u) ∈ E and (i = j)). This completes the description of the graph G′ = G × K∆+1 .
See Figure 3.1 for an illustration.
40 3. BASIC DISTRIBUTED GRAPH COLORING ALGORITHNS

Consider an MIS U ′ ⊆ V ′ in G′ .

Lemma 3.18 U ′ contains exactly one vertex from each clique {(v, 1), (v, 2), ..., (v, ∆ + 1)}.

Proof. Since vertices of {(v, 1), (v, 2), ..., (v, ∆ + 1)} form a clique, U ′ cannot contain two of
them. Suppose for contradiction that U ′ ∩ {(v, 1), (v, 2), ..., (v, ∆ + 1)} = ∅ for some vertex
v ∈ V . Then for each index i ∈ [∆ + 1] there exists a vertex ui ∈ U such that ((v, i), (ui , i)) ∈
E ′ and (ui , i) ∈ U ′ . Moreover, for distinct indices i, j ∈ [∆ + 1], it holds that (ui , i), (uj , j) ∈
U ′ , and so ui 6= uj . (Because otherwise there would be two representatives (ui , i), (ui , j)
in U ′ from the clique of ui .) Hence (v, ui ) ∈ E, for every i ∈ [∆ + 1], and the vertices
u1 , u2 , ..., u∆+1 are distinct. This contradicts the assumption the the graph G has maximum
degree ∆. 2

Given an MIS U ′ for G′ one can determine the (∆ + 1)-coloring ϕ for G in the following
way: for a vertex v ∈ V , let i ∈ [∆ + 1] be the unique index such that (v, i) ∈ U ′ . (The
index exists and it is unique by Lemma 3.18). Set ϕ(v) = i.

Lemma 3.19 The (∆ + 1)-coloring ϕ is a legal coloring of G.

Proof. Consider an edge (v, u) ∈ E. The vertices (v, ϕ(v)), (u, ϕ(u)) both belong to the
MIS U ′ , and so these vertices are not connected in E ′ . Since (v, ϕ(v)) and (u, ϕ(v)) are
connected in E ′ , it holds that (u, ϕ(u)) 6= (u, ϕ(v)). Thus ϕ(u) 6= ϕ(v). 2

Now we are ready ready to describe the reduction from (∆ + 1)-coloring to MIS. Given
a graph G = (V, E), every vertex v ∈ V simulates the ∆ + 1 vertices of the clique
(v, 1), (v, 2), ..., (v, ∆ + 1) of G′ . The network runs an algorithm A for MIS, which is pro-
vided to the reduction as input. Whenever a vertex (v, i) wishes to send a message to a
vertex (u, i), in the simulation the vertex v sends the appropriately labeled message to u.
Whenever (u, i) wishes to send a message to (u, j), this is performed locally within the
vertex v. Once the algorithm A completes the computation of the MIS U ′ , every vertex
v locally checks what is the index i such that (v, i) ∈ U ′ , and sets ϕ(v) = i. By Lemmas
3.18 and 3.19, the resulting coloring is a legal (∆ + 1)-coloring. The running time of this
computation is the running time of the algorithm A.

Corollary 3.20 [60] Given an algorithm A that computes an MIS for general n-vertex
graphs with maximum degree ∆ within time T (n, ∆), the reduction which was described
above provides a (∆ + 1)-coloring algorithm with running time T ((∆ + 1) · n, 2∆).

We remark that the simulation which was described above increases the message size by
a factor of (∆ + 1). Also, note that this reduction is not applicable to graphs of bounded
arboricity. Specifically, even if the arboricity of G is a < ∆, the arboricity of G′ is Θ(∆).
To the best of our knowledge it is open whether a similar reduction that does not blow up
the message size exists.
 3.10. LINIAL’S ALGORITHM 41

3.10 LINIAL’S ALGORITHM

In Section 3.6 we saw that a 3∆ -coloring can be computed within log∗ n + O(1) time. Also,
in Section 3.7 we saw that (∆ + 1)-coloring can be computed within O(∆2 ) + log∗ n time.
This section is devoted to a stronger result (due to Linial [55]), which states that an O(∆2 )-
coloring can be computed within log∗ n + O(1) rounds. The proof relies on the following
purely combinatorial lemma due to Erdős et al. [27]. See also [55].

Lemma 3.21 For two integers n and ∆,  n > ∆ ≥ 4, there exists a family J of n subsets
of the set {1, 2, ..., m}, m = 5 · ∆2 · ln n , such that if F0 , F1 , ..., F∆ ∈ J then

∆
[
F0 * Fi .
i=1

Remark: A set system J that satisfies the assertion of the lemma is called ∆-cover-free.

Proof. We build a random collection J of subsets of [m] in the following way. For every
element x ∈ [m], and for every index i ∈ [n], we insert x into the set Si with probability
1/∆, independently of other pairs (x′ , i′ ) 6= (x, i). For a fixed element x, x ∈ [m], and fixed
distinct indices i0 , i1 , ..., i∆ ∈ [n], it holds that
 
[∆  ∆
  1 1 1
IIP x ∈ Si0 \ S ij = · 1− ≥ .
j=1
∆ ∆ 4∆

Hence  
∆
[ 1
IIP x ∈
/ (Si0 \ S ij )  ≤ 1 − .
j=1
4∆

/ Si0 \ ∪ ∆
The probability that for every x, x ∈ [m], x ∈ j=1 Sij is
 
∆
[  m
1
IIP ∀x, x ∈
/ S i0 \ S ij  ≤ 1− ≤ e−(5/4)∆ ln n = n−(5/4)∆ .
j=1
4∆

Hence  
∆
[
IIP Si0 ⊆ Sij  ≤ n−(5/4)∆ .
j=1

The probability that there will be (∆ + 1) indices i0 , i1 , ..., i∆ , such that Si0 ⊆ ∪∆
j=1 Sij is,
by union-bound, at most the number of ways to choose these indices multiplied by n−(5/4)∆ .
42 3. BASIC DISTRIBUTED GRAPH COLORING ALGORITHNS
n


There are ∆+1 ways to choose the (∆ + 1) distinct indices, and (∆ + 1) ways to choose
i0 from the selected (∆ + 1)-tuple of indices. Hence
 
[∆  
  n
IIP ∃ i0 , i1 , ..., i∆ such that Si0 ⊆ S ij ≤ (∆ + 1) · n−(5/4)∆
j=1
∆ + 1
 ∆
e
≤ · e · n−(1/4)∆+1 .
∆+1
The right-hand-side is strictly smaller than 1, for ∆ ≥ 4. We remark that to fix the cases
of ∆ ∈ {1, 2, 3} one
 shouldincrease the leading constant in the definition of m from 5 to 8,
i.e., set m = 8 · ∆2 · log n . Hence
 
[∆  ∆
e
IIP ∀ distinct i0 , i1 , ..., is , Si0 * S ij  ≥ 1 − · e · n−(∆/4)+1 > 0.
j=1
∆ + 1

Therefore, there exists a selection of sets S1 , S2 , ..., Sn , for which no one of them is covered
by a union of ∆ others. 2
Next we use this lemma for coloring. Each vertex v ∈ V is assigned its own subset
FId(v) from a collection J of subsets of [m], m = 5 ∆2 · ln n , whose existence is guaranteed
by Lemma 3.21. Then each vertex v sends its set FId(v) to all its neighbors. (In fact, it
is enough just to send the index Id(v), and the neighbors will compute FId(v) locally.)
Given its own set FId(v) , and the sets Fid(u1 ) , Fid(u2 ) , ..., FId(uh ) of all the h ≤ ∆ neighbors
u1 , u2 , ..., uh of v, the vertex v finds an element
h
!
[
c ∈ FId(u) \ FId(ui ) .
i=1

Such an element exists because FId(u) * ∪hi=1 FId(ui ) . The vertex v sets c to be its new color.
Next, we analyze this algorithm. Observe that it requires just one single round. Also,
the coloring ϕ that it produces is an m-coloring with m = O(∆2 · log n).
Lemma 3.22 ϕ is a legal coloring.
Proof. Consider an edge (v, u) ∈ E. Then ϕ(v) ∈ FId(v) \ FId(u) and ϕ(u) ∈ FId(u) . Hence
ϕ(v) 6= ϕ(u). 2
Observe also that any legal coloring ψ could have been used instead of the Id numbers as
an input coloring for this procedure. Generally, if the original number of colors n′ , then the
resulting number of colors is m = O(∆2 · log n′ ).
Theorem 3.23 [55] The algorithm discussed above, given an n′ -coloring of a graph G =
(V, E) with degree ∆, produces a 5 ∆2 · ln n′ -coloring of G within one single round.
 3.10. LINIAL’S ALGORITHM 43
This theorem was significantly improved by Szegedy and Vishwanathan [74] who showed
that an n′ -coloring can be converted into O(∆2 · log log n′ )-coloring within one single round.
Note, however, that this algorithm can be invoked iteratively. It is easy to verify that
within log∗ n rounds the resulting coloring employs O(∆2 · log ∆)-coloring. Using another
set system of Erdős et al. [27] (see below), one can further decrease the number of colors
to O(∆2 ) within one additional round.

Corollary 3.24 [55] An O(∆2 )-coloring of an n-vertex graph with maximum degree ∆ can
be computed within log∗ n + O(1) rounds.

We remark that the algorithm for computing set-systems which was described above is
randomized. However, it can be easily derandomized (see [27, 55]) using an algebraic con-
struction based on polynomials. (This construction is presented below.) The resulting al-
gorithm has similar properties to the ones that were stated above. Using the algorithm of
Szegedy and Vishwanathan [74], the running time in Corollary 3.24 can be improved to
1 ∗
2 log n + O(1). In view of the lower bounds of Linial [55] that we described in Section 4.2,
this result is tight up to constant in the additive term.
Next, we describe how to compute O(∆2 )-coloring in log∗ n + O(1) time using alge-
braic constructions. This algorithm is also based on [55, 27]. In [27] the authors devised
constructions of ∆-cover-free set systems F = {S (1) , S (2) , ..., S (n) }, over a ground-set [m]
(i.e., S (i) ⊆ [m] for each i ∈ [n]). Specifically, Erdős et al. [27] showed that for any n and ∆,
n > ∆, one can build a ∆-cover-free family with m = O(∆2 · log n). The proof of this result
by the probabilistic method was explained above. Next we describe an algebraic proof of a
slightly weaker bound, specifically, m = O(∆2 · log2 n).
Let X, |X| = m, be a ground-set, where m = q 2 for a prime q. It is convenient to view
X as X = GF (q) × GF (q), where GF (q) stands for a field of characteristic q. For a positive
parameter d, let Poly(d, q) denote the set of polynomials of degree d over GF (q). For each
polynomial g() ∈ Poly(d, q), let Sg = {(a, g(a)) | a ∈ GF (q)} be the set of all points on the
graph of the polynomial g(). Let Fd,q = {Sg | g() ∈ Poly(d, q)}. Observe that |Sg | = q, for
every g() ∈ Poly(d, q). Note that two such distinct sets may intersect in at most d elements.
Hence to cover a fixed set Sg , one needs at least q/d other sets Sh from the family F = Fd,q .
Let ∆ = ⌈q/d⌉ − 1 < q/d. It follows that F is a ∆-cover-free family. Its cardinality
is |F| = q d+1 = n. By expressing q and d in terms of n, m and ∆, we obtain m · log2 m ≤
log2 n
4(∆ + 1)2 log2 n. Hence m ≤ 4(∆ + 1)2 log2 n. (In fact, m ≤ 5(∆ + 1)2 · log2 (4(∆+1) 2 log2 n) ,

but we will not use this estimate.)

Another valuable setting of parameters is d = 2. Then we get n = q 3 , m = q 2 , ∆ ≥
√ √
m/2 − 1. Since q = m, it follows that m ≤ 4(∆ + 1)2 . In other words, for n ≤ 8(∆ + 1)3
one can have a groundset of size m ≤ 4(∆ + 1)2 . To summarize:
44 3. BASIC DISTRIBUTED GRAPH COLORING ALGORITHNS

Theorem 3.25 [27] For any positive integers n, ∆, n > ∆, one can construct a ∆-cover-
free family F with n sets over the groundset [m], for some m ≤ 4(∆ + 1)2 log2 n. Moreover,
if n ≤ 8(∆ + 1)3 then m ≤ 4(∆ + 1)2 .

Note that for any ∆ > 0, and for any n > ∆, (and not only a prime power), we can choose
a prime q, ⌊(∆ + 1) log n⌋ ≤ q ≤ 2 ⌊(∆ + 1) log n⌋, and set d = ⌊log n⌋. (Such a prime q
exists according to the Bertrand-Chebyshev postulate. See, e.g., Theorem 418 in [37].)
Then the family Fd,q is ∆-cover-free. Moreover |Fd,q | = q d+1 > n. Thus we can select a
subset of Fd,q of size n which is a ∆-cover-free family over a groundset [m] of size m = q 2 ≤
4(∆ + 1)2 log2 n.
As was argued above, by applying the recoloring procedure which is based on these
set-systems for log∗ n + O(1) times, the initial n-coloring in which each vertex v is assigned
Id(v) as its color is converted into an O(∆2 log2 ∆)-coloring ψ for G. For a sufficiently large
∆, it holds that O(∆2 log2 ∆) ≤ 8(∆ + 1)3 . (If ∆ = O(1) then O(∆2 log2 ∆) = O(∆2 ).)
Hence we next use the second set system from Theorem 3.25 to convert this coloring into
a 4(∆ + 1)2 -coloring of G. The overall running time is log∗ n + O(1).
 45

CHAPTER 4

Lower Bounds
This section is devoted to two lower bounds, both due to Linial [55]. The first one (Section
√
4.1) shows that coloring the balanced d-regular tree unoriented tree Td with less than 12 d
colors requires Ω( log n
log d ) time. The second one (Section 4.2) shows that O(1)-coloring an
oriented path requires at least 21 log∗ n − O(1) time.

4.1 COLORING UNORIENTED TREES

We start with providing some intuition for the first result. There are known constructions
√
[59] of d-regular graphs Gd with girth(G) > log n 1
log d and chromatic number at least 2 d. These
constructions are based on Ramanujan graphs [59]. In√fact, it is conjectured that the lower
bound on the number of colors can be raised from 12 d to Ω( logd d ) [59]. If this conjecture
is true then it will follow that coloring a d-regular tree with c · logd d colors, for some fixed
constant c > 0, requires Ω( log n
log d ) time.
Observe that from the perspective of many vertices v, within less that log n
log d rounds it
cannot distinguish between being in Gd or Td . (In fact, this is true
√ if v is far away from tree
leaves.) Hence if Td can be legally α-colored, for some α < c · d colors for a sufficiently
small constant c > 0, within c · log n
log d rounds, then Gd can be α-colored as well. (In this case
the distributed algorithm for α-coloring Td could be executed on Gd , which would produce
a legal α-coloring of Gd .) But α < χ(Gd ), i.e., Gd cannot
√ be α-colored, no matter how
many rounds are used. Thus coloring Td with α < c · d colors requires more than c · log n
log d
rounds.
We will provide two proofs for this result. The first proof is simpler, and applies to
both randomized and deterministic algorithms. The second one is more involved and applies
only to deterministic algorithms. However, the second proof illustrates an important proof
technique. This technique will also be used in Section 4.2.

4.1.1 THE FIRST PROOF

Consider first the problem of distributed coloring n-vertex graphs Td and Gd , where the
assignment of identifiers (henceforth, Id-assignment) is the following one. Every vertex v
selects its Id uniformly at random from [n3 ]. For short, we will refer to these problems as
coloring random Td and coloring random Gd . Suppose for contradiction that there exists a
distributed algorithm A that requires c · log n
log d rounds or less, and colors random Td legally
46 4. LOWER BOUNDS
√
with c · d colors, with a positive probability. (The algorithm A may be either deterministic
or randomized. In the former case the probability is taken over the choice of Ids, and in
the latter case it is also taken over the coin tosses of the algorithm.)
Consider an execution E of A on the random Gd . Let U ⊆ V (Td ) be a subset of
vertices of Td which are at distance greater than c · log n
log d + 1 from their respective closest
leaves. Observe that U is not empty, for a sufficiently small c > 0. Let view(v, Gd , A) be the
information accumulated by a vertex v ∈ V (Gd ) in an execution of A of random Gd after
c · log n ′
log d rounds. Similarly, let view(v , Td , A) be the information accumulated by a vertex
′
v ∈ U ⊆ V (Td ) in an execution of A on random Td after the same number of rounds.
Both these views are random variables, distributed precisely in the same way. Hence the
′
distributions of the colors computed by v ∈ V (Gd ) and √ by v ∈ U ⊆ V (Td ) are the same
as well. For the tree Td the algorithm A employs c · d colors, and so Gd will also be
colored with the same number of colors. Moreover, with a positive probability, the coloring
ϕ′ produced by the algorithm is legal for Td . In particular, with a positive probability, for
every vertex v ′ ∈ U and every neighbor w′ of v ′ in Td , ϕ′ (v ′ ) 6= ϕ′ (w′ ). Hence, with the
same probability, for every vertex v ∈ V (Gd ), the coloring ϕ produced by the algorithm
for random Gd satisfies for every neighbor w of √ v in Gd , ϕ(v) 6= ϕ(w). Hence, with √a
positive probability, the coloring ϕ is a legal (c · d)-coloring for Gd , but χ(Gd ) > c · d,
contradiction.

Corollary 4.1 There √ exists a constant c > 0, such that there is no algorithm for random
Td that employs c · d colors, runs for c · log n
log d rounds or less and produces a legal coloring
with a positive probability.
√
Suppose now for contradiction that there exists some (c · d)-coloring algorithm B for Td
that runs in c · log n
log d rounds and for any assignment of distinct Ids from the range [n ] to
3

vertices of Td with probability at least 1/2 this algorithm produces a legal coloring. Invoke B
on random Td . If the Id-assignment that was selected randomly assigns all vertices distinct
Ids, then with probability at least 1/2 the algorithm B will produce a legal coloring. The
random assignment satisfies this property with probability at least 1 − o(1), and so the
algorithm B produces a legal coloring for random Td with a positive probability at least
(1/2 − o(1)). But this is a contradiction to Corollary 4.1.

Theorem
√ 4.2 There exists a constant c > 0 such that there is no algorithm that employs
c · d colors, runs for c · log n
log d rounds, and for any assignment of distinct Ids from the range
[n3 ] to vertices of Td provides a legal coloring with a constant probability.

It is also easy to see that the range [n3 ] in Theorem 4.2 can be decreased to [n] at the
expense of decreasing the lower bound c · log n
log d by a factor of 3. (Instead of considering only
n-vertex trees Td one will have to allow balanced d-regular trees with n1/3 vertices, and
other n − n1/3 vertices forming an isolated component.)
 4.1. COLORING UNORIENTED TREES 47
Theorem 4.2 implies that for any α ≥ 3, any algorithm that α-colors unoriented trees
log n 2
requires Ω( log α ) rounds. (Just consider a d-regular tree with d = C · α , for a sufficiently
large constant C, and use Theorem 4.2.) Remarkably, this lower bound is tight. In Chap-
ter 5 we will describe an algorithm that is based on forest-decomposition, which α-colors
log n
unoriented trees within O( log α ) time!
There is also another important lower bound known. Specifically, Kuhn et al. [50, 52]
√
showed that MM and MIS require Ω(min{log ∆, log n}) time. Moreover, for the MM
√
problem this lower bound is shown for graphs G with girth(G) = Ω( log n). (This is not
the case for the MIS problem.) The indistinguishability argument which we described above
implies that this lower bound for MM holds even for unoriented trees.
Theorem 4.3 [50, 52, 11] The MM problem for unoriented n-vertex trees requires
√
Ω( log n) time. The lower bound applies both to deterministic and randomized algorithms.
This lower bound is tight as well. Specifically a randomized algorithm that solves MM in
√
O( log n) time in graphs of constant arboricity was devised in [11].

4.1.2 THE SECOND PROOF

In this section we provide an alternative proof for Theorem 4.2. (In fact, we will show a
slightly weaker variant of it, in which we only allow deterministic algorithms.) Recall that for
a graph G, a parameter t ≥ 0, and a vertex v in G, we denote by Γ̂t (v) = {u | distG (u, v) ≤ t}
the t-neighborhood of v. For any Id-assignment Φ from [n] to Γ̂t (v) we define a vertex
(Γ̂t (v), Φ) in a graph Nt (G), which we will now describe. The vertices of this graph will be
pairs (Γ̂t (v), Φ), where v is a vertex of G, and Φ is an Id-assignment to vertices of Γ̂t (v).
Given two vertices (Γ̂t (v), Φ), (Γ̂t (u), Ψ) of Nt (G), there is an edge between them in Nt (G)
iff all the following conditions hold:
1. Φ (respectively, Ψ) is an Id-assignment for Γ̂t (v) (resp., Γ̂t (u)), for some neighboring
vertices v, u in G.
2. There exists an Id-assignment Υ for the entire graph G, whose restriction to Γ̂t (v)
(respectively, Γ̂t (u)) is Φ (resp., Ψ).
Suppose that we are given a distributed algorithm Π that runs for t rounds and colors G in
α colors. We can assume without loss of generality that the algorithm operates in two stages
(in every single vertex v). In the first stage v collects all the information about Γ̂t (v), i.e.,
the graph G(Γ̂t (v)) and the labels of its vertices. In the second stage v invokes some function
fΠ on Γ̂t (v) and the assignment Ψ of its vertices to compute the color fΠ (v) = fΠ (Γ̂t (v), Φ)
of v.
It is easy to verify that any other algorithm can be simulated by an algorithm that
operates in this way. Hence any deterministic algorithm Π that runs for t rounds can be
fully characterized by the function fΠ as above from nodes (Γ̂t (v), Φ) of Nt (G) to colors
48 4. LOWER BOUNDS

[α]. Observe also that fΠ is an α-coloring of the graph Nt (G). Indeed if for neighboring
pairs (Γ̂t (v), Φ), (Γ̂t (u), Ψ) the function fΠ assigns the same color, then there exists an Id-
assignment Υ for the entire graph for which the algorithm Π returns the same color for both
v and u. On the other hand, (v, u) ∈ E, contradiction to the assumption that Π produces
a legal α-coloring for G for any input Id-assignment Υ for the vertices of G.

Corollary 4.4 If there exists a deterministic algorithm Π that runs for t rounds and colors
G in α (for every assignment of distinct Ids for its vertices), then χ(Nt (G)) ≤ α.

It follows that there is no deterministic algorithm that colors G in χ(Nt (G)) − 1 colors
within t rounds. Interestingly, the opposite is correct as well.

Lemma 4.5 For any graph G and positive integer t, there exists an algorithm that colors
G usin χ(Nt (G)) colors within t rounds. (Here G is a graph given in advance. An algorithm
that colors G is an algorithm that colors the graph for every possible assignment of distinct
Ids to the vertices of G.)

Proof. Let ϕ be a legal χ(Nt (G))-coloring of the graph Nt (G). Every vertex v is given
Nt (G) and ϕ. (This information can be ”hard-wired” into memories of vertices before
the computation starts.) In t rounds each vertex v collects the information about Γ̂t (v),
including the Ids of its vertices. Let Φ be the Id-assignment to Γ̂t (v) that the vertex v learns.
Then v computes the color ϕ(Γ̂t (v), Φ) of the node (Γ̂t (v), Φ) of Nt (G), and returns is as its
ultimate color. It is easy to verify that the resulting coloring is a legal χ(Nt (G))-coloring
for G. 2

For most graphs it is very hard to analyze χ(Nt (G)). Some estimates are known only for
very few graph families. Specifically, √
for unoriented d-regular n-vertex trees G it is known
(see Section 4.1) that χ(Nt (G)) = Ω( d) for t < log n
log d . Also, for an n-path Pn (and also for
an n-cycle Cn ) it is known that χ(Nt (Pn )) ≥ log(2t) n (see Section 4.2). the latter implies
that to color Pn with a constant number of colors one needs at least 12 log∗ n − O(1) rounds.
Consider again the d-regular n-vertex graph Gd with girth(Gd ) > log n
log d and χ(Gd ) ≥
1
√ 1
√ 1 log n
2 d. (See Section 4.1.) For any t, χ(Nt (Gd )) ≥ χ(Gd ) ≥ 2 d. Set t = 2 · log d , and consider
√ Td . We will next show that χ(Nt (Td )) ≥ χ(Nt (Gd )). It will
the d-regular unoriented tree
follow that χ(Nt (Td )) ≥ 21 d, i.e., any t-round deterministic
√ algorithm that colors Td legally
(for any choice of distinct Ids) must use at least 21 d colors.

Lemma 4.6 Nt (Gd ) ⊆ Nt (Td ).

Proof. Consider a vertex (Γ̂t (v), Φ) in Nt (Gd ), i.e., v ∈ V (Gd ) and Φ is an Id-assignment
for vertices of Γ̂t (v). One can pick an arbitrary vertex v ′ ∈ U (i.e., a vertex in Td at distance
at least 21 · log n
log d + 1 from its closest leaf), and assign its vertices identities according to
Φ. Hence (Γ̂t (v), Φ) is a node in Nt (Td ) as well. For an edge ((Γ̂t (v), Φ), (Γ̂t (u), Ψ)) in
 4.2. COLORING THE n-PATH Pn 49

Figure 4.1: Implementing a node (a1 , a2 , ..., a2t+1 ) of G2t+1 as a node of Nt (P ).

Nt (Gd ), there exist two neighboring vertices (v, u) ∈ E(Gd ) and an Id-assignment Υ whose
restriction to Γ̂t (v) (respectively, Γ̂t (u)) is Φ (resp., Ψ). Pick two neighboring vertices v ′ , u′
in U (in Td ), and assign Ids to vertices of Γ̂t (v ′ ) ∪ Γ̂t (u′ ) according to Υ. It follows that
nodes (Γ̂t (v), Φ) and (Γ̂t (u), Ψ) are neighboring in Nt (Td ) as well. 2
1
√ 1 log n
We conclude that χ(Nt (Td )) ≥ χ(Nt (Gd )) ≥ 2 d, for t = 2 · log d , proving the lower bound
of Theorem 4.2.

4.2 COLORING THE n-PATH Pn

In this section we show that an O(1)-coloring of the n-vertex path Pn requires at least
1 ∗
2 log n − O(1) rounds for deterministic algorithms. This result is due to Linial [55]. Naor
[65] extended this lower bound to randomized algorithms. Our presentation here is based
on [55].
We will start with showing that χ(Nt (Pn )) ≥ 3 for t ≤ n−3 2 . As we saw in Section
4.1, this implies that no deterministic algorithm that runs for at most n−3 2 rounds can
legally 2-color Pn . For a positive integer parameter s, let Gs be the graph whose vertices
are s-tuples (a1 , a2 , ..., as ), ai 6= aj for i 6= j, and for every i ∈ [s], ai ∈ [n]. There are edges
((a1 , a2 , ..., as ), (a2 , a3 , ..., as+1 )) in Gs if (a1 , a2 , ..., as ), (a2 , a3 , ..., as+1 ) are vertices of Gs
and a1 6= as+1 .
Consider the graph Nt (Pn ), for some positive integer t. It contains the graph G2t+1 .
Indeed, every node (a1 , a, ..., a2s+1 ) in G2t+1 can be implemented as a t-neighborhood of a
vertex v in the middle of the path Pn = P . (The identities a1 , a2 , ..., at , at+1 , at+2 , ..., a2t+1
are then assigned to the vertices in the t-neighborhood of v. Specifically, v is assigned the
Id that is equal to at+1 . The vertex u at distance t from v that lies on the left side of v is
assigned the Id a1 . The vertices on the subpath of P that connects u to v are assigned Ids
a2 , ..., at . Symmetrically, the t vertices that follow v on P are assigned IDs at+2 , ..., a2t+1 .
Other vertices of P are assigned arbitrary Ids from [n] \ {a1 , ..., a2t+1 }. See Figure 4.1.)
An edge ((a1 , ..., a2t+1 ), (a2 , ..., a2t+1 , a2t+2 )) of G2t+1 is implemented similarly as an
edge of Nt (P ). One just needs to assign the vertex consequent to the one that received
50 4. LOWER BOUNDS

Figure 4.2: An odd cycle in G2t+1 .

Id a2t+1 the Id a2t+2 . (The vertex w in Figure 4.1.) Now let x be the neighbor of v that
was assigned the label at+2 . The nodes (Γ̂t (v), Φ) and (Γ̂t (x), Φ′ ) are neighboring vertices
in Nt (P ), where Φ is the assignment (a1 , ..., a2t+1 ) to the 2t + 1 vertices of P centered at
v, and Φ′ is the assignment (a2 , ..., a2t+2 ) to the 2t + 1 vertices of P centered at x. Hence
G2t+1 is a subgraph of Nt (Pn ), and so χ(G2t+1 ) ≤ χ(Nt (Pn )).
We next argue that χ(G2t+1 ) ≥ 3, and this will emply the desired bound
χ(Nt (Pn )) ≥ 3. To complete the proof it is enough to show that G2t+1 contains
an odd cycle, and thus it is not bipartite. It is easy to verify that the se-
quence of nodes (1, 2, ..., 2t + 1), (2, 3, ..., 2t + 1, 2t + 2), (3, 4, ..., 2t + 2, 2t + 3), (4, 5, ..., 2t +
3, 1), (5, 6, ..., 2t + 3, 1, 2), ..., (2t + 3, 1, 2, ..., 2t) forms a cycle of length (2t + 3) in G2t+1 ,
completing the proof. (See Figure 4.2.)

Theorem 4.7 For t, 1 ≤ t ≤ n−3 2 , it holds that χ(G2t+1 ) ≥ 3. Hence Pn cannot be 2-colored
by a deterministic algorithm in n−3
2 or less rounds.

We will next strengthen the inequality χ(G2t+1 ) ≥ 3, and show that χ(G2t+1 ) ≥ log(2t) n.
Since χ(Nt (Pn )) ≥ χ(G2t+1 ), this would imply that no deterministic algorithm that runs
for t rounds can use less than log(2t) n colors.
 4.2. COLORING THE n-PATH Pn 51
For a positive integer s, let G′s be the subgraph of Gs induced by nodes
(a1 , a2 , ..., as ) with a1 < a2 < ... < as . We will view G′s as a directed graph: each edge
(a1 , a2 , ..., as ), (a2 , a3 , ..., as+1 ) will be oriented towards (a2 , ..., as+1 ). For a directed graph
H = (V, Q), The directed line graph L(H) ~ = (Q, E) is given by E = {he = hu, vi, e′ =
hv, wii | e, e′ ∈ Q}. In the directed line graph L(G ~ ′s ) of G′s an arc h(a1 , ..., as ), (a2 , ..., as+1 )i
is connected to an arc h(a2 , ..., as , as+1 ), (a3 , ..., as+1 , as+2 )i. It follows that L(G ~ ′ ) is
s
′ ′
isomorphic to Gs+1 : we just map each arc h(a1 , ..., as ), (a2 , ..., as+1 )i of Gs to a node
(a1 , a2 , ..., as+1 ) of G′s+1 .
~
Lemma 4.8 For any directed graph H = (V, Q), χ(L(H)) ≥ log χ(H).

Proof. We will argue that

~
χ(H) ≤ 2χ(L(H)) . (4.1)
~
Let ϕ be an x-coloring of L(H), ~
for some x ≥ χ(L(H)). We define a coloring ψ for H in
the following way. For each index i ∈ [x] and vertex v ∈ V let

1 if there exists an outgoing arc hv, ui with ϕ(hv, ui) = i
bi (v) =
0 otherwise

Now ψ(v) = hb1 (v), b2 (v), ..., bx (v)i. Obviously ψ(·) is a 2x -coloring. Next we argue the ψ(·)
is a legal coloring. Consider an edge e = hv, ui ∈ Q. Let i = ϕ(e). Then there exists an
outgoing edge of v ϕ-colored by i, but since ϕ() is legal, there is no outgoing edge of u ϕ-
colored by i. Hence bi (v) = 1 6= bi (u) = 0, and so ϕ(v) 6= ϕ(u). Hence ψ is a legal 2x -coloring
of H, proving (4.1). 2
Observe that G′1 is just an n-clique Kn , with all edges hi, ji, i < j, are oriented towards the
endpoint with a greater index. Hence χ(G′1 ) = n. As a consequence (by Lemma 4.8), for
any positive integer s ≥ 2, χ(G′s ) ≥ log(s−1) n. In particular, for any positive integer t ≥ 1,
χ(G2t+1 ) ≥ χ(G′2t+1 ) ≥ log(2t) n. Since G2t+1 ⊆ Nt (Pn ), the next theorem follows.

Theorem 4.9 No deterministic algorithm that runs for t rounds can color Pn with less
than log(2t) n colors.
∗ ∗
Set t = log2 n − 1. Then log(2t) n = log(log n−2) n > 4. Hence no deterministic algorithm
∗
that runs in less than log2 n − 1 rounds can 4-color Pn . More generally, we have:
log∗ n
Corollary 4.10 O(1)-coloring Pn by a deterministic algorithm requires at least 2 −
O(1) rounds.

As was mentioned above, this lower bound (due to [55]) was extended to randomized algo-
rithms in [65].
52

CHAPTER 5

Forest-Decomposition
Algorithms and Applications
Coloring forests can be performed extremely efficiently in the distributed setting, both in
terms of running time and number of colors. Using the algorithms of Cole and Vishkin [18]
or Goldberg, Plotkin and Shannon [31], one can compute 3-vertex-coloring of a forest in
O(log∗ n) time. However, coloring general graphs is a significantly more challenging task.
The best currently known deterministic algorithms for general graphs for (∆ + 1)-coloring
require at least linear in ∆ time, unless ∆ is very large.1 Nevertheless, for a wide range of
graph families, it is possible to achieve much better results. If a graph can be decomposed
into a reasonably small number of oriented forests, then both the running time and the
size of the employed coloring palette can be reduced. Indeed, each of the forests in the
decomposition can be colored quickly with 3 colors. However, using the decomposition
to achieve a unified legal coloring of the entire input graph is more complicated. In this
chapter we describe an algorithm that computes a forest-decomposition for graphs with
bounded arboricity (see Section 2.3 for the definition of arboricity), and uses it for coloring
them efficiently. The material in this chapter is based on [7]. See also Section 8.1, where
we describe a simple forest-decomposition procedure due to Panconesi and Rizzi [68]. The
latter procedure applies to graphs with bounded maximum degree ∆.

5.1 H-PARTITION
In this discussion we assume that all vertices know the arboricity a of the input graph and
the number of vertices n before the algorithm starts. (See [7] for extensions to scenarios in
which the arboricity or/and the number of vertices is unknown.) The algorithm starts with
computing an H-partition of the graph (to be defined shortly). Then the H-partition is
used for computing O(a)-forest-decomposition. Recall that the arboricity a is the minimum
number of forests into which the edge-set of the input graph can be decomposed. For an inte-
ger parameter A ≥ 2a, an H-partition is a vertex-partition into subsets H1 , H2 , ..., Hℓ ⊆ V ,
Sℓ
such that each vertex in Hi , 1 ≤ i ≤ ℓ, has at most A neighbors in j=i Hj . The parameter

1 For randomized algorithms the situation is better. Specifically, algorithms that run in O(log n) time, √for all
values of ∆, are known [1, 60, 61]. For deterministic algorithms one can compute a (∆ + 1)-coloring in 2O( log n)
time [69].
 5.1. H-PARTITION 53
A is called the degree of the H-partition H1 , H2 , ..., Hℓ . The parameter ℓ is called the size
of the H-partition. See Figure 5.1 in the end of this section for an illustration.
The procedure that computes an H-partition is called Procedure Partition. This pro-
cedure accepts as input the arboricity a of the graph, and an arbitrarilly small positive
real constant ǫ ≤ 2. The parameter ǫ determines the quality of the resulting H-partition.
In other words, smaller values of ǫ result in H-partition with smaller degree, which, in
turn, allows one to compute a forest-decomposition with fewer forests. However, selecting
small values for ǫ affects the size of the H-partition, and, consequently, the running time
is affected as well. Specifically, Procedure
 Partition computes an H-partition with degree
at most (2 + ǫ) · a and size ℓ = 2ǫ log n within ℓ rounds.
During the execution of Procedure Partition each vertex in V is either active or
inactive. Initially, all the vertices are active. For every i = 1, 2, ..., ℓ, in the i th round each
active vertex with at most (2 + ǫ) · a active neighbors joins the set Hi and becomes inactive.
The pseudo-code of Procedure Partition is presented below.
 
Algorithm 1 Procedure Partition(a,ǫ): partitions the vertices into ℓ = 2ǫ log n sets such
Sℓ
that every vertex v ∈ Hi , i ∈ {1, 2, ..., ℓ}, has at most (2 + ǫ) · a neighbors in j=i Hj .
Initially all vertices are active.
An algorithm for each vertex v ∈ V :
1: for round i = 1, 2, ..., ℓ do
2: if v is active and has at most (2 + ǫ) · a active neighbors then
3: make v inactive
4: add v to Hi
5: send the messages ’inactive’ and ’v joined Hi ’ to all the neighbors
6: end if
7: for each received ’inactive’ message do
8: mark the sender neighbor as inactive
9: end for
10: end for

The next lemma shows that each vertex in the network becomes inactive during the
execution, and joins one of the sets H1 , H2 , ...., Hℓ .
ǫ
Lemma 5.1 A graph G = (V, E) with arboricity a(G) has at least 2+ǫ · |V | vertices with
degree (2 + ǫ) · a or less.
2
Proof. Suppose for contradiction that there are more than 2+ǫ · |V | vertices with degree
greater than (2 + ǫ) · a. It follows that
X 2 |E|
2|E| = deg(v) > ((2 + ǫ) · a) · |V | · = 2 · a · |V | ≥ 2 · · |V | > 2|E|.
2+ǫ |V | − 1
v∈V
54 5. FOREST-DECOMPOSITION ALGORITHMS AND APPLICATIONS

This is a contradiction. 2

By the definition of arboricity, the subgraph induced by any subset of V of active

vertices has arboricity at most a as well.

Lemma 5.2 For any subgraph G′ of G, the arboricity of G′ is at most the arboricity of G.
ǫ
By Lemmas 5.1 and 5.2, in each round at least ( 2+ǫ )-fraction of the active ver-
tices become inactive, and so after log(2+ǫ)/2 n rounds all vertices become inactive. Since
log(2+ǫ)/2 n ≤ 2ǫ log n for ǫ, 0 < ǫ ≤ 2, we have proved the following lemma.

Lemma 5.3 For a graph G with a(G) = a, and a parameter ǫ, 0 < ǫl≤ 2, Procedure m
Partition(a,ǫ) produces an H-partition H = {H1 , H2 , ...., Hℓ } of size ℓ ≤ log(2+ǫ)/2 n ≤
2 
ǫ log n .

The next lemma shows that the H-partition H has a small degree.
 
Lemma 5.4 The H-partition H = {H1 , H2 , ..., Hℓ } , ℓ ≤ 2ǫ log n , has degree at most A =
(2 + ǫ) · a.

Proof. The vertex v was added to Hj in round number j. Every neighbor of v that belongs
to one of the sets Hj , Hj+1 , ..., Hℓ was added to its set in round j or later. Therefore, at
the end of round j − 1 all its neighbors in Hj ∪ Hj+1 ∪ ... ∪ Hℓ were active. The vertex v
has been added because the number of its active neighbors was at most (2 + ǫ) · a. Thus
the number of the neighbors of v in Hj ∪ Hj+1 ∪ ... ∪ Hℓ is at most (2 + ǫ) · a. 2

We summarize the properties of Procedure Partition in the following theorem.

 ǫ, 0 < ǫ ≤ 2, Pro-
Theorem 5.5 For a graph G with arboricity a(G) = a, and a parameter
cedure Partition(a, ǫ) computes an H-partition of size ℓ ≤ 2ǫ log n with degree at most
(2 + ǫ) · a. The running time of the procedure is O(log n).

This procedure can be also used with a second parameter q > 2. (For convenience,
this parameter is called ǫ when it is at most 2, and q when it is larger than 2.) Observe
that Lemma 5.1 is applicable for all values of the second parameter. The number of rounds
required to make all vertices inactive is at most log 2+q n = O( log n
log q ), and thus, for q > 2,
j k 2

set ℓ = log 2+q n . Consequently, the resulting H-partition has size O( log n
log q ) as well. On
2
the other hand, by Lemma 5.4, the degree of the H-partition is at most (2 + q) · a.

Corollary 5.6 For a graph G with arboricity a(G) = a, and a parameter q, q > 2, Pro-
cedure Partition(a,q) computes an H-partition of size O( log n
log q ) with degree A ≤ (2 + q) · a.
The running time of the procedure is O( log n
log q ).
 5.1. H-PARTITION 55
An H-partition can be employed in order to compute a forest-decomposition as fol-
lows. Given an H-partition, one can employ it for computing an acyclic orientation of the
input graph, whose out-degree is at most the out-degree of the H-partition. (More details
are provided below.) Once an acyclic orientation is computed, each vertex becomes respon-
sible only for its outgoing edges. In this way, for each edge e, exactly one of the endpoints
of e is responsible for it. Next, each vertex assigns distinct labels 1, 2, ... to its outgoing
edges. We will soon argue that all edges in the graph that receive the same label form a
forest.
Now we turn to describe the procedure for computing forest-decomposition that is
called Procedure Forest-Decomposition. Similarly to Procedure Partition, it accepts as input
the parameters a and ǫ. In the first step it computes an H-partition with degree at most
(2 + ǫ) · a. In the next step, it invokes a procedure called Procedure Orientation. Procedure
Orientation orients the edges of the graph as follows. For each edge e = (u, v), if the end-
points u, v are in different sets Hi , Hj , i 6= j, then the edge is oriented towards the endpoint
in the set with a greater index. Otherwise, if i = j, the edge e is oriented towards the vertex
with a greater Id among the two vertices u and v. The orientation µ produced by this step
is acyclic. By Lemma 5.4, each vertex has µ-out-degree at most (2 + ǫ) · a.
Finally, in the last step Procedure Forest-Decomposition partitions the edge set of the
graph into forests. Each vertex is in charge for its outgoing edges, and it assigns each out-
going edge a different label from the set {1, 2, ..., ⌊(2 + ǫ) · a⌋}. This step will be henceforth
referred as the labeling step.

Algorithm 2 Forest-Decomposition(a,ǫ): partition the edge set into ⌊(2 + ǫ) · a⌋ forests.

1: Invoke Procedure Partition(a, ǫ) /* See Algorithm 1 */
2: µ := Orientation()
3: Assign a distinct label to each µ-outgoing edge of v from the set {1, 2, ..., ⌊(2 + ǫ) · a⌋}

The time complexity of Procedure Partition is O(log n), and the steps 2 and 3 of
Procedure Forest-Decomposition, orienting and labeling the edges, require O(1) rounds
each. Hence the overall time complexity of the forest-decomposition algorithm is O(log n).
Definition 5.7 Given an H-decomposition H = {H1 , H2 , ..., Hℓ } of a graph G = (V, E),
the H-index of a vertex v ∈ V is the unique index i ∈ [ℓ] = {1, 2, ..., ℓ} such that v ∈ Hi .
Lemmas 5.8-5.10 constitute the proof of correctness of the algorithm for computing
a forest-decomposition.
Lemma 5.8 The orientation µ formed by Algorithm 2 is consistent.
Proof. For an edge e = (u, v), if u orients e towards v then either the H-index of v is
greater than the H-index of u, or they have the same H-index but ID(u) < ID(v). In both
cases v orients e towards v as well. 2
56 5. FOREST-DECOMPOSITION ALGORITHMS AND APPLICATIONS

Lemma 5.9 The orientation µ formed by the algorithm is acyclic.

Proof. We show that there are no directed cycles with respect to µ. Let C be a cycle of
G. Let v be a vertex in C such that the H-index i of v is the smallest index of a vertex
in C, and such that ID(v) is the smallest identity number in Hi ∩ C. Let u, w denote the
two neighbors of v in C. Obviously, both edges (v, u) and (v, w) are oriented outwards of
v, and thus, the µ-out-degree of u in the cycle is 2. Hence C is not a directed cycle with
respect to µ. Consequently, the orientation µ is acyclic. 2
For each i ∈ [ℓ], consider the graph Gi = G(Hi ) induced by the set Hi . Lemma 5.4
implies that the maximum degree ∆(Gi ) of a vertex in Gi is at most (2 + ǫ) · a. Moreover,
a stronger statement follows:

Lemma 5.10 Each vertex has µ-out-degree at most (2 + ǫ) · a.

Proof. Let v be a vertex of G. Let j be the H-index of v. Each outgoing edge of v is

connected to a vertex with an H-index that is greater or equal to j. Hence by Lemma 5.4,
v has at most (2 + ǫ) · a outgoing edges. 2
By Lemma 5.10, once the orientation µ is formed, each vertex can assign distinct
labels to its outgoing edges from the range 1, 2, ..., ⌊(2 + ǫ) · a⌋. Denote A = ⌊(2 + ǫ) · a⌋.
The next lemma shows that the undirected graph induced by the set of edges labeled with
the label i, for any i ∈ [A], does not contain cycles.

Lemma 5.11 For each label i, the set of edges labeled by i forms a forest.

Proof. By Lemma 5.9, each cycle of G has a vertex with two outgoing edges in this cycle.
Suppose for contradiction that there is a cycle C with all edges labeled by the same label
i. There exists a vertex v in this cycle and two edges e1 , e2 adjacent to v oriented outwards
of v. Thus, the algorithm labeled the edges e1 , e2 with different labels, contradiction. 2
We summarize this section with the following corollary.

Corollary 5.12 For a graph G with arboricity a = a(G), and a parameter ǫ, 0 < ǫ ≤ 2,
Procedure Forest-Decomposition(a, ǫ) partitions the edge set of G into A = ⌊(2 + ǫ) · a⌋
oriented forests in O(log n) rounds. Moreover, as a result of its execution each vertex v
knows the label and the orientation of every edge (v, u) adjacent to v.

Similarly to Procedure Partition, Procedure Forest-Decomposition can be invoked

with second parameter q > 2. Lemmas 5.8 - 5.11 stay unchanged, and thus we obtain the
following corollary.

Corollary 5.13 For a graph G with a(G) = a, and a parameter q, q > 2, Procedure Forest-
Decomposition(a, q) partitions the edge set of G into at most (2 + q) · a forests within time
O( log n
log q ).
 5.2. AN O(a)-COLORING 57
See Figure 5.1 for an illustration.

Figure 5.1: H-partition and Forest-Decomposition. (Some vertices and edges are omitted from
the figure for clarity.) An outgoing edge from a vertex u to a vertex v labeled with a label i
means that v is the parent of u in a tree of the i th forest Fi . Solid edges represent edges with
the label ’1’. Dashed edges represent edges with the label ’2’.

5.2 AN O(a)-COLORING
A forest-decomposition allows us to compute a legal coloring of the entire graph very quickly.
Since each vertex belongs to at most A = O(a) forests, we can maintain a vector of size A
for each vertex, for representing colors in different forests. The i th coordinate of the vertex
represents the color that is assigned to the vertex in the i th forest. Next, we perform A
parallel invocations of the CV algorithm for 3-coloring oriented forests. (See Section 3.4.)
Invocation i, i = 1, 2, ..., A, computes a 3-coloring of the i th forest, and stores the result
in the i th coordinate of the vector. Observe that such a vector can be seen as an integer
number in the range {1, 2, ..., 3A }. Observe also, that for each pair of neighbors u, v in the
input graph, there exist a forest Fi , i ∈ {1, 2, ..., A}, in the decomposition, such that either
u is the parent of v in the forest Fi or vice versa. In any case, the i th coordinate of the
vector of v and that of the vector of u are different each from another. Thus, it is possible to
compute a 3A -coloring of a graph which is decomposed into A forests in O(log∗ n) time. The
running time for computing a 3A -coloring from scratch is O(log n). (Forest-decompositions
can be computed in O(log n) time by Corollary 5.12. Observe that A = O(a), and so this
is a 3O(a) -coloring.)
We summarize this discussion by the following theorem.
Theorem 5.14 A legal 3O(a) -coloring of an n-vertex graph G = (V, E) with arboricity a
can be computed deterministically within O(log n) time.
Although the above algorithm is very simple and very fast, it produces an output with
quite a large number of colors. Next, we discuss how to improve the number of colors to O(a).
58 5. FOREST-DECOMPOSITION ALGORITHMS AND APPLICATIONS

(Recall that a ≤ ∆, and that for a wide range of graph families, a is significantly smaller
than ∆.) This, however, comes at a price of increasing the running time. The improved
algorithm is called Procedure Arb-Color. It colors the input graph G of arboricity a = a(G)
using A + 1 colors, where A = ⌊(2 + ǫ) · a⌋, and ǫ is an arbitrarily small positive parameter.
The running time of the algorithm is O(a · log n).
The algorithm starts by executing Procedure Forest-Decomposition with  the input
parameter a = a(G). This invocation returns an H-partition of G of size ℓ ≤ 2ǫ log n and
degree at most A. Then, for each index i, the graph Gi = G(Hi ) induced by the set Hi is
colored using the KW algorithm for (∆ + 1)-coloring (see Section 3.8). By Lemma 5.4, for
all i, i = 1, 2, ..., ℓ, the subgraph Gi satisfies ∆(Gi ) ≤ A. Hence the algorithm colors each
graph Gi with at most A + 1 colors. Denote by ϕi the coloring of Gi . Although each ϕi is
a legal coloring, the resulting coloring of the entire input graph G is not necessarily legal.
Thus, it needs to be converted into a legal (A + 1)-coloring of G. To this end the subgraphs
G1 , G2 , ..., Gℓ are gradually recolored. The recoloring starts from the last subraph Gℓ , and
proceeds backwards, ending with the first subgraph G1 .
The recoloring is performed using a new orientation η of G, which is computed from
the colorings ϕ1 , ϕ2 , ..., ϕℓ . The new orientation η is computed using a procedure called
Procedure New-Orientation that works in the following way. For each edge (u, v) whose
endpoints u and v belong to Gi and Gj respectively, for some i < j, the edge is oriented
towards v. For each edge (u, v) whose both endpoints belong to the same Gi , for some
1 ≤ i ≤ ℓ, the edge is oriented towards the vertex with a greater ϕi -color. (Since ϕi is a
legal coloring of Gi , it necessarily holds that ϕi (u) 6= ϕi (v).) This completes the description
of Procedure New-Orientation.
Observe that the procedure orients all the edges in the input graph, and that for edges
e that cross between distinct subgraphs Gi and Gj , the orientations µ and η have assigned
the same direction to e. (Recall that the orientation µ was computed within Procedure
Forest-Decomposition. See Section 5.1.) However, inside subgraphs these orientations are
different. Specifically, the length of the orientation η restricted to a subgraph Gi is at most
the number of colors used by ϕi . (See Property 3.4.) This is in contrast to the orientation
µ whose length within Gi may be arbitrarily large.
The new orientation η is used for constructing a new coloring ϕ of the input graph.
The coloring is computed according to Property 3.3. Specifically, each vertex waits for all
its parents with respect to η to select a color. Then it selects its own color to be different
from the selections of all its parents. Since the length of η is O(a · ℓ) = O(a log n), and its
out-degree is at most the degree of the H-partition, the new coloring ϕ is computed in
O(a log n) time, and employs A + 1 colors. The coloring ϕ is the final coloring returned by
the algorithm. This completes the description of Procedure Arb-Color. Its pseudocode is
provided below.
 5.3. FASTER COLORING 59

Algorithm 3 Procedure Arb-Color(a,ǫ)

1: A := ⌊(2 + ǫ) · a⌋
2: H = (H1 , H2 ..., Hℓ ) := Forest-Decomposition(a,ǫ)
3: In parallel, color each graph Gi , i = 1, 2, ..., ℓ, with A + 1 colors using the KW algorithm.
Denote the resulting colorings ϕi , i = 1, 2, ..., ℓ.
4: η := New-Orientation()
5: ϕ := Compute (A + 1)-coloring of G using η and Property 3.3

The correctness of the procedure follows from the above discussion. The running time
of step 2 is O(log n). The running time of step 3 is O(a log a + log∗ n). The running time of
step 5 is proportional to the length of the orientation η, which is O(a log n). The other steps
require O(1) time. Thus, the overall running time of Procedure Arb-Color is O(a log n).

Theorem 5.15 For a graph G with arboricity a = a(G), and a positive parameter ǫ, 0 <
ǫ ≤ 2, Procedure Arb-Color(a, ǫ) computes an O(a) coloring of G in time O(a log n).

We remark that invoking Procedure Arb-Color with q > 2 as second parameter results
in inferior results than those given by Theorem 5.15. Specifically, it results in O(q · a)-
coloring in O(q · a · log n) time.

5.3 FASTER COLORING

In some occasions it is important that the number of colors that an algorithm employs is
as small as possible. In other occasions the running time of the algorithm is crucial. Thus,
sometimes one may want to compromise the running time for achieving a smaller number of
colors, and sometimes the other way around. Thus, a tradeoff between the running time and
the number of colors is often handy. Next, we describe an algorithm (from [7]) for computing
O(t · a)-coloring in O( at · log n + a) time, for a parameter t, 1 ≤ t ≤ A + 1. (Recall that
A = ⌊(2 + ǫ) · a⌋, for an arbitrarily small positive constant ǫ ≤ 2.) The algorithm is called
Procedure Tradeoff-Color.
We start with describing a special case in which the procedure is invoked with the pa-
rameter t = A + 1. Later we describe the general case. The first steps of Procedure Tradeoff-
Color are similar to those of Procedure Arb-Color (Algorithm 3). Specifically, steps 1-3 are
exactly the same as in Procedure Arb-Color, and the only difference is that instead of steps
4-5 it invokes a procedure called Recolor.
Procedure Recolor accepts as input the H-partition H = {H1 , H2 , ...., Hℓ } of the
graph G computed by Procedure Forest-Decomposition in step 2. Procedure Recolor pro-
ceeds iteratively, and creates a new coloring ψ. Vertices of the set Hℓ retain their colors. For
all other vertices v ∈ V \ Hℓ , ψ(v) is initialized as NULL. In iteration i, i = 1, 2, ..., ℓ − 1,
vertices of the set Hℓ−i are recolored. In the case of t = A + 1, each iteration requires
60 5. FOREST-DECOMPOSITION ALGORITHMS AND APPLICATIONS

exactly one round. All vertices of Hℓ−i select a new color in parallel. A vertex v with
ϕℓ−i (v) = k, where 1 ≤ k ≤ A + 1, selects a new color from the range {(k − 1) · (A + 1) +
1, (k − 1) · (A + 1) + 2, ..., k · (A + 1)} = [(k − 1) · (A + 1) + 1, k · (A + 1)], which is not
Sℓ
used by any neighbor of v in j=ℓ−i Hj . (In other words, ψ(v) is selected from the set
Sℓ
[(k − 1)(A + 1) + 1, k · (A + 1)] \ {ψ(w) | w ∈ Γ(v) ∩ j=ℓ−i Hj }. Note that in this variant
of the algorithm, when the value of ψ(v) is selected it holds that ψ(v) = NULL for ev-
ery w ∈ Hℓ−i .) Observe that there is at least one such color for any vertex v, because
Sℓ Sℓ
deg(v, j=ℓ−i Hj ) ≤ A, and so |{ψ(u) | u ∈ j=ℓ−i Hj , ψ(u) 6= NULL}| ≤ A as well.
Consider, for example, iteration 1. In this iteration the vertices of Hℓ−1 select a
new color. Specifically, all vertices v with ϕℓ−1 (v) = 1 select a new color from the range
{1, 2, ..., A + 1}. In parallel, the vertices v with ϕℓ−1 (v) = 2 select a new color from the
range {A + 2, A + 3, ..., 2(A + 1)}, and so on. Observe that for any pair of neighbors u, v
that belong to the same Hℓ−i , 1 ≤ i < ℓ, their ϕℓ−i -colors are different, and that distinct
ϕℓ−i -colors are associated with disjoint palettes (ranges). Hence u and v select distinct
colors. Morover, any pair that belong to distinct H-sets select distinct colors as well. In
this case, the vertex with a smaller H-index necessarily selects a new color which is distinct
from the selection of its neighbor with a greater H-index.
Now we turn to the general case where 1 ≤ t ≤ A + 1. Similarly to the previous case,
Procedure Tradeoff-Color begins with executing steps 1-3 as in Procedure Arb-Color. Then
it executes a general version of Procedure Recolor. (This version will be described shortly.)
The pseudocode of Procedure Tradeoff-Color is provided below.

Algorithm 4 Procedure Tradeoff-Color(a, ǫ, t)

1: Execute steps 1-3 of Procedure Arb-Color
2: Recolor(t, H)

Procedure Recolor recolors roughly t color classes of Hℓ−i in the same round.
Specifically, Procedure
 Recolor groups the (A + 1) color classes C1 , C2 , ..., CA+1 of Hℓ−i
into p = A+1 t disjoint subsets S1 , S2 , ..., Sp . Each subset Sj , j = 1, 2, ..., p, contains the
color classes Cr with indices r ∈ Ij = {(j − 1)t + 1, (j − 1)t + 2, ...., min {j · t, A + 1}}, i.e.,
Sj = {Cr | r ∈ Ij }.
The i th iteration of Procedure Recolor continues for p rounds. In round j, j =
1, 2, ..., p, vertices of color classes Cr , r ∈ Ij , are recolored in parallel. To guarantee
that no pair of neighboring vertices u ∈ Cr , w ∈ Cr′ , r 6= r′ , r, r′ ∈ Ij , will select the
same color, the color classes {Cr | r ∈ Ij } are assigned disjoint palettes {Pr | r ∈ Ij },
Pr = {(A + 1)(r − 1 − (j − 1)t) + 1,
(A + 1)(r − 1 − (j − 1)t) + 2, ..., (A + 1)(r − 1 − (j − 1)t) + (A + 1)}.
 5.3. FASTER COLORING 61
In other words, the color class C(j−1)t+1 (i.e., r = (j − 1)t + 1) is assigned the palette
P(j−1)t+1 = {1, 2, ..., A + 1}, the color class C(j−1)t+2 is assigned the palette
P(j−1)t+2 = {(A + 1) + 1, (A + 1) + 2, ..., 2(A + 1)}, etc., for every j = 1, 2, ..., p.
Consider a vertex v ∈ Cr , r ∈ Ij . In round j of the i th iteration the vertex v selects
a color from its palette Pr which is not taken by any neighbor in the set W of already
recolored vertices. This completes the description of Procedure Recolor. Its pseudocode is
provided below.

Algorithm 5 Procedure Recolor (t, H = (H1 , H2 , ..., Hℓ ))

1: W := ∅ /* the set of recolored vertices */
2: for i := ℓ − 1 downto 1 do
3: k = ((ϕi (v) − 1) modt) 
4: for round p := 1 to A+1 t do
5: for each vertex v in Hi such that (p − 1) · t < ϕi (v) ≤ min{p · t, A + 1} (in paral-
lel) do
6: recolor v with a color from the set:
{k · (A + 1) + 1, k · (A + 1) + 2, ..., (k + 1) · (A + 1)} \ {ψ(w) | w ∈ W ∩ Γ(v)}
7: W := W ∪ {v}
8: end for
9: end for
10: end for

Each palette Pr contains (A + 1) colors. Consider a vertex v and the set W

at the time when v is recolored (in step 6 of Algorithm 5). It holds that deg(v, W )
Sℓ
≤ deg(v, j=ℓ−i Hj ) ≤ A. Hence there necessarily exists a color for v in its palette, which
is not used by its neighbors in W . Using an inductive argument on the number of iterations
it can be shown that Procedure Tradeoff-Color produces a legal coloring.
For an upper bound on its running time, observe
 that Procedure Recolor runs for
O(log n) iterations, and each iteration requires A+1t = O( a
t rounds. Hence the running
)
a
time of Procedure Recolor is O( t log n). The running time of the step which computes a
forest-decomposition is O(log n). Finally, invoking the KW algorithm (see Section 3.8, and
step 3 of Procedure Arb-Color, Algorithm 3) requires O(a log a + log∗ n) rounds. Hence the
overall running time of Procedure Tradeoff-Color is O( at · log n + a log a).
However, the improved running time of Procedure Tradeoff-Color (in comparison to
the running time of Procedure Arb-Color - see Theorem 5.15) comes at a price. Specifically,
since we used t disjoint palettes of size A + 1 each, the number of colors that were used
is t · (A + 1) = O(t · a). We summarize the properties of Procedure Tradeoff-Color in the
following theorem.
62 5. FOREST-DECOMPOSITION ALGORITHMS AND APPLICATIONS

Theorem 5.16 For a positive parameter t, 1 ≤ t ≤ A + 1, Procedure Tradeoff-Color pro-

duces an O(a · t)-coloring of the input graph in time O( at · log n + a log a).
We remark that in Section 6 we will show that (∆ + 1)-coloring for general graphs can
be computed within O(∆ + log∗ n) time, rather than in O(∆ · log ∆ + log∗ n) time. This
speeds up the algorithm of Theorem 5.16. Specifically, the improved running time is O( at ·
log n + a).
Notice that by substituting t = 1 we obtain the O(a)-coloring algorithm (Procedure
Arb-Color) which was described in Section 5.2. (See Theorem 5.15.)
Next, we describe a variant of Procedure Tradeoff-Color, that accepts as input a =
a(G), and a parameter q, q > 2. (In other words, the second parameter that the procedure
accepts is now greater than 2, as opposed to ǫ ≤ 2.) This new variant computes an O(a2 · q)-
coloring. In its first step it invokes Procedure Forest-Decomposition with the same pair of
parameters a and q. By Corollary 5.13, this procedure partitions the edge set of G into at
most (2 + q) · a forests, and it does so within time O( log n
log q ). The other steps are very similar
to those of the previous variant (when invoked with t = A + 1). The only difference is that
the value of A is now (2 + q) · a and not ⌊(2+ ǫ) · a⌋. By the same argument,  this new
(2+q)·a log n
variant computes an O(a · q · t)-coloring in O t · log q + (2 + q) · a time, for any t,
1 ≤ t ≤ (2 + q) · a = A. In particular, by setting t = a · q we obtain an O(a2 · q 2 )-coloring
within O( log n
log q + q · a) time.
log n √ ′
Finally, set q ′ = q 2 . We get an O(a2 · q ′ )-coloring within time O( log q′ + a · q ).
Corollary 5.17 For an n-vertex graph G with arboricity a and a parameter q > 2, Pro-
cedure Tradeoff-Color invoked with parameters a and q computes an O(a2 · q)-coloring in
time
√
O( log n
log q + a · q).
Consider an unoriented n-vertex tree T . Observe that its arboricity a(T ) is equal to 1.
Set q = ∆ǫ , for an arbitrarily small constant ǫ > 0. Corollary 5.17 implies an O(∆ǫ )-coloring
log n 1/2
of T within O( log ∆ ) time. On the other hand, Linial [56] showed that an o(∆ )-coloring of
log n
an unoriented ∆-regular tree requires Ω( log ∆ ) time (see Section 4.1). Therefore, remarkably,
ǫ
the running time of the O(∆ )-coloring algorithm (provided by Corollary 5.17) for graphs
with constant arboricity cannot be improved by more than a constant factor.

5.4 MIS ALGORITHMS

In this section we capitalize on the results of Section 5.3, and describe an algorithm that
computes an MIS in graphs with bounded arboricity in sublogarithmic time. The algorithm
employs the basic reduction from MIS to coloring. (See Section 3.2.)
First, observe that by Corollary 5.17, for any graph with arboricity O((log n)1/2−ǫ ),
for a positive constant ǫ < 21 , a legal O( logloglogn n )-coloring can be found in O( logloglogn n ) time.
 5.4. MIS ALGORITHMS 63
ǫ
(To this end, set q = (log n) .) Then the basic color reduction technique (see Section 3.2)
that reduces the number of colors, one color per round, can be used to achieve (∆ + 1)-
coloring in additional O( logloglogn n ) rounds. We summarize this fact in the following corollary.

Corollary 5.18 For a graph G with arboricity a(G) = O((log n)1/2−ǫ ), 0 < ǫ < 1/2, both
(∆ + 1)-coloring and O( logloglogn n )-coloring can be found in O( logloglogn n ) time.

Corollary 5.18 can be used in conjunction with the basic reduction from MIS to
coloring. (See Section 3.2.) Specifically, given an O( logloglogn n )-coloring, the reduction produces
an MIS by handling one color class in each round. The overall running time is O( logloglogn n ).
Consequently, we obtain an MIS algorithm for graphs with bounded arboricity that runs
is sublogarithmic time.

Theorem 5.19 Consider an n-vertex graph G with arboricity a(G) = O((log n)1/2−ǫ ), 0 <
ǫ < 1/2. Procedure Tradeoff-Color combined with the standard reduction from an MIS to
coloring, computes an MIS of G in time O( logloglogn n ).
√
Whenever a = Ω( log n) the same reduction can be used in conjunction with Lemma 5.16.
The running time of the resulting algorithm for computing MIS becomes O( at · log n + a · t).
√
This expression is optimized by setting t = log n.
√
Theorem 5.20 Consider an n-vertex graph G with arboricity a(G) = Ω( log n). Proce-
√
dure Tradeoff-Color invoked with parameters a and t = log n, combined with the standard
√
reduction from MIS to coloring, computes an MIS of G in time O(a · log n).

In particular, Theorem 5.20 implies that an MIS can be computed deterministically in

polylogarithmic time on graphs with polylogarithmic arboricity. (This follows from Theorem
5.15 as well.)
In [7] it is shown that the algorithms presented in this section can be extended to
scenarios in which the vertices do not know the value of the arboricity a or the number
of vertices n at the beginning of the computation. The effect of the generalization on the
running time of these algorithms is minor. The description of these extensions is outside the
scope of this monograph. A far more general approach can be found in [44]. This approach
allows one to transform algorithms that require some global knowledge into algorithms that
do not require it, for a wide range of distributed algorithms.
64

CHAPTER 6

Defective Coloring
In this section we discuss computation of defective colorings (see also Section 2.4), and
show how defective colorings can be transformed into legal ones. Specifically, we describe
a (∆ + 1)-coloring algorithm that requires O(∆) + log∗ n time, which is based on defective
coloring. The results of this section are due to [8, 48].
In this section and later we assume that all vertices know ∆ and n before the beginning
of execution. In the previous section we noted that many distributed algorithms can be
extended to work without knowing in advance such parameters. In particular, it is shown
in [44] that the legal (∆ + 1)-coloring algorithms described in this section can be generalized
to the scenario when ∆ and n are not known in advance. The generalization affects the
running time only by constant factors.

6.1 EMPLOYING DEFECTIVE COLORING FOR COMPUTING

LEGAL COLORING
In a graph G colored by a defective coloring ψ a vertex may have a color identical to colors
of some of its neighbors. Nevertheless, the number of neighbors with an identical color is
bounded by the defect of ψ. This property allows one to employ defective colorings in order
to compute legal colorings efficiently. Suppose that ψ is a d-defective p-coloring, for some
integers d and p. Each vertex v in G has at most d neighbors colored with the color ψ(v).
Therefore, for i = 1, 2, ..., p, the subgraph Gi ⊆ G induced by all vertices that are colored
with color i, has maximum degree at most d. Hence, Gi can be colored with (d + 1)-colors,
rather than (∆ + 1). Moreover, the running time of computing a (d + 1)-coloring of Gi
depends on d as well. For example, one can use the KW algorithm (see Section 3.8) to
compute a (d + 1)-coloring of Gi in O(d log d) + log∗ n time.
Suppose that we could compute a ⌊∆/p⌋-defective p-coloring ψ of the graph G, for
any p, 1 ≤ p ≤ ∆. In this case d = ⌊∆/p⌋. Suppose also that the running time of this
computation would be f (n, ∆), for some function f . Then we could color legally, in parallel,
the subgraphs G1 , G2 , ..., Gp induced by the color classes of ψ. We would use the color
palette P1 = {1, 2, ..., d + 1} for G1 , the color palette P2 = {d + 2, d + 3, ..., 2(d + 1)} for
G2 , and so on. Coloring all graphs Gi with the palettes Pi results in a legal (⌊∆/p + 1⌋ · p) =
O(∆)-coloring of G. (The coloring is legal because any pair of neighbors that belong to the
same Gi are colored with distinct colors, as a result of invoking the KW algorithm on Gi .
Any pair of vertices that belong to different subgraphs Gi and Gj are colored using disjoint
6.1. EMPLOYING DEFECTIVE COLORING FOR COMPUTING LEGAL COLORING 65
palettes Pi and Pj .) Since the KW algorithm is used for coloring the subgraphs Gi , the
overall running time would be f (n, ∆) + O(∆/p · log(∆/p)) + log∗ n.
Thus, the ability to compute a ⌊∆/p⌋-defective p-coloring efficiently, for sufficiently
large p, would result in a legal O(∆)-coloring algorithm with sublinear in ∆ running time.
Unfortunately, computing such a defective coloring is a challenging open problem. (Though,
in the sequential setting, a ⌊∆/p⌋-defective p-coloring, can be computed for any input graph
G, and any parameter p, using a simple greedy algorithm [58]. See Section 2.4.) On the other
hand, a defective coloring with somewhat weaker parameters is sufficient for computing
a (∆ + 1)-coloring in O(∆) + log∗ n time. Specifically, an O(∆/p)-defective p2 -coloring is
appropriate for this goal, and it can be efficiently computed in the distributed setting. In
this section we discuss how to use an O(∆/p)-defective p2 -coloring for computing a legal
(∆ + 1)-coloring. In the next section we describe how to compute an O(∆/p)-defective
p2 -coloring from scratch.
We will be using the following theorem that states that an appropriate defective
coloring can be computed efficiently. In the next section we discuss an algorithm that
computes it, and prove its correctness.

Theorem 6.1 Let p be a parameter such that p ≤ ∆ǫ , for an arbitrarily small constant
ǫ > 0. It is possible to compute an O(∆/p)-defective p2 -coloring within O(∆3ǫ ) + log∗ n
deterministic time.

Remark: This theorem is from [8]. A faster algorithm for computing an O(∆/p)-defective
p2 -coloring for any p, 1 ≤ p ≤ ∆, was devised in [48]. The running time of that algorithm
is log∗ n + O(1).
We start with presenting a legal (∆ + 1)-coloring algorithm that runs in
O(∆ log log ∆ + log∗ n) time. This is already a significant improvement over the KW algo-
rithm. This improved algorithm is called A2 . (The KW algorithm will be denoted by A1 .)
The algorithm accepts as input a graph G. It starts with computing an O(∆/p)-defective p2 -
coloring ψ of G, where p = ⌊log ∆⌋. Recall that the color classes of ψ induce a partition into
p2 subgraphs G1 , G2 , ..., Gp2 , with maximum degree O(∆/p) = O(∆/ log ∆) each. Next, the
algorithm A2 computes legal colorings of G1 , G2 , ..., Gp2 , in parallel. It does so by assigning
disjoint palettes P1 , P2 , ...., Pp2 to the subgraphs, and employing the KW algorithm for
computing an O(∆/ log ∆)-coloring for each subgraph Gi , i = 1, 2, ..., p2 , in parallel. These
colorings constitute a legal coloring of the entire graph using O(∆/p · p2 ) = O(∆ log ∆) col-
ors. Finally, on its last step, the algorithm A2 reduces the number of colors from O(∆ log ∆)
to (∆ + 1) using the KW iterative procedure. (Recall that the KW iterative procedure
starts from a legal m-coloring, for some m > ∆, and computes a legal (∆ + 1)-coloring in
O(∆ log m ∆ ) time. See Section 3.8.) See Algoritm 6 for the pseudocode of A2 . The proof of
correctness of the algorithm, and its running time analysis, are provided below.
66 6. DEFECTIVE COLORING

Algorithm 6 A2 (G)
1: p := ⌊log ∆⌋
2: ψ := compute an O(∆/p)-defective p2 -coloring of G
3: Let G1 , G2 , ..., Gp2 denote the subgraphs induced by the color classes of ψ
4: for i = 1, 2, ..., p2 , in parallel do
5: ϕi := compute a legal O(∆/p)-coloring of Gi using the KW algorithm
6: end for
7: ϕ := compute a legal O(∆ · p)-coloring from ϕ1 , ϕ2 , ..., ϕp2
8: ϕ′ := invoke the KW iterative procedure on ϕ
9: return ϕ′

Theorem 6.2 Algorithm A2 computes a legal (∆ + 1)-coloring of G in O(∆ log log ∆ +

log∗ n) time.

Proof. First, we prove the correctness of the algorithm. Recall that all vertices know ∆
before the execution starts. Let c be the constant hidden in the O-notation in the defect
parameter in line 2 of the algorithm. The constant c is independent of the input graph,
and thus can be provided to the vertices before the execution starts, as well. Therefore,
in line 5 of the algorithm, for each vertex v ∈ Gi , i = 1, 2, ..., p2 , a color ϕi (v) is com-
puted such that ϕi (v) ∈ {(i − 1) · (c · ⌊∆/p⌋ + 1) + 1, (i − 1) · (c · ⌊∆/p⌋ + 1) + 2, ..., i · (c ·
⌊∆/p⌋ + 1)}, and for each neighbor u of v in Gi , it holds that ϕi (u) 6= ϕi (v). In line 7 a
coloring ϕ of the entire graph is computed, by setting for each v ∈ Gi , ϕ(v) := ϕi (v), for all
i = 1, 2, ..., p2 . The coloring ϕ is legal since for any pair of neighbors u, v, they either belong
to the same set Gi , which implies ϕ(u) = ϕi (u) 6= ϕi (v) = ϕ(v), or belong to distinct sets
Gi and Gj , i 6= j. In the latter case the ranges from which the colors ϕi (u) and ϕj (v) were
selected are disjoint, and thus ϕ(u) 6= ϕ(v) as well. Therefore, ϕ is a legal coloring that
employs ((c · ⌊∆/p⌋ + 1) · p2 ) = O(∆ · p) = O(∆ log ∆) colors. In the last step this coloring
is transformed into a legal (∆ + 1) coloring of G using the KW iterative procedure. This
completes the correctness proof.
Next, we analyze the running time of the algorithm. By Theorem 6.1, line 2 re-
quires O(∆3·ǫ + log∗ n) time. Line 5 invokes the KW algorithm on graphs with maxi-
mum degree O(∆/p) = O(∆/ log ∆). This requires O(∆/ log ∆ · log(∆/ log ∆) + log∗ n) =
O(∆ + log∗ n) time. Line 7 is performed locally without any communication. Line 8 invokes
the KW iterative procedure on a graph with an initial m-coloring, where m = O(∆ log ∆).
The running time of this invocation is O(∆ · log( m ∆ )) = O(∆ log log ∆). Hence, the overall
running time is O(∆ log log ∆ + log∗ n). 2

Next, we build a series of algorithms A3 , A4 , A5 , ... that compute (∆ + 1)-coloring.

Each algorithm Ak , k = 3, 4, 5, ..., improves upon the algorithm Ak−1 . Specifically, for any
constant integer k > 2, the running time of Ak is O(∆ log(k) ∆ + log∗ n). The structure of
6.1. EMPLOYING DEFECTIVE COLORING FOR COMPUTING LEGAL COLORING 67
an algorithm Ak is very similar to that of A2 . The main difference is that instead of using
the KW algorithm in line 5, it invokes the algorithm Ak−1 . In addition, the values of some
parameters are changed appropriately. See the pseudocode of an algorithm Ak below. Its
analysis is provided in the next theorem.

Algorithm 7 Ak (G)
j k
(k−1)
1: p := log ∆
2: ψ := compute an O(∆/p)-defective p2 -coloring of G
3: Let G1 , G2 , ..., Gp2 denote the subgraphs induced by the color classes of ψ
4: for i = 1, 2, ..., p2 , in parallel do
5: ϕi := compute a legal O(∆/p)-coloring of Gi using the algorithm Ak−1
6: end for
7: ϕ := compute a legal O(∆ · p)-coloring from ϕ1 , ϕ2 , ..., ϕp2
8: ϕ′ := invoke the KW iterative procedure on ϕ
9: return ϕ′

Theorem 6.3 For any constant integer k ≥ 2, the algorithm Ak computes a legal (∆ + 1)-
coloring of G in O(∆ log(k) ∆ + log∗ n) time.

Proof. We prove the theorem by induction on k. The base case (k = 2) follows directly from
Theorem 6.2. For the induction step, assume that an algorithm Ak−1 computes a (∆ + 1)-
coloring in O(∆ log(k−1) ∆ + log∗ n) time. Next, we analyze the algorithm Ak . The proof of
correctness for Ak is very similar to the proof of Theorem 6.2. Thus, we present here only the
running time analysis. Line 2 of Algorithm Ak requires O(∆3ǫ + log∗ n) time, by Theorem
6.1. By the induction hypothesis, linej 5 of Ak requires
k O(∆/p · log(k−1) (∆/p) + log∗ n) =
O(∆ + log∗ n) time. (Recall that p = log(k−1) ∆ .) Line 8 of Ak invokes the KW iterative
procedure on an m-colored graph with m = O(∆ · p) = O(∆ · log(k−1) ∆). The running time
(k)
of this invocation is O(∆ · log( m
∆ )) = O(∆ log ∆). Therefore, the overall running time of
the algorithm Ak is O(∆ log(k) ∆ + log∗ n). 2

The series of algorithms A2 , A3 , A4 , ..., Ak can be extended to superconstant values of

k. In particular, for k = ⌈log∗ ∆⌉, the algorithm Ak requires O(∆ + log∗ ∆ log∗ n) time. By
a more sophisticated algorithm, this can be improved to O(∆) + log∗ n. Since this algorithm
is somewhat technically involved, we will not present it here. (The details can be found in
[8].) Instead, we describe an algorithm due to [48] that achieves the same running time,
but employs a different technique. However, it is still based on computation of defective
colorings. It requires computing a (∆/c)-defective O(c2 )-coloring, for a constant c. Observe
that it is possible to achieve such a coloring using Theorem 6.1, within o(∆) + log∗ n time.
68 6. DEFECTIVE COLORING

Algorithm 8 Procedure Delta-Col(G′ )

˜ log ∆)
1: if (∆′ < ∆/ ˜ then
2: ϕ′ := compute a legal (∆′ + 1)-coloring using the KW iterative procedure
3: else
4: d := ⌊∆′ /2⌋
5: ψ := compute a d-defective c-coloring using Theorem 6.4
/* c = O(1) is a universal constant */
6: for all colors i ∈ [c] in parallel do
7: denote by Gi the subgraph induced by all vertices with ψ-color i
8: Delta-Col(Gi ) /* recursive call */
9: end for
10: ϕ := compute a legal c · (d + 1)-coloring from ϕ1 , ϕ2 , ..., ϕc
11: ϕ′ := invoke the KW iterative procedure with input coloring ϕ
12: end if
13: return ϕ′

To this end, one needs to select p to be larger than the constant hidden in the O-notation
of the defect parameter O(∆/p) in Theorem 6.1. We summarize this in the next theorem.
Theorem 6.4 For any constant integer c > 0, a (∆/c)-defective O(c2 )-coloring can be com-
puted in o(∆) + log∗ n time.
The additive term of log∗ n in the running time given in Theorem 6.4 corresponds
to an initial stage of the algorithm for computing defective coloring. This stage computes
a legal O(∆2 )-coloring. In the consequent stages of the algorithm it is used to compute a
(∆/c)-defective O(c2 )-coloring in o(∆)-time. Therefore, if a legal O(∆2 )-coloring is provided
a priori, computing the defective coloring as above requires o(∆) time (rather than o(∆) +
log∗ n time).
Using Theorem 6.4 a legal (∆ + 1)-coloring algorithm that runs in O(∆) + log∗ n
time is obtained in the following way. The algorithm accepts as input the graph G. First, it
computes a (∆/2)-defective O(1)-coloring ψ of G. Then it recursively computes legal (∆/2 +
1)-colorings of the O(1) graphs induced by the color classes of ψ. Next, these colorings are
merged into a unified legal O(∆)-coloring of G. Finally, the number of colors is reduced to
(∆ + 1). This completes the description of the algorithm. Its pseudocode is provided below.
In the pseudocode, ∆ ˜ denotes the maximum degree in the input graph G. ∆′ = ∆(G′ )
denotes (an upper bound on) the maximum degree of the graph G′ in which the procedure
is invoked. (G′ is a subgraph of G. In the first invocation G′ = G and ∆′ = ∆). ˜ Next, we
prove the correctness of the algorithm and analyze its running time.
Theorem 6.5 Procedure Delta-Col invoked on an input graph G with maximum degree ∆
computes a legal (∆ + 1)-coloring of G in O(∆) + log∗ n time.
6.1. EMPLOYING DEFECTIVE COLORING FOR COMPUTING LEGAL COLORING 69
Proof. We start with proving the correctness of the algorithm. The proof is by induction
on ∆. For the base case (∆ = 1), the algorithm computes a legal (∆ + 1)-coloring of G
in line 2 of the algorithm. For the induction step, assume that the algorithm is correct
for any ∆′ < ∆. We prove the correctness for graphs with ∆(G) = ∆ = ∆. ˜ The algorithm
computes a d-defective c-coloring of G in line 5. It induces a partition of G into c subgraphs
G1 , G2 , ..., Gc , each with maximum degree at most d = ∆/2. Then, Procedure Delta-Col
is invoked recursively on these subgraphs in line 8. By the induction hypothesis, it com-
putes legal (∆/2 + 1)-colorings ϕ1 , ϕ2 , ..., ϕc , for G1 , G2 , ..., Gc , respectively. Consequently,
these colorings can be transformed into a legal (c · (∆/2 + 1))-coloring of G, in line 10 of
the algorithm. Then, the number of colors is reduced to (∆ + 1) using the KW iterative
procedure, in line 11. This completes the correctness proof.
Next, we analyze the running time of the algorithm. First, we note that computing
a d-defective c-coloring requires o(∆) + log∗ n only in the first time the computation is
performed. (See Theorem 6.4, and the discussion that follows it.) In the next computations
of defective colorings, the running time becomes o(∆). This is possible since during the
first computation an O(∆ ˜ 2 )-coloring ψ of the input graph is computed in log∗ n + O(1)
time. Given the O(∆ ˜ 2 )-coloring ψ of the input graph we compute an O(∆′2 )-coloring ψ ′
of a subgraph G in O(1) time via the algorithm of Linial [56]. Specifically, ∆′ satisfies
′

∆′ ≥ ∆/˜ log ∆. ˜ Hence ψ can be viewed also as an O(∆′2 log2 ∆′ )-coloring of G′ . Such a
coloring can be converted into an O(∆′2 )-coloring of G′ within O(1) rounds. (See Chapter
3.10.) Therefore, the factor of log∗ n + O(1) appears only in the initial invocation. Thus,
the running time of the algorithm is f (n, ∆) = log∗ n + O(1) + T (∆), where T (∆) is a
recursive function. By lines 5, 8, and 11 of the algorithm, we conclude that T (∆) = o(∆) +
T (∆/2) + O(∆) = T (∆/2) + O(∆), if ∆ ≥ ∆/ ˜ log ∆.
˜ Otherwise, by lines 1-2 it is easy to
˜
verify that T (∆) = O(∆ log ∆) = O(∆). The recursive equation T (∆) = T (∆/2) + O(∆)
solves to T (∆) ˜ = O(∆). ˜ 2

Theorem 6.5 in conjunction with Theorem 6.1 can be used to devise a tradeoff between
the running time and the number of colors in a straightforward way. Specifically, for any
p ≤ ∆1/4 , a legal O(∆ · p)-coloring can be computed in O(∆/p) + log∗ n time. To this end,
compute an O(∆/p)-defective p2 -coloring ϕ′ , in time O(∆3ǫ ) + log∗ n = O(∆3/4 ) + log∗ n.
Then compute a legal O(∆/p)-coloring of each subgraph induced by a color class of ϕ′ .
These computations can be performed for all color classes of ϕ′ in parallel, and using
disjoint color palettes. This step requires O(∆/p) + log∗ n time. As a result a legal O(∆ · p)-
coloring is obtained. The overall running time is O(∆/p + log∗ n). We remark that using
a more sophisticated procedure one can obtain a tradeoff for the entire range 1 ≤ p ≤ ∆.
(See [8, 48].) We summarize this in the next theorem.

Theorem 6.6 For any p, 1 ≤ p ≤ ∆, a legal O(∆ · p)-coloring can be computed in O(∆/p +
log∗ n) time.
70 6. DEFECTIVE COLORING

6.2 DEFECTIVE COLORING ALGORITHMS

In the previous section we demonstrated how a legal coloring can be computed by combining
defective colorings. In this section we describe algorithms for computing defective colorings
from scratch. Combining the algorithms from the previous section with the algorithms from
this section results in an efficient algorithm for computing legal colorings from scratch.
In Section 6.2.1 we present a tool, called Procedure Refine, which transforms one defective
coloring ϕ into another defective coloring ϕ′ . The latter coloring has a slightly larger defect
than ϕ has, but it typically uses much less colors. In Section 6.2.2 Procedure Refine is used
to devise an algorithm for constructing defective colorings from scratch.

6.2.1 PROCEDURE REFINE

Many algorithms for computing a legal (∆ + 1)-coloring employ the following standard
technique. Whenever a vertex is required to select a color it selects a color that is different
from the colors of all its neighbors. Its neighbors select their colors in different rounds. On
the other hand, if one is interested in a defective coloring, a vertex can select a color that is
used by some of its neighbors. Moreover, some neighbors can perform the selection in the
same round. Consequently, the computation can potentially be significantly more efficient
than that of a (∆ + 1)-coloring.
We start with presenting a procedure, called Refine, that accepts as input a graph
with an m-defective γ-coloring ϕ, and a parameter p, 1 ≤ p ≤ ∆, for some integers m, γ,
and p, and computes an (m + ⌊∆/p⌋)-defective p2 -coloring in time O(γ). The procedure em-
ploys acyclic partial orientations. (See Section 3.3 for definitions concerning acyclic partial
orientations.)
While acyclic orientations are useful for computing legal colorings, acyclic partial
orientations are useful for computing defective ones. Specifically, Procedure Refine com-
putes such an orientation, and then uses it for computing a defective coloring. In order to
compute the partial orientation, it orients each edge (u, v) for which ϕ(u) 6= ϕ(v) towards
the endpoint with the smaller ϕ-color. All other edges remain undirected. (These are the
edges that connect vertices with the same ϕ-color.) Denote the resulting orientation by η.
Since not all edges have to be oriented, the length of an acyclic partial orientation may
be significantly smaller than the length of any possible complete orientation of the input
graph. (The length of an orientation is defined in Definitions 3.1 - 3.5.) Consequently, if
it is possible to employ a partial orientation instead of a complete one, then the coloring
computation can be performed much faster.
Once an acyclic partial orientation is obtained, in the way that was described above,
Procedure Refine employs it to computes a new defective coloring ϕ′ . It proceeds in two
stages. In the first stage each vertex v computes a new color ψ(v) from the range [p] =
{1, 2, ..., p} in the following way. Once v receives the color ψ(u) from each of its parents
u, it sets ψ(v) to be the color from [p] that is used by the minimal number of its parents,
 6.2. DEFECTIVE COLORING ALGORITHMS 71
breaking ties arbitrarily. In other words, v selects a color i, such that for every j = 1, 2, ..., p,
it holds that

|{u is a parent of v : ψ(u) = i}| ≤ |{u is a parent of v : ψ(u) = j}| .

In particular, if there is a color in the range [p] that is not used by any parent, then it
is selected. Then v sends its selection ψ(v) to all its neighbors. In the second stage the
orientation is reversed, and each vertex v computes a new color Ψ(v) from the range [p] in
a similar way. Specifically, it waits for all its parents to select a Ψ-color, and then selects a
color which is used by the minimal number of parents. Denote the reversed orientation by
η̄. (Observe that the parents of v in the orientation η̄ are the children of v in the orientation
η.) Then v sends its selection Ψ(v) to all its neighbors.
Once the vertex v has computed both colors ψ(v) and Ψ(v), it sets its final color
ϕ (v) = (Ψ(v) − 1) · p + ψ(v). Intuitively, the color ϕ′ (v) can be seen as a pair (Ψ(v), ψ(v)).
′

This completes the description of Procedure Refine. Next, we show that the procedure is
correct.
Lemma 6.7 The coloring ϕ′ produced by Procedure Refine is an (m + ⌊∆/p⌋)-defective
p2 -coloring.
Proof. First, observe that for each vertex v, it holds that 1 ≤ ψ(v), Ψ(v) ≤ p, and thus,
1 ≤ ϕ′ (v) ≤ p2 . It is left to show that for each vertex v, the number of neighbors u of v
with ϕ′ (u) = ϕ′ (v) is at most (m + ⌊∆/p⌋). Recall that procedure Refine accepts a defective
coloring ϕ as input. For a vertex v ∈ V , denote by S(v) the set of neighbors of v with a
smaller ϕ-color. Denote by G(v) the set of neighbors of v with a greater ϕ-color. Notice
that S(v) and G(v) correspond to the parents and the children of v, respectively, in the
orientation η. Each vertex v has at most m neighbors z such that ϕ(v) = ϕ(z). By the
pigeonhole principle, the number of neighbors u of v with ϕ(u) < ϕ(v) and ψ(u) = ψ(v)
is at most ⌊|S(v)| /p⌋, since v selected ψ(v) to be the color from [p] that is used by the
minimal number of its neighbors from S(v). Similarly, the number of neighbors w of v with
ϕ(w) > ϕ(v) and Ψ(w) = Ψ(v) is at most ⌊|G(v)| /p⌋. Observe that for any neighbor u of v,
if ϕ′ (u) = ϕ′ (v) then ψ(u) = ψ(v) and Ψ(u) = Ψ(v). Consequently, the number of neighbors
u with ϕ′ (u) = ϕ′ (v) is at most (m + ⌊|S(v)| /p⌋ + ⌊|G(v)| /p⌋) ≤ (m + ⌊deg(v)/p⌋) ≤ (m +
⌊∆/p⌋). 2
The two stages of Procedure Refine can be executed in parallel. Thus, Refine can be
executed within γ rounds. This is argued formally in the next lemma.
Lemma 6.8 The time complexity of Procedure Refine is γ.
Proof. We prove by induction on i that after i rounds, i = 1, 2, ..., γ, each vertex with
ϕ(v) ≤ i has selected its color ψ(v). For the base case, consider all the vertices v with ϕ(v) =
1. There are no vertices u with ϕ(u) < 1, and thus, each vertex v with ϕ(v) = 1 selects the
72 6. DEFECTIVE COLORING

color ψ(v) in the first round. Now, for i ≥ 2, assume that after (i − 1) rounds, each vertex
with ϕ(v) ≤ (i − 1) has selected its color ψ(v). Then, by the induction hypothesis, in round
i, for a vertex v with ϕ(v) = i, all the neighbors u of v satisfying ϕ(u) < ϕ(v) = i have
selected their color ψ(u) in round (i − 1) or earlier. Hence, if v has not selected the color
ψ(v) before round i, it necessarily selects it in round i. Therefore, after γ rounds all the
vertices in the graph have selected the color ψ(v) and the first stage is completed. Similarly,
the second stage is completed after another γ rounds. The computation of ϕ′ (v) from ψ(v)
and Ψ(v) is performed immediately after the second stage is finished, and it requires no
additional communication. Finally, note that the two stages can be executed in parallel.
Thus, the running time is γ. 2

For a graph G = (V, E) whose vertices are provided with an m-defective k-coloring,
for some parameters m and k, we say that G is m-defective k-colored.
We summarize this section with the following corollary.

Corollary 6.9 For positive integers γ, m, and p, suppose that Procedure Refine is invoked
on a graph G with maximum degree ∆. Suppose also that G is m-defective γ-colored. Then
the procedure produces an (m + ⌊∆/p⌋)-defective p2 -coloring of G within at most γ rounds.

6.2.2 PROCEDURE DEFECTIVE-COLOR

In this section we describe an algorithm called Procedure Defective-Color. The algorithm
accepts as input a graph G = (V, E), and two integer parameters p, q such that 1 ≤ p ≤ ∆,
log ∆
p2 < q, and q < c′ · ∆2 , for some positive constant c′ > 0. It computes an O( log(q/p 2 ) · ∆/p)-

defective p2 -coloring of G in time O(log∗ n + log(q/p

log ∆
2 ) · q) from scratch. In particular, if we
ǫ 2
set q = ∆ · p for an arbitrarily small positive constant ǫ, we get an O(∆/p)-defective
p2 -coloring algorithm with running time O(log∗ n + ∆ǫ · p2 ). The algorithm starts by com-
puting a legal coloring with a very large number of colors. Next, the algorithm proceeds
in phases. In each phase the number of colors is reduced by a factor of q/p2 . However,
this increases the defect parameter of the coloring by an additive term of ⌊∆/p⌋. Selecting
appropriate parameters for p and q enables us to keep the defect parameter and the running
time in check.
Next, we describe the algorithm in detail. The algorithm starts by computing an
O(∆2 )-coloring of the input graph. This coloring ϕ can be computed in log∗ n + O(1) time
from scratch using the algorithm of Linial [56]. Let c, c > 0, be a constant such that c · (∆2 )
is an upper bound on the number of colors employed. Let h = c · ∆2 /q . (The constant c′
mentioned in the beginning of the section is sufficiently small to ensure that h ≥ 1.) Each
vertex v with 1 ≤ ϕ(v) ≤ h · q joins the set Vj with j = ⌈ϕ(v)/q⌉. Vertices v that satisfy
h · q < ϕ(v) ≤ c · ∆2 join the set Vh . In other words, the index j of the set Vj to which
the vertex v joins is determined by j = min {⌈ϕ(v)/q⌉ , h}. Observe that for every index j,
1 ≤ j ≤ h − 1, the set Vj is colored with exactly q colors, and Vh is colored with q ′ colors
 6.2. DEFECTIVE COLORING ALGORITHMS 73
′
with q ≤ q ≤ 2q. By definition, for each j, 1 ≤ j ≤ h − 1, Vj is 0-defective q-colored (i.e.,
the defect is m = 0 and the number of colors is k = q), and Vh is 0-defective q ′ -colored
(m = 0, k = q ′ ). For each j, 1 ≤ j ≤ h, denote this coloring of Vj by ψj . Then, for each
graph G(Vj ) induced by the vertex set Vj , Procedure Refine is invoked on G(Vj ) with the
parameter p, in parallel for j = 1, 2, .., h. As a result of these invocations, each graph G(Vj )
is now ⌊∆/p⌋-defective p2 -colored. Let ϕ′j denote this coloring. Next, each vertex v selects
a new color ϕ′′ (v) by setting ϕ′′ (v) = ϕ′j (v) + (j − 1) · p2 , where j is the index such that
v ∈ Vj . The number of colors used by the new coloring ϕ′′ is at most h · p2 ≤ c · (∆2 ) · p2 /q.
It follows that the coloring ϕ′′ is a ⌊∆/p⌋-defective (c · (∆2 ) · p2 /q)-coloring of G.
This process is repeated iteratively. On each iteration the vertex set is partitioned
into disjoint subsets Vj , such that in each subset the vertices are colored by at most q
different colors, except one subset in which the vertices are colored by at most 2q colors.
Then, in parallel, the coloring of each subset is converted into a p2 -coloring. Consequently,
in each iteration the number of colors is reduced by a factor of at least q/p2 . (Except for
the last iteration in which the number of colors is larger than p2 but smaller than 2q, and
it is reduced to p2 .) However, for a vertex v, the number of neighbors of v that are colored
by the same color as v, that is, the defect def ϕ (v) of v, may grow by an additive term of
⌊∆/p⌋ in each iteration. The process terminates when the entire graph G is colored by at
most p2 colors. (After logq/p2 (c · ∆2 ) iterations all vertices know that G is colored by at
most p2 colors.) In each iteration an upper bound γ on the number of currently employed
colors is computed. In the last iteration, if γ < q then all the vertices join the same set
V1 , and consequently V1 = V , and Procedure Refine is invoked on the entire graph G. See
Figure 6.1 for an illustration. The pseudo-code of the algorithm is provided below.
74 6. DEFECTIVE COLORING

Figure 6.1: An execution of Procedure Defective-Color with the parameters p and q, such
that q = 3p2 , on an initially (6q)-colored graph G. Each oval represents a subgraph. The range
inside the oval represents the color palette employed by the subgraph. For j, 1 ≤ j ≤ 6, the set
Vj changes after each iteration, and contains all vertices that are currently colored using the
palette {(j − 1) · q + 1, (j − 1) · q + 2, ..., j · q}.
 6.2. DEFECTIVE COLORING ALGORITHMS 75

Algorithm 9 Procedure Defective-Color(p, q)

Algorithm for each vertex v ∈ V
1: ϕ := color G with (c · ∆2 ) colors
2: γ := c · ∆2 /* the current number of colors */
3: i = 0 /* the index the of current iteration */
4: while γ > p2 do
5: if γ < q then
6: j := 1
7: else
8: j := min {⌈ϕ(v)/q⌉ , ⌊γ/q⌋}
9: end if
10: set Vj to be the set of v
11: ψj (v) := ϕ(v) − (j − 1) · q /* ψj (·) is an (i · ⌊∆/p⌋)-defective (2q)-coloring of
G(Vj ) */
12: ϕ′j := Refine(G(Vj ), ψj ,p) /*ϕ′j (·) is an ((i + 1) ⌊∆/p⌋)-defective p2 -coloring of
G(Vj ) */
13: ϕ(v) := ϕ′′ (v) := ϕ′j (v) + (j − 1) · p2
14: γ := (max {⌊γ/q⌋ , 1}) · p2 /* ϕ(·) is an ((i + 1) ⌊∆/p⌋)-defective γ-coloring of G */
15: i := i + 1
16: end while
17: return ϕ

In what follows we prove the correctness of Procedure Defective-Color. We start with

proving the following invariant regarding the variable γ. Let γi denote the value of γ at the
end of the i th iteration. For technical convenience, we define γ0 to be the value of γ at the
beginning of the first iteration.
th
Lemma 6.10 For i = 0, 1, 2, ..., after the i iteration, the number of colors employed by
ϕ is at most γi .

Proof. The proof is by induction on i.

Base (i = 0): In the first step of Procedure Defective-Color, the graph G is colored using
(c · ∆2 ) colors. Therefore, after 0 iterations, the number of colors employed by ϕ is at most
γ 0 = c · ∆2 .
Induction step: By the induction hypothesis, after iteration (i − 1), the number of colors
employed by ϕ is at most γi−1 . In iteration i the vertex set V of G is partitioned into
h = max {⌊γi−1 /q⌋ , 1} disjoint subsets Vj , j = 1, 2, ..., h. Each of these subsets except Vh
is colored with at most q colors. The set Vh is colored with at most 2q colors. Procedure
Refine produces a new coloring in each set Vj such that the number of colors used in the
set Vj is at most p2 , for j = 1, 2, ..., h. Consequently, the number of colors used by ϕ at
76 6. DEFECTIVE COLORING

the end of iteration i is at most (max {⌊γi−1 /q⌋ , 1}) · p2 = γi . (See steps 8, 13, and 14 of
Algorithm 9.) 2
 2 2
By step 14 of Algorithm 9, γi+1 ≤ max γi · p /q, p , for i = 0, 1, 2, ..., and γ0 =
2
c · ∆ . Therefore, 
γi ≤ max c · ∆2 · (p2 /q)i , p2 . (6.1)
Next, we analyze the defect of the coloring produced by Procedure Defective-Color.
Theorem 6.11 Procedure Defective-Color invoked with the parameters p, q, computes an
log ∆ 2
O( log(q/p 2 ) · ∆/p)-defective p -coloring.

Proof.  We2prove by induction on i that after i iterations ϕ(·) is an (i · ∆/p)-defective

(max c · ∆ · (p /q)i , p2 )-coloring of G.
2

Base (i = 0): Observe that a 0-defective (c · ∆2 )-coloring is computed in the first step
of the algorithm. Therefore, before the beginning of the first iteration, ϕ is a 0-defective
(c · ∆2 )-coloring of G.
Induction step: Let ϕ be the coloring produced after  i − 1 iterations. By the induction
hypothesis, ϕ is an ((i − 1) · ∆/p)-defective (max c · ∆2 · (p2 /q)i−1 , p2 )-coloring of G.
In iteration i, the vertex set V of G is partitioned into h = max {⌊γi−1 /q⌋ , 1} disjoint
subsets Vj . If there is only one subset V1 = V , then G(V1 ) = G is colored with at most 2q
colors. Otherwise, each induced graph G(Vj ), 1 ≤ j < h, is colored by q different colors.
The induced graph G(Vh ) is colored by at most 2q colors. Therefore, for each j, 1 ≤ j ≤ h,
the coloring ψj computed in step 11 of the i th iteration is an ((i − 1) · ∆/p)-defective (2q)-
coloring of G(Vj ). In step 12, Procedure Refine is invoked on G(Vj ) with p as input. As
a result, an ((i − 1) · ∆/p + ∆/p)-defective p2 -coloring ϕ′j of G(Vj ) is produced. In other
words ϕ′j is an (i · ∆/p)-defective p2 -coloring of G(Vj ), i.e., def (ϕ′j ) ≤ i · ∆/p. To finish the
proof, we next argue that def (ϕ′′ ) is at most i · ∆/p too. (The coloring ϕ′′ is defined in line
13 of Algorithm 9.)
Consider a vertex v, and a neighbor u of v. First, suppose that v ∈ Vj , u ∈ Vℓ , and
j 6= ℓ. Suppose without loss of generality that j < e. Then
ϕ′′ (v) − ϕ′′ (u) = (ϕ′j (v) − ϕ′ℓ (u)) + (j − ℓ) · p2 ≥ ϕ′j (v) − ϕ′ℓ (u) + p2 .
Since ϕ′j (v) − ϕ′ℓ (u) ≥ −p2 + 1, it follows that ϕ′′ (v) 6= ϕ′′ (u).
Second, consider a neighbor w ∈ Vj of v. If ϕ′j (v) 6= ϕ′j (w) then also
ϕ′′ (v) = ϕ′j (v) + (j − 1) · p2 6= ϕ′′ (w) = ϕ′j (w) + (j − 1) · p2 .
Since def (ϕ′j ) ≤ i · ∆/p, there are at most (i · ∆/p) neighbors w ∈ Vj of v such that ϕ′j (w) =
ϕ′j (v). Consequently, thecoloring ϕ = ϕ′′ that is produced in line 13 of the i th iteration is an
(i · ∆/p)-defective (max c · ∆2 · (p2 /q)i , p2 )-coloring of G. This completes the inductive
log(c·∆2 ) 2
proof. By (6.1) after log(q/p2 ) iterations, ϕ is a ( log(c·∆ ) 2
log(q/p2 ) · ∆/p)-defective p -coloring of G.
2
 6.2. DEFECTIVE COLORING ALGORITHMS 77
2
Procedure Defective-Color starts with computing an O(∆ )-coloring. The algorithm
of Linial [56] computes a (c · ∆2 )-coloring in time log∗ n + O(1). The number of iterations
2
performed by Procedure Defective-Color is at most logq/p2 (c · ∆2 ) = log(c·∆ )
log(q/p2 ) . Each iter-
ation invokes Procedure Refine that requires O(q) time, and performs some additional
computation that requires O(1) time. The running time of Procedure Defective-Color is
given below.

Theorem 6.12 Procedure Defective-Color invoked with parameters p,q, runs in T (n) +
log ∆ 2
O(q · log(q/p 2 ) ) time, where T (n) is the time required for computing O(∆ )-coloring. If

Linial’s algorithm is used for O(∆2 )-coloring, the running time of Procedure Defective-
log ∆ ∗ log ∆ 2
Color is O(q · log(q/p 2 ) ) + log n. It produces an O( log(q/p2 ) · ∆/p)-defective p -coloring.

Observe that by substituting p = ∆ǫ , q = ∆3ǫ , for a sufficiently small constant ǫ > 0,

into Theorem 6.12, we obtain Theorems 6.1 and 6.4. Those theorems, in turn, imply The-
orems 6.5 and 6.6, i.e., that (∆ + 1)-coloring can be computed in O(∆) + log∗ n determin-
istic time, and that an O(∆ · p)-coloring can be computed in O(∆/p + log∗ n) determin-
istic time, for any 1 ≤ p ≤ ∆. Moreover, an O(∆2 )-coloring can, in fact, be computed in
1 ∗
2 log n + O(1) time [74]. Using the algorithm of [74] instead of Linial’s Algorithm [55]
within the above algorithm produces a (∆ + 1)-coloring in O(∆) + 12 log∗ n time.
78

CHAPTER 7

Arbdefective Coloring
In his seminal paper [55] in 1987 Linial devised an O(∆2 )-coloring algorithm that runs in
log∗ n + O(1) time. (See Section 3.10 in the current monograph.) He also raised a major
open question which triggered a lot of research in the area of distributed symmetry breaking.
His question was whether in deterministic polylogarithmic time one can come up with a
coloring algorithm whith significantly less than ∆2 colors. This section is based on the
paper [9] by the authors of this monograph. This paper showed that ∆1+o(1) -coloring can
be computed in deterministic polylogarithmic time (specifically, in O(f (∆) · log ∆ · log n)
time, where f (∆) = ω(1) is an arbitrarily slowly growing function). This result answered
Linial’s question in the affermative. The main technical tool introduced in [9] on our way
to this result was the notion of arbdefective coloring. In this section we describe algorithms
for computing arbdefective colorings, and show how they can be used for producing legal
colorings.

7.1 SMALL ARBORICITY DECOMPOSITION

In this section we discuss a generalization of defective coloring which is called arbdefective
coloring. A b-arbdefective k-coloring is a coloring of the vertices with k colors, such that each
color class induces a subgraph with arboricity at most b. Arbdefective coloring partitions
the input graph into subgraphs of bounded arboriciy, but the maximum degree of these
subgraphs may be unbounded. Nevertheless, one can still efficiently compute legal colorings
of such subgraphs using the algorithms described in Section 5. The challanging task is to
compute appropriate partitions of bounded-arboricity subgraphs. This seems to be a more
difficult task than computing defective coloring. We start with describing an algorithm
for computing an O(a2/3 )-arbdefective O(a1/3 )-coloring. (Later we discuss algorithms that
apply to a wider range of parameters.) This algorithm employs some of the procedures
described in previous sections. In particular, it employs Procedure Defective-Color that
computes O(∆/p)-defective p2 -coloring. But in contrast to the coloring produced by this
procedure, the product of the parameters of the arbdefective coloring is O(a2/3 · a1/3 ) =
O(a). In other words, the product of the parameters of the arbdefective coloring is linear
in a, while the product of parameters of the defective coloring is superlinear in ∆. This
makes arbdefective colorings very useful for efficient computation of legal colorings. In fact,
it turns out that by using arbdefective colorings one can compute a legal coloring much
more efficiently than by using defective ones.
 7.1. SMALL ARBORICITY DECOMPOSITION 79
2/3 1/3
The algorithm for computing an O(a )-arbdefective O(a )-coloring accepts as
input a graph G. The first stage of the algorithm computes an acyclic partial orientation
with certain helpful properties. Specifically, the orientation is sufficiently short, and has
bounded deficit. This stage is called Procedure Partial-Orientation. (See Algorithm 10 for
its pseudocode. The argument t is set as a1/3 .) Procedure Partial-Orientation starts with
computing an H-partition H = H1 , H2 , ..., Hℓ of G, ℓ = O(log n), with degree A = O(a).
Recall that each subgraph G(Hi ), i ∈ {1, 2, .., ℓ}, has maximum degree at most A. (See
Lemma 5.4.) Next, for i = 1, 2, ..., ℓ in parallel, it computes an O(a2/3 )-defective O(a2/3 )-
coloring ψi of G(Hi ). (To this end, it invokes Procedure Defective-Color on G(Hi ) with the
parameters p = a1/3 , q = a2/3+ǫ , for an arbitrarily small positive constant ǫ. See Theorem
6.12.)
The colorings ψi are used to compute an acyclic partial orientation µ of the input
graph as follows. Each edge that connects endpoints from distinct H-sets is oriented towards
the endpoint with greater H-index. Each edge that connects endpoints from the same H-
set, but with distinct colors, is oriented towards the endpoint with the greater color. The
rest of the edges, that connect endpoints from the same set and with the same color, remain
unoriented. This completes the description of Procedure Partial-Orientation.

Algorithm 10 Procedure Partial-Orientation(G, t)

1: H1 ,H2 ,...,Hℓ := an H-partition of G.
2: for i = 1, 2, ..., ℓ in parallel do
3: compute an ⌊a/t⌋-defective O(t2 )-coloring ψi of G(Hi ).
4: end for
5: for each edge e = (u, v) in E in parallel do
6: if u and v belong to different H-sets then
7: orient e towards the endpoint with greater H-index.
8: else
9: /* u, v ∈ Hi for some i, 1 ≤ i ≤ ℓ */
10: if u and v have different colors then
11: orient e towards the endpoint with greater ψi -color.
12: end if
13: end if
14: end for

The orientation
  produced by invoking the procedure on the input graph G, and the
parameter t = a1/3 , has out-degree O(a) (by Lemma 5.4) and length O(a2/3 · log n) (as
we shortly prove). In addition, it has another helpful property. The number of unoriented
edges connected to each vertex, that is, the maximum deficit is bounded. (See Definition
3.5 (3).) Since each vertex v ∈ V has at most O(a2/3 ) neighbors in the same H-set Hi with
80 7. ARBDEFECTIVE COLORING

the same ψi -color, the deficit of the orientation µ which was obtained from the colorings
ψi by Algorithm 10 is O(a2/3 ).
Next, we analyze the length of µ. To prove that the length of µ is O(a2/3 log n)
consider the graph G′ which is obtained by removing all unoriented edges from G. For an
index i ∈ {1, 2, ..., ℓ}, for each vertex v ∈ Hi , consider the ordered pair hψi (v), ii as the color
of v in G′ . Then G′ is colored legally using O(a2/3 log n) colors. Denote this coloring by
ρ. Observe that µ is an induced orientation of the coloring ρ. Thus, by Property 3.4, the
length of µ is O(a2/3 log n). For future reference we summarize the properties of µ below.
Corollary 7.1 Theacyclic partial orientation µ which was produced by Algorithm 10 in-
voked with t = a1/3 has out-degree A = O(a), length ℓ = O(t2 · log n) = O(a2/3 log n), and
deficit d = O(a/t) = O(a2/3 ).
Once a partial orientation µ has been computed, it is used for computing an O(a2/3 )-
arbdefective O(a1/3 )-coloring ϕ. To this end each vertex v selects its color
 ϕ(v) once all
its parents have done so. It selects a color from the range {1, 2, ..., a1/3 }, which is used
by the minimum number of parents. This completes the description of the algorithm.
  Its
pseudocode is provided below. (The parameters t and k are set to t = k = a1/3 .) Next
we prove its correctness.

Algorithm 11 Procedure Arbdefective-Coloring(G, k, t)

1: µ = Partial-Orientation(G, t)
2: once all the parents u of v with respect to µ have selected a color ϕ(u) do
v selects a color ϕ(v) from the palette {1, 2, ..., k} which is used by the minimum number
of parents of v

Lemma
 1/37.2
 The coloring
 1/3  ϕ produced by the above algorithm invoked with the parameters
k= a and t = a is an O(a )-arbdefective O(a1/3 )-coloring.
2/3

Proof. The number of colors used by ϕ is at most k = t = O(a1/3 ). For any i ∈ {1, 2, ..., t},
consider the subgraph Gi of G induced by all vertices v with ϕ(v) = i. We need to prove
that a(Gi ) = O(a2/3 ), for all i = {1, 2, ..., t}. To this end we first note that for each vertex
v ∈ V , the number of parents of v in G (under the orientation µ) that have the same ϕ-color
as that of v is at most O(a2/3 ). Indeed, the out-degree of µ is A = O(a), and each vertex
v selects a color ϕ(v) = i ∈ {1, 2, ..., t} that is used by the minimum number of parents.
Therefore, by pigeonhole principle, v has at most O(A/t) = O(a2/3 ) parents (under µ) in
G with the same ϕ-color as that of v.
Observe that v ∈ V (Gi ). Although v has O(a2/3 ) parents under µ in G, note that µ
is a partial orientation. Therefore, it may leave some edges incident on v in Gi unoriented.
Next we show that these edges can also be oriented while preserving an upper bound of
O(a2/3 ) on the maximum out-degree.
 7.2. EFFICIENT COLORING ALGORITHMS 81
Consider the orientation µ restricted to the subgraph Gi . The number of parents
under µ in Gi of a vertex v ∈ Gi is O(a2/3 ). Denote be Ei′ the set of edges of Gi that
are oriented by µ, and by Ei′′ the set of edges of Gi which are not oriented. Consider the
graph G′i = (V, Ei′ ). The orientation µ restricted to G′i is an acyclic complete orientation
with out-degree O(a2/3 ). In other words, each vertex in G′i has O(a2/3 ) parents under µ.
Therefore, the arboricity of G′i is O(a2/3 ). On the other hand, the graph G′′i = (V, Ei′′ )
consists of all unoriented edges of Gi with respect to the restriction of the orientation µ
to Gi . Therefore, each unoriented edge of Gi is also unoriented in G. Recall that µ has
deficit d = O(a2/3 ). Therefore, each vertex in G belongs to at most d unoriented edges.
Consequently, each vertex in Gi belongs to at most d unoriented edges of Gi as well.
Therefore, the maximum degree of G′′i , which includes only unoriented edges, is also at
most d. Consequently, a(G′′i ) ≤ ∆(G′′i ) ≤ d = O(a2/3 ). Therefore, the arboricity of G′i ∪ G′′i
is O(a2/3 ) · 2 = O(a2/3 ). Since E(Gi ) = Ei′ ∪ Ei′′ , it follows that a(Gi ) = O(a2/3 ). 2
Lemma 7.3 An O(a2/3 )-arbdefective O(a1/3 )-coloring of a graph G with arboricity a can
be computed within O(a2/3+ǫ · log n) time, for an arbitrarily small positive constant ǫ.
Proof. The first stage of Algorithm 11 involves invoking Procedure Partial-Orientation,
which, in turn, invokes Procedure Partition and Procedure Defective-Color. Procedure Par-
tition requires O(log n) time. (See Theorem 5.5.) Procedure Defective-Color invoked with
∗
q = a2/3+ǫ , p = a1/3 , requires O(q · loglogq/p
a
2 + log n) = O(a
2/3+ǫ
+ log∗ n) time. (See The-
orem 6.12.) The second stage employs the partial orientation µ that was computed in the
first stage, for computing the coloring ϕ. The running time depends linearly on the length
of the orientation. Therefore, the running time of the second stage is O(a2/3 log n). Hence,
the overall running time is O(a2/3+ǫ · log n). 2
Once an O(a2/3 )-arbdefective O(a1/3 )-coloring ϕ is computed, it can be used for obtaining
a legal coloring. Specifically, ϕ partitions the input graph G into subgraphs G1 , G2 , ..., Gt ,
each of arboricity O(a2/3 ). Therefore, for 1 ≤ i ≤ t in parallel, Gi can be colored with
O(a2/3 )-colors within O(a2/3 log n) time, by Corollary 5.15. By using t = O(a1/3 ) unique
palettes of size O(a2/3 ) each for G1 , G2 , ..., Gt , a legal O(a)-coloring of the input graph G is
obtained. To summarize, an O(a)-coloring can be computed from scratch within O(a2/3+ǫ ·
log n) time, for an arbitrarilly small positive constant. Note that this is already a significant
improvement over the bound O(a · log n). (See Theorem 5.15.)

7.2 EFFICIENT COLORING ALGORITHMS

In this section we dicuss how to improve further the running time of the algorithm that
computes a legal O(a)-coloring. Before we describe the improved algorithm, we analyze the
performance of Procedure Arbdefective-Coloring in the general
 scenario of accepting any
1/3
positive parameters k, t, rather then fixing k = t = a . (See Algorithm 11.) As a first
step, we generalize Corolary 7.1.
82 7. ARBDEFECTIVE COLORING

Figure 7.1: A directed path P = (v11 , v12 , ..., vℓ4 ) with respect to the orientation produced
by Algorithm 10. In this example each Hi is colored with 4 colors. For all i ∈ {1, 2, ..., ℓ},
j ∈ {1, 2, 3, 4}, vij is colored by j. P contains at most ℓ − 1 = O(log n) edges that cross between
different Hi ’s.

Lemma 7.4 Let ǫ be an arbitrarily small positive constant. Procedure Partial-Orientation

invoked on a graph G and an integer parameter t > 0 produces an acyclic orientation µ of
out-degree ⌊(2 + ǫ) · a⌋, length O(t2 · log n), and deficit at most ⌊a/t⌋. The running time of
the procedure is O(log n).
Proof. The out-degree of the oreintation µ is at most A = ⌊(2 + ǫ) · a⌋, by Lemma 5.4.
Next, we analyze the length of the orientation µ. Consider a directed path (oriented con-
sistently with respect to µ) in a subgraph G(Hi ), 1 ≤ i ≤ ℓ. The length of this path is at
most the number of colors used in the defective coloring ψi of G(Hi ), which is O(t2 ). Now
consider a directed path P in the graph G with respect to the orientation µ. The path may
contain up to O(log n) edges that cross between different H-sets. Between any pair of such
edges in the path, there are up to O(t2 ) consequent edges whose endpoints belong to the
same H-set. Hence, the length of a directed path P in G is O(t2 log n). (See Figure 7.1.)
For analyzing the deficit, observe that for every vertex v ∈ Hi , for some i, 1 ≤ i ≤ ℓ, the
number of edges which are not oriented by µ and incident to v is at most the defect of
the coloring ϕi of Hi . Indeed, the only edges incident to v that are left unoriented by the
procedure are edges (v, u) with v, u ∈ Hi and ϕi (u) = ϕi (v). Therefore the deficit of µ is at
most ⌊a/t⌋.
Next, we analyze the running time of the procedure. Procedure Partial-Orientation
starts with computing an H-partition. This step requires O(log n) time. For the step that
computes an ⌊a/t⌋-defective O(t2 )-coloring of a graph G(Hi ) that has maximum degree
A = O(a), we use an algorithm by Kuhn. (Theorem 4.9 in [48].) This algorithm requires
O(log∗ n) time. Alternatively, if t is reasonably small (i.e., t < log1/2−η n, for some small
 7.2. EFFICIENT COLORING ALGORITHMS 83
2+η
constant η > 0), one can also use the algorithm from Theorem 6.12 with p = t, q = t .
The running time of this step is O(t2+η + log∗ n) = o(log n). Other steps require O(1) time.
We remark that without using the algorithm of [48], the running time of the procedure
becomes O(t2+η + log n) (instead of O(log n)). This is also sufficient for deriving main
results of this section. 2
Corollary 7.5 Procedure Arbdefective-Coloring invoked on a graph G and two positive
integer parameters k and t computes an ⌊a/t + (2 + ǫ) · a/k⌋-arbdefective k-coloring in time
O(t2 log n).
Proof. By Lemma 7.4, the orientation µ which is returned in step 1 of Procedure
Arbdefective-Coloring is a partial orientation with length ℓ = O(t2 · log n), out-degree
m = ⌊(2 + ǫ) · a⌋, and deficit τ ≤ ⌊a/t⌋. Consider the coloring ϕ returned by step 2 of
the procedure. The arboricity of a subgraph induced by a color class i, 1 ≤ i ≤ k, of ϕ
is at most ⌊m/k⌋ + τ . (Notice that µ is acyclic, and each vertex has at most ⌊m/k⌋ par-
ents with its color, and at most τ unoriented edges incident on it. Now the arboricity
bound follows similarly to the proof jof Lemma 7.2.) Hence,
k the arbdefective coloring ϕ
⌊(2+ǫ)·a⌋
has arbdefect at most ⌊τ + ⌊m/k⌋⌋ = ⌊a/t⌋ + k ≤ ⌊a/t + (2 + ǫ) · a/k⌋. Step 2 re-
quires O(ℓ) = O(t2 · log n) time. The invocation of Procedure Partial-Orientation requires,
by Theorem 7.4, O(log n) time. Hence the overall running time of Procedure Arbdefective-
Coloring is O(t2 · log n) + O(log n) = O(t2 · log n). 2
Now we are ready to describe the improved algorithm for O(a)-coloring. The main
idea of the improved algorithm is invoking Procedure Arbdefective-Coloring several times.
Since Procedure Arbdefective-Coloring produces subgraphs of smaller arboricity than that
of the input graph, it can be invoked again on the subgraphs, producing a refined decompo-
sition, in which each subgraph has even smaller arboricity.
  For example, invoking the pro-
cedure on a graph G with the parameters k = t = a1/6 , results in an O(a5/6 )-arbdefective
O(a1/6 )-coloring. Invoking the Procedure Arbdefective-Coloring with the same parameters
again on all the O(a1/6 ) subgraphs induced by the initial arbdefective coloring results in an
O(a2/3 )-arbdefective O(a1/6 )-coloring of each subgraph. If distinct palettes are used for each
subgraph, the entire graph is now colored with an O(a2/3 )-arbdefective O(a1/3 )-coloring.
The running time of this computation is O(t2 · log n) = O(a1/3 log n). This computation is
much faster than 1/3asingle invocation of Procedure Arbdefective-Coloring with the param-
eters k = t = a , even though the latter invocation yields the same (up to constant
factors) results. However, to obtain a legal coloring of the original graph G, each subgraph
still has to be colored legally. Given an O(a2/3 )-arbdefective O(a1/3 )-coloring π, we can con-
vert it into a legal O(a)-coloring within additional O(a2/3 log n) time. (This is accomplished
by O(a2/3 )-coloring each of the O(a1/3 ) subgraphs induced by color classes of π.) To speed
up this computation, the arboricity of all subgraphs has to be decreased. Therefore, we need
to invoke Procedure Arbdefective-Coloring more times to achieve an o(a2/3 )-arbdefective
84 7. ARBDEFECTIVE COLORING
 
coloring. Indeed, applying Procedure Arbdefective-Coloring with k = t = a1/6 on each of
√ √
the O(a1/3 ) subgraphs produces an O( a)-arbdefective O( a)-coloring of the entire input
√
graph. This, in turn, directly gives rise to an O(a)-coloring within O( a · log n) time.
We employ this idea in the following algorithm called Procedure Legal-Coloring. The
procedure receives as input a graph G and a positive integer parameter p. Procedure Legal-
Coloring proceeds in phases. In the first phase Procedure Arbdefective-Coloring is invoked
on the input graph G with the parameters k := p and t := p. Consequently, a decomposition
into p subgraphs is produced, in which each subgraph has arboricity O(a/p). In each of the
consequent phases Procedure Arbdefective-Coloring is invoked in parallel on all subgraphs
in the decomposition that was created in the previous phase. As a result, a refinement of the
decomposition is produced, i.e., each subgraph is partitioned into p subgraphs of smaller
arboricity. Consequently, after each phase, the number of subgraphs in G grows by a factor
of p, but the arboricity of each subgraph decreases by a factor of Θ(p). Hence, the product
of the number of subgraphs and the arboricity of subgraphs remains O(a) after each phase.
(As long as the number of phases is constant.) Once the arboricities of all subgraphs become
small enough, Lemma 5.15 is used for a fast parallel coloring of all the subgraphs, resulting
in a unified legal O(a)-coloring of the input graph.
 7.2. EFFICIENT COLORING ALGORITHMS 85

Algorithm 12 Procedure Legal-Coloring(G, p)

1: G1 := G
2: α := a(G1 ) /* a(G) is assumed to be known to all vertices */
3: G := {G1 } /* The set of subgraphs */
4: while α > p do
5: Ĝ := ∅ /* Temporary variable for storing refinements of the set G */
6: for each Gi ∈ G in parallel do
7: G′1 , G′2 , ..., G′p := Arbdefective-Coloring(Gi , k := p , t := p)
/* G′j is the subgraph of Gi induced by all the vertices that are assigned the color
j by the arbdefective coloring */
8: for j := 1, 2, ..., p in parallel do
9: z := (i − 1) · p + j /* Computing a unique index for each subgraph */
10: Ĝz := G′j
11: Ĝ := Ĝ ∪ {Ĝz }
12: end for
13: end for
14: G := Ĝ
15: α := ⌊α/p + (2 + ǫ) · α/p⌋
/* The new upper bound for the arboricity of each of the subgraphs */
16: end while
17: A := ⌊(2 + ǫ)α⌋ + 1
18: for each Gi ∈ G in parallel do
19: color Gi legally using the palette {(i − 1) · A + 1, (i − 1) · A + 2, ..., i · A}
/* Using Lemma 5.15 */
20: end for

Let η be an arbitrarily small positive constant. We show that invoking Procedure
Legal-Coloring on G with the input parameter p := aη/2 results in an O(a)-coloring in
O(aη log n) time. The following lemma constitutes the proof of correctness of the algorithm.
We assume without loss of generality that the arboricity a is sufficiently large to
guarantee that p ≥ 16. (Otherwise, it holds that a ≤ 172/η , i.e., the arboricity is bounded
by a constant. In this case, by Lemma 5.15, one can directly compute an O(1)-coloring in
O(log n) time).
Let αi and Gi denote the values of the variables α and G, respectively, in the end of
iteration i of the while-loop of Algorithm 12 (lines 4-16).

Lemma 7.6 (1) (Invariant for line 16 of Algorithm 12) In the end of iteration i of the
while-loop, i = 1, 2, ..., each graph in the collection Gi has arboricity at most αi .  
(2) The while-loop runs for a constant number of iterations. (Assuming that p = aη/2 .)
86 7. ARBDEFECTIVE COLORING

Specifically, the number of iterations is at most 4/η.

(3) For i =1,2,..., after i iterations, it holds that αi · |Gi | ≤ (3 + ǫ)i · a.

Proof. The proof of (1): The proof is by induction on the number of iterations. For
the base case, observe that after the first iteration, G contains at most p subgraphs pro-
duced by Procedure Arbdefective-Coloring. The arboricity of each subgraph is at most
⌊a/t + (2 + ǫ) · a/k⌋ = ⌊a/p + (2 + ǫ) · a/p⌋ = α1 .
For the inductive step, consider an iteration i, i ≥ 2. By the induction hypothesis, each
subgraph in Gi−1 has arboricity at most αi−1 . During iteration i, Procedure Arbdefective-
Coloring is invoked on all subgraphs in Gi−1 . Consequently, Gi contains new subgraphs,
each with arboricity at most ⌊αi−1 /p + (2 + ǫ) · αi−1 /p⌋, which is exactly the value αi of α
in the end of iteration i. (See line 15 of Algorithm 12.)
The proof of (2): The variable α is initialized as a. In each iteration the variable α
is decreased by a factorof atleast b = p/(3 + ǫ). Hence, the number of iterations is at most
logb a. Recall that p = aη/2 . For any 0 < ǫ < 1/2, and a sufficiently large a, it holds that

log a log a 2/η · log aη/2

logb a = ≤ = ≤ 4/η.
log(p/(3 + ǫ)) log( 14 aη/2 ) log aη/2 − 2

The proof of (3): The correctness of this assertion follows directly from the fact
that in each iteration the number |G| of subgraphs grows by a factor of p, and the arboricity
of each subgraph decreases by a factor of at least p/(3 + ǫ). 2
The next theorem follows from Lemma 7.6.

Theorem 7.7 Invoking  Procedure Legal-Coloring on a graph G with arboricity a with the
η/2
parameter p = a for a positive constant η < 1, computes a legal O(a)-coloring of G
within O(aη · log n) time.

Proof. We first prove that the coloring is legal. Observe that the selection of unique indices
in line 9 guarantees that any two distinct subgraphs that were added to the same set Ĝ are
colored using distinct palettes. In addition, in each iteration each vertex belongs to exactly
one subgraph in G. Consequently, once the while-loop terminates, each vertex v belongs to
exactly one subgraph in G. Let Gi ∈ G be the subgraph that contains v. Let α′ denote the
value of α on line 17 of Algorithm 12, i.e., right after the while-loop. As we have seen, the
arboricity of Gi is at most α′ . Hence, Gi is colored legally using a unique palette containing
A = ⌊(2 + ǫ)α′ + 1⌋ colors. Consequently, the color of v is different from the colors of all its
neighbors, not only in Gi , but in the entire graph G.
Now we analyze the number of colors in the coloring. By Lemma 7.6, the number of
colors employed is (⌊(2 + ǫ)α′ ⌋ + 1) · |G| ≤ (3 + ǫ)c · a, for some explicit constant c. (For a
sufficiently large a, the appropriate constant is c = 4/η + 1.) Hence, the number of employed
colors is O(a).
 7.2. EFFICIENT COLORING ALGORITHMS 87
Next, we analyze the running time of Procedure Legal-Coloring. By Lemma 7.6(2),
during the execution of Procedure Legal-Coloring, the Procedure Arbdefective-Coloring is
invoked for a constant number of times. Note also that each time it is invoked with the same
values of the parameters t = k = p = aη/2 . Hence, by Corollary 7.5, executing the while-
loop requires O(t2 log n) = O(aη log n) time. By Lemma 5.15, the additional time required
for coloring all the subgraphs in step 19 of Algorithm 12 is O(p log n) = O(aη/2 log n). (By
the termination condition of the while-loop (line 4), once the algorithm reaches line 19, it
holds that α ≤ p.) Therefore, the total running time is O(aη log n). 2
Theorem 7.7 implies that for the family of graphs with polylogarithmic (in n) ar-
′
boricity, an O(a)-coloring can be computed in time O((log n)1+η ), for an arbitrarily small
positive constant η ′ . In the case of graphs with superlogarithmic arboricity, even better
results than those that are given in Theorem 7.7 can bejachieved. In this case one can exe-
′ k
aη
cute Procedure Legal-Coloring with the parameter p = log n . Since a is superlogarithmic
′
in n, and η ′ > 0 is a constant, it holds that p > aη /2 , for a sufficiently large n. Therefore,
Procedure Legal-Coloring executes its loop for a constant number of times. Consequently,
the number of colors employed is still O(a). The running time is the sum of running time of
Procedure Arbdefective-Color and the running time of computing legal colorings of graphs
′ ′
a2η aη 2η ′
of arboricity at most p, which is O( log 2 n · log n + log n · log n) = O(a ). If we set η ′ = η/2,
η
the running time becomes O(a ). We summarize this result in the following corollary.

Corollary 7.8 Let η be an arbitrarily small constant. For any graph G, a legal O(a)-
coloring of G can be computed in time O(aη + (log n)1+η ).

Next, we demonstrate that one can trade the number of colors for time. Specifically,
we show that if one is allowed to use slightly more than O(a) colors, the running time
can be bounded by polylog(n), for all values of arboricity a. To this end we select the
parameter p to be polylogarithmic in a. With this value of p the running time O(p log n) of
the coloring step in line 19 of Algorithm 12 becomes polylogarithmic. Moreover, setting the
parameters t and k to be polylogarithmic in a results in a polylogarithmic running time of
Procedure Arbdefective-Coloring. (By Corollary 7.5 the running time of a single invocation
of Procedure Arbdefective-Coloring is O(t2 · log n).) The number of iterations of the while-
loop is O(logp a). Consequently, the total running time is also polylogarithmic. However,
the number of iterations becomes superconstant. Hence the number of colors grows beyond
O(a). The specific parameters we select are p = k = t = f (a)1/2 , for an arbitrarily slow-
growing function f (a) = ω(1). The results of invoking Procedure Legal-Coloring with these
parameters are given below.

Theorem 7.9 Invoking Procedure Legal-Coloring with the parameter p = f (a)1/2 , f (a) =
ω(1) as above, requires O(f (a) log a log n) time. The resulting coloring employs a1+o(1) col-
ors.
88 7. ARBDEFECTIVE COLORING

Proof. Set b = p/(3 + ǫ). The number of iterations is at most logb a = O( loglogf (a)
a
). Each
iteration requires O(p2 log n) = O(f (a) log n) time. Hence the running time of Procedure
Legal-Coloring is
f (a)
logb a · O(f (a) log n) = O( log a log n).
log f (a)
By Lemma 7.6(3), the total number of employed colors is at most

a · (3 + ǫ)O(log a/ log f (a)) = a1+O(1/ log f (a)) = a1+o(1) .

2
More generally, as evident from the above analysis, the running time of Algorithm 12
is O(p2 logp a log n), and the number of colors used is 2O(logp a) · a. Another noticeable point
on the tradeoff curve is on the opposite end of the spectrum, i.e., p = C, for some sufficiently
large constant C. (The constant need to be larger than 16. See the discussion preceding
′
Lemma 7.6.) Here the tradeoff gives rise to a1+C ·(1/ log C) -coloring in O(log a log n) time,
for some fixed constant C ′ . (The constant C ′ does not depend on C, and thus, log C can
be made arbitrarilly larger than C ′ .)

Corollary 7.10 For an arbitrarily small constant η > 0, Procedure Legal-Coloring invoked
with p = 2O(1/η) produces an O(a1+η )-coloring in O(log a log n) deterministic time.

Corollary 7.10 also implies that any graph G for which there exists a constant ν > 0
such that a ≤ ∆1−ν can be colored with o(∆) colors in O(log a log n) time. This goal is
2
achieved by computing an O(a1+ν )-coloring of the input graph G. Since a1+ν ≤ ∆1−ν , this
is an o(∆)-coloring of G. Therefore, Corollary 7.10 gives rise to a deterministic polylogarith-
mic (∆ + 1)-coloring algorithm for a very wide family of graphs. This fact is summarized
in the following corollary.

Corollary 7.11 For the family of graphs with arboricity a ≤ ∆1−ν , for an arbitrarily small
constant ν, one can compute (∆ + 1)-coloring within O(log a log n) deterministic time.

Also, since a ≤ ∆, Corollary 7.10 implies that an O(∆1+η )-coloring can be computed
in O(log ∆ log n) deterministic time, for an arbitrarily small constant η > 0. Similarly, The-
orem 7.9 implies that ∆1+o(1) -coloring can be computed in O(f (∆) log ∆ log n) time, for an
arbitrarily slowly growing function f = ω(1). These results from [9] answer in the affirma-
tive an open question of Linial [55]. (See the discussion in the beginning of this section.)
 89

CHAPTER 8

Edge-Coloring and Maximal

Matching
In this section we explore colorings of the edge-set of a graph. Since an edge-coloring of a
graph G can be computed using a vertex coloring of the line-graph L(G), all algorithms
described in the previous sections for vertex-coloring can be used for computing edge-
colorings as well. However, line graphs have some special properties that are absent in
general graphs. These properties allow for more efficient computation of vertex-coloring of
line graphs, which, in turn, gives rise to efficient edge-coloring algorithms on general graphs.
These algorithms are the subject of the current chapter. The algorithms in Section 8.1 are
due to Panconesi and Rizzi [68]. The algorithms in Section 8.2 are from [10].

8.1 EDGE-COLORING AND MAXIMAL MATCHING USING

FOREST-DECOMPOSITION

We start with describing a (2∆ − 1)-edge-coloring distributed algorithm for oriented trees
(due to [68]). Next it will be used as a building block for computing edge-colorings of
general graphs. The algorithm for oriented trees is called Procedure Tree-Edge-Color. It
accepts as input an oriented tree T = (V, E). Each vertex v ∈ V holds a list lv of colors
that are forbidden for edges adjacent on v. Initially, lv = ∅ for all v ∈ V . The procedure
starts with computing a 3-vertex-coloring of T using the algorithm of Cole and Vishkin
[18]. Then it proceeds in three phase. In phase i, i = 1, 2, 3, all vertices v ∈ V colored by i,
in parallel, assign colors ϕ to edges (v, w) incident on them which connect them with their
children w. A color for an edge (v, w) is selected from the pallete [2∆ − 1] \ (lv ∪ lw ). The
colors are selected such that for each pair of children w,w′ of v, ϕ(v, w) 6= ϕ(v, w′ ). Then
all vertices v ∈ V update their lists lv to contain the colors of all edges incident on v that
have already been colored. This completes the description of the algorithm. Its pseudocode
is provided below.
90 8. EDGE-COLORING AND MAXIMAL MATCHING

Algorithm 13 Procedure Tree-Edge-Color(T )

An algorithm for each vertex v ∈ V :
1: ψ := 3-vertex-coloring of T
2: for i := 1, 2, 3 do
3: if ψ(v) = i then
4: for each child w of v do
5: /* Iterations are performed sequentially, but within a single round (locally) */
6: ϕ(v, w) := a color from [2∆ − 1] \ (lv ∪ lw )
7: lv = lv ∪ {ϕ(v, w)}
8: end for
9: for each child w of v, in parallel do
10: send ϕ(v, w) to w
11: end for
12: end if
13: if v receives a color ϕ(u, v) from its parent u then
14: lv = lv ∪ {ϕ(u, v)}
15: end if
16: send lv to all neighbors
17: end for

Lemma 8.1 Procedure Tree-Edge-Color computes a legal (2∆ − 1)-edge-coloring of an ori-

ented tree T .

Proof. First we show that each edge e = (v, w) ∈ E is assigned a color from [2∆ − 1]
during an execution of the algorithm. Suppose without loss of generality that v is the
parent of w. In round i = ψ(v) ∈ [3] the edge e is assigned a color. Notice that the palette
[2∆ − 1] \ (lv ∪ lw ) is not empty, since lv and lw contain the colors assigned to edges incident
on v and w, respectively. Thus |lv | ≤ ∆ − 1 and |lw | ≤ ∆ − 1. (Because at the time of
selection of the color of (v, w), each of the vertices v and w have at most ∆ − 1 colored edges
incident on them.) Therefore, |[2∆ − 1] \ (lv ∪ lw )| ≥ 1, and so there exists an available color
for e.
Next, we show that the coloring is legal. Let e = (v, w), e′ = (v, u) be a pair of edges
that share a common vertex v. If v is the parent of w and u, then e and e′ are assigned
distinct colors during an execution of the loop in lines 4-8. Otherwise, either v is the child
of w, or v is the child of u. Suppose without loss of generality that the latter is the case.
Then w is the child of v. Consequently, e and e′ are assigned colors in distinct phases.
(Because ψ(u) 6= ψ(v), u is the parent of v, and v is the parent of w.) Suppose without loss
of generality that the color of e′ is selected in a later phase. Then ϕ(e′ ) is selected from the
palette [2∆ − 1] \ (lv ∪ lu ), where ϕ(e) ∈ lv . Therefore, ϕ(e′ ) 6= ϕ(e). 2
8.1. EDGE-COLORING AND MAXIMAL MATCHING USING FOREST-DECOMPOSITION 91
∗
Lemma 8.2 The running time of Procedure Tree-Edge-Color is log n + O(1).
Proof. The first step that computes 3-vertex-coloring requires log∗ n + O(1) time. Next,
we show that each of the three phases of the algorithm (lines 2 - 17) can be performed
within a constant number of rounds. In the beginning of a phase i, each vertex v knows
the sets lw of all its neighbors w that were computed in previous phases. These sets do not
change during the execution of the loop (lines 4 - 8), because ψ(w) 6= i for all neighbor w of
v. Therefore, the loop can be performed locally. Hence, the entire phase can be implemented
within a single round. Thus, the overall running time is log∗ n + O(1). 2
Procedure Tree-Edge-Color can be extended to work on an oriented forest in a straightfar-
ward way. Simply invoke procedure Tree-Edge-Color in all the trees of the forest in parallel.
Obviously, the resulting coloring is a legal (2∆ − 1)-edge coloring of the forest, since edges
from different forests do not share common vertices. The running time of the algorithm on
forests remain log∗ n + O(1). We call the extended algorithm Procedure Forest-Edge-Color.
Procedure Tree-Edge-Color can be also extended to compute a maximal matching
(henceforth, MM). Like Procedure Tree-Edge-Color, the modified procedure, called Tree-
MM, also starts with computing a 3-vertex-coloring ψ of T . Then it proceeds in 3 phases,
and in phase i = 1, 2, 3 the vertices v with ψ(v) = i are active. In phase i, i ∈ [3], vertices v
with ψ(v) = i decide the status of their descending edges (v, u). (We say that the edge (v, u)
is descending if v is the parent of u.) Like in Procedure Tree-Edge-Color, this is done locally
sequentially by v. Specifically, if v is unmatched then it picks an arbitrary unmatched child
u of v (if exists), and inserts the edge (v, u) into the matching. Then v and u infrom their
neighbors that they became matched. The analysis of Procedure Tree-MM is analogous to
that of Procedure Tree-Edge-Color. The running time of both procedures is log∗ n + O(1).
It also extends to oriented forests, and computes MM in them in log∗ n + O(1) time. This
extended routine will be referred to as Procedure Forest-MM.
Next, we show how to extend these algorithms further, to work on general graphs.
This extension, however, comes at a price of increasing the running time. The algorithm
for general graphs is called Procedure Simple-Edge-Color. It accepts as input a graph G.
First, it computes a ∆-forest-decomposition of G. To this end it orients the edges towards
endpoints with greater Ids. Then each vertex assigns distinct labels from the set [∆] to its
outgoing edges. For i = 1, 2, ..., ∆, all edges that were assigned the label i form a forest Fi .
Next, Procedure Simple-Edge-Color proceeds in ∆ phases. In each phase i = 1, 2, ..., ∆, it
computes an edge-coloring of the forest Fi in a way that avoids conflicts with previously
colored forests. In other words, in the beginning of phase i, for each vertex v ∈ V , the list of
forbidden colors lv contains the colors of all edges incident on v that have been colored before
phase i. Thus, once a color for an edge is selected, it is not only distinct from the colors
of ajacent edges in the same forest, but also from the adjacent edges in other forests that
have been already colored. This completes the description of the algorithm. Its pseudocode
is provided below. (We remark that 3-vertex coloring of all forests can be performed in
92 8. EDGE-COLORING AND MAXIMAL MATCHING

parallel before the beginning of executing the ∆ phases of edge-coloring forests. In this way
the step of computing 3-vertex-coloring in each phase (line 1 of Algorithm 13) actually will
not require any computation, since the coloring has been already computed earlier. See
lines 2-4 of Algorithm 14.)

Algorithm 14 Procedure Simple-Edge-Color(G)

An algorithm for each vertex v ∈ V :
1: {F1 , F2 , ..., F∆ } := ∆-forest-decomposition
2: for i := 1, 2, ..., ∆, in parallel do
3: ψi := 3-vertex-coloring of Fi
4: end for
5: lv := ∅
6: for i := 1, 2, ..., ∆ do
7: Forest-Edge-Color(Fi )
8: lv := {ϕ(v, u) | u ∈ Γ(v), (v, u) is colored}
9: end for

Lemma 8.3 For any graph G = (V, E), Procedure Simple-Edge-Color computes a legal
(2∆ − 1)-edge-coloring of G.

Proof. Similarly to the proof of Lemma 8.1, before a color for an edge (u, v) ∈ E is selected,
it holds that |lu | ≤ ∆ − 1 and |lv | ≤ ∆ − 1. Thus there always exists an available color for
(u, v) from [2∆ − 1] \ (lu ∪ lv ). Next we show that the coloring is legal. Let e = (v, w),
e′ = (v, u) be a pair of edges in E that share a common vertex v. If e, e′ ∈ Fi , for some
i ∈ [∆], then ϕ(e) 6= ϕ(e′ ) by the correctness of Procedure Tree-Edge-Color. (We remark
that Procedure Tree-Edge-Color is correct even if in the beginning of its execution some
lists lx satisfy lx 6= ∅, as long as there are always available colors for edges (x, y) ∈ E
from [2∆ − 1] \ (lx ∪ ly ).) If e ∈ Fi , e′ ∈ Fj for some i < j then the color of e′ is selected
in a later phase than that of e. Consequently, at the time of selection of the color of
e′ = (v, u) it holds that ϕ(e) = ϕ(v, w) ∈ lv . Therefore, the selected color of e′ satisfies
ϕ(e′ ) ∈ [2∆ − 1] \ (lv ∪ lu ), and thus, ϕ(e′ ) 6= ϕ(e). The remaining case i > j is symmetrical.
2

Lemma 8.4 The running time of Procedure Simple-Edge-Color is O(∆) + log∗ n.

Proof. Computing ∆-forest-decomposition in line 1 requires O(1) time. Computing 3-

vertex-coloring for ∆ forests in parallel in lines 2 - 4 requires log∗ n + O(1) time. Each
of the ∆ phases in lines 6 - 9 requires O(1) time. Therefore, the overall running time is
O(∆) + log∗ n. 2
The next theorem summarizes the analysis of Procedure Simple-Edge-Color.
8.2. EDGE-COLORING USING BOUNDED NEIGHBORHOOD INDEPENDENCE 93
Theorem 8.5 A (2∆ − 1)-edge-coloring of general graphs can be computed in O(∆) +
log∗ n time.

Procedure Forest-MM can be extended in an analogous way to produce an MM for a general

graph in time O(∆) + log∗ n.
Next consider the (2∆ − 1)-edge-coloring and the MM problems in graphs of bounded
arboricity (at most a). One can use an algorithm similar to Procedure Simple-Edge-Color,
except that instead of computing a ∆-forest-decomposition in line 1 of Algorithm 14 we
compute a forest-decomposition into A ≤ a · q forests, for some parameter q > 2. The rest
of the algorithm is identical to Algorithm 14, but ∆ has to be replaced by A in lines 2 and
6. The modified algorithm will be called Procedure Arb-Edge-Color.
The same analysis as in Lemmas 8.3 and 8.4 shows that Procedure Arb-Edge-Color
produces a (2∆ − 1)-edge-coloring within O(A) + log∗ n time, in addition to the time re-
quired to compute the forest-decomposition. The latter is, by Lemma 5.13, O( log n
log q ). Hence
log n
the overall running time is O(a · q + log q ). For graphs with arboricity a ≤ log1−ǫ n, for some
constant ǫ > 0, we can set q = logǫ/2 n, and obtain running time O( logloglogn n ). Also, evidently,
the running time of this algorithm is polylogarithmic in n as long as the arboricity is poly-
logarithmic in n. (By setting q = 3 one gets here time O(a + log n).) Moreover, similarly to
Procedure Simple-Edge-Color, Procedure Arb-Defective-Color can also be easily extended
to compute a MM within the same time.

Theorem 8.6 [7] For graphs with arboricity a ≤ log1−ǫ n, for some constant ǫ > 0, it is
possible to compute (2∆ − 1)-coloring and MM in O( logloglogn n ) deterministic time. Moreover,
they can be always computed in time O(a + log n).

8.2 EDGE-COLORING USING BOUNDED NEIGHBORHOOD

INDEPENDENCE
A graph with bounded neighborhood independence c is a graph in which every 1-
neighborhood of a vertex contains at most c independent vertices, for some integer parame-
ter c > 0. In other words, for each vertex v ∈ V , the size of any independent set I ⊆ Γ(v) is
at most c. Consider, for example, the line graph L(G) of a graph G = (V, E). A vertex v in
L(G) corresponds to an edge ev ∈ G. An independent set of vertices I ∈ Γ(v) corresponds
to a set of edges JI ⊆ E, such that each e ∈ JI share a common endpoint with ev , but each
pair of edges e, e′ ∈ JI do not intersect. Therefore, |JI | ≤ 2, and consequently, |I| ≤ 2. Thus,
any line graph L(G) has neighborhood independence bounded by 2. In this section we show
that graphs with bounded neighborhood independence can be vertex-colored much faster
than by using algorithms for general graphs described in previous sections. In particular,
these results apply to vertex-coloring of line graphs, which, in turn, gives rise to efficient
edge-coloring algorithms for general graphs. The results in this section are from [10].
94 8. EDGE-COLORING AND MAXIMAL MATCHING

As a first step we show that graphs with bounded neighborhood independence and
bounded arboricity must also have bounded degree. This fact allows one to compute defec-
tive colorings of graphs with bounded neighborhood independence more efficiently than in
general graphs. Specifically, for general graphs it is currently known only how to compute
efficiently O(∆/p)-defective p2 -coloring (see Section 6.2) and O(a/p)-arbdefective O(p)-
coloring (see Chapter 7). On the other hand, for graphs with bounded neighborhood inde-
pendence, O(∆/p)-defective O(p)-coloring can be computed very efficiently for reasonably
small values of p ≥ 1. Efficient defective coloring with these parameters (notice that the
product of the defect and the number of colors is linear in ∆) gives rise to efficient algorithms
for legal O(∆)-vertex-coloring of graphs with bounded neighborhood independence.

Lemma 8.7 A graph G = (V, E) with arboricity bounded by a and neighborhood indepen-
dence bounded by c, for some integer parameters a, c > 0, has maximum degree at most
2a · c.

Proof. First, notice that G can be vertex-colored legally using 2a colors, because χ(G) ≤
degen(G) + 1 ≤ 2a(G) = 2a. (See Section 2.3.2, Lemma 2.30). Let v ∈ V be a vertex such
that deg(v) = ∆(G). The subgraph G(Γ(v)) can be colored with 2a colors as well. Let ϕ be
such a coloring. By the pigeonhole principle, there exists a color k, 1 ≤ k ≤ 2a, such that
|{u ∈ Γ(v) | ϕ(u) = k}| ≥ deg(v)
2a . On the other hand, all vertices colored by the same color
form an independent set. The size of the independent set {u ∈ Γ(v) | ϕ(u) = k} is at most
c. Therefore, c ≥ deg(v)
2a
∆
= 2a . Hence, ∆(G) ≤ 2a · c. 2
By Lemma 8.7, an O(∆/p)-arbdefective O(p)-coloring of a graph with neighborhood
independence bounded by c is also an O((2∆/p) · c)-defective O(p)-coloring of the graph.
Therefore, for obtaining defective colorings of such graphs, it is sufficient to compute an
appropriate arbdefective coloring. Next, we describe an efficient algorithm for comput-
ing an O(∆/p)-arbdefective O(p)-coloring. This algorithm is called Procedure Arbdefective-
Coloring-Bounded. It is very similar to Procedure Arbdefective-Coloring. (See Section 7.1,
Algorithm 11.) The only difference is that in the beginning of the partial-orientation phase
the partition H consists only of a single graph H1 = G, i.e., the entire input graph. The
pseudocode of the procedure is provided in Algorithms 16 below. It employs Algorithm 15
as a sub-routine.

Algorithm 15 Procedure Partial-Orientation-Bounded(G, t)

1: compute a ⌊∆/t⌋-defective O(t2 )-coloring ψ of G.
2: for each edge e = (u, v) in E in parallel do
3: if u and v have different ψ-colors then
4: orient e towards the endpoint with a greater ψ-color.
5: end if
6: end for
8.2. EDGE-COLORING USING BOUNDED NEIGHBORHOOD INDEPENDENCE 95

Algorithm 16 Procedure Arbdefective-Coloring-Bounded(G, k, t)

1: µ = Partial-Orientation-Bounded(G, t)
2: once all the parents u of v with respect to µ have selected a color ϕ(u) do
v selects a color ϕ(v) from the palette {1, 2, ..., k} which is used by the minimum number
of parents of v

Procedure Partial-Orientation-Bounded computes an orientation µ with deficit ⌊∆/t⌋

and length O(t2 ). Thus, Procedure Arbdefective-Coloring-Bounded computes a (∆/t +
∆/k)-arbdefective k-coloring. The running time of step 1 of Procedure Partial-Orientation-
Bounded is log∗ n + O(1), by using the algorithm of Kuhn [48]. The other steps of the
procedure require constant time. Thus, the running time of step 1 of Algorithm 16 is
log∗ n + O(1). Step 2 of Algorithm 16 requires time proportional to the length of µ, which
is O(t2 ). We summarize the properties of the algorithm in the next theorem.

Theorem 8.8 For positive integer parameters t, k, satisfying 0 < t, k < ∆, an (∆/t +
∆/k)-arbdefective k-coloring of an input graph G can be computed in O(t2 ) + log∗ n time.

We remark that Theorem 8.8 holds for general graphs, and not only on graphs with bounded
neighborhood independence. However, for graphs with bounded neighborhood indepen-
dence, Theorem 8.8 in conjunction with Lemma 8.7 imply that defective colorings of such
graphs with appropriate parameters can be computed efficiently.

Corollary 8.9 Let G be a graph with neighborhood independence bounded by c, for some
integer c > 0. For positive integer parameters t, k, satisfying 0 < t, k < ∆, a (2 · (∆/t +
∆/k) · c)-defective k-coloring of the graph G can be computed in O(t2 ) + log∗ n time.

Proof. Let ϕ be an (∆/t + ∆/k)-arbdefective k-coloring of G computed by procedure

Arbdefective-Coloring-Bounded. The arboricity of a subgraph Gi induced by a color class
i of ϕ, for 1 ≤ i ≤ k, is at most (∆/t + ∆/k). Thus by Lemma 8.7, the maximum degree of
Gi is 2 · (∆/t + ∆/k) · c. Thus, ϕ is a (2 · (∆/t + ∆/k) · c)-defective k-coloring. 2

For graphs in which the neighborhood independence is bounded by a constant, the above
corollary implies an O(∆/p)-defective p-coloring, for an integer 0 < p < ∆. (To this end,
set t = k = p.) Such a coloring can be used to achieve a legal O(∆)-vertex-coloring of such
graphs faster than in O(∆ + log∗ n) time. Specifically, compute an O(∆2/3 )-defective ∆1/3 -
coloring ψ in O(∆2/3 + log∗ n) time. Then compute a legal O(∆2/3 )-coloring ϕ of each
subgraph induced be a color class of ψ, using distinct palettes. This requires O(∆2/3 +
log∗ n) time as well. Overall, a legal O(∆)-coloring of the entire input graphs is obtained
in O(∆2/3 + log∗ n) time. This approach can be improved if the computation of defective
colorings is performed several times recursively, similarly to the approach in Section 7.2. In
other words, we need to compute defective colorings on subgraphs induced by color classes
96 8. EDGE-COLORING AND MAXIMAL MATCHING

of a coloring ψ returned by Procedure Arbdefective-Coloring-Bounded. To this end, we

show that the family of graphs with bounded neighborhood independence is closed under
taking vertex-induced subgraphs.

Lemma 8.10 Let G = (V, E) be a graph with neighborhood independence bounded by c. For
any V ′ ⊆ V , the neighborhood independence of the induced subgraph G′ = G(V ′ ) is at most
c as well.

Proof. For a vertex u ∈ V ′ , ΓG′ (u) is the neighborhood of u in G′ , and ΓG (u) is the
neighborhood of u in G. Suppose for contradiction that there exists a vertex u ∈ V ′ such
that there is an independent set W ⊆ ΓG′ (u) with cardinality |W | > c. For a pair of vertices
/ E. (Because v, w ∈ V ′ and v, w ∈ V . Therefore if (v, w) ∈ E,
v, w ∈ W , it holds that (v, w) ∈
then (v, w) must be present in any induced subgraph that contains the vertices u, w. But
the vertices v and w are not connected in G(V ′ ), thus they are not connected in G as
well.) In addition, ΓG′ (u) ⊆ ΓG (u). Therefore, W ⊆ ΓG (u) is an independent set with more
than c vertices, and it is contained in the neighborhood ΓG (u) of the vertex u. This is a
contradiction. 2

The improved algorithm for computing vertex-colorings of graphs with bounded

neighborhood independence is called Procedure Legal-Coloring-Bounded. It accepts as in-
put a graph G with neighborhood independence bounded by c, a parameter d which is
an upper bounded on ∆(G), and a parameter p > 4 · c. If d ≤ p then a (d + 1)-coloring is
directly computed on G in O(d) + log∗ n time using Algorithm 8 from Section 6. Otherwise,
an O(c · d/p)-defective p-coloring ψ of G is computed. The p color classes of ψ induce the
subgraphs G1 , G2 , ..., Gp , each with maximum degree O(c · d/p). Next, Procedure Legal-
Coloring-Bounded is invoked recursively on G1 , G2 , ..., Gp in parallel. These invocations
produce legal q-colorings of G1 , G2 , ..., Gp . (We will analyze the value of q later.) Then
these colorings are merged into a unified O(q · p)-coloring of the input graph G. This com-
pletes the description of the algorithm. Its pseudocode is provided below.
8.2. EDGE-COLORING USING BOUNDED NEIGHBORHOOD INDEPENDENCE 97

Algorithm 17 Procedure Legal-Color-Bounded(G, d, p)

1: if d ≤ p then
2: ϕ := a (d + 1)-coloring of G
3: return ϕ
4: else
5: ψ := Arbdefective-Coloring-Bounded(G, k := p, t := p)
6: denote by Gi the graph induced by color class i of ψ, i ∈ {1, 2, ..., p}
7: for i = 1, 2, ..., p, in parallel do
8: ϕi := Legal-Color-Bounded(Gi , ⌊4 · c · d/p⌋ , p)
9: ϕ(v) := (ϕi (v) − 1) · p + i
10: end for
11: return ϕ
12: end if

Lemma 8.11 Suppose that Procedure Legal-Color-Bounded is invoked on a graph G with

bounded neighborhood independence c, and the parameters d = ∆ = ∆(G) and p > 4 · c.
Then the procedure produces a legal ((4c)logp/4c ∆ ∆)-vertex coloring in O((p2 + log∗ n) ·
logp/4c ∆) time.

Proof. First we prove that the procedure invoked with the above parameters produces the
required coloring. The proof is by induction on the recursion depth.
Base: If d ≤ p then the procedure computes in line 2 a legal (∆ + 1)-coloring of G.
Step: If d > p then the procedure computes a ⌊4 · c · d/p⌋-defective p-coloring ψ of G in
line 5. (See Corollary 8.9.) Denote d′ = ⌊4 · c · d/p⌋. By induction hypothesis, each of the
′
subgraphs G1 , G2 , ..., Gp is colored legally with at most ((4c)logp/4c d d′ ) colors in line 8. Next,
′
in line 9 these colorings are transformed into a legal coloring with at most ((4c)logp/4c d d′ ) ·
′ ′ ′
p ≤ ((4c)logp/4c d 4 · c · d/p) · p ≤ (4c)logp/4c d +1 · d ≤ (4c)logp/4c (d ·p/4c) · d ≤ (4c)logp/4c d · d.
Next, we analyze the running time of the procedure. Observe that in each recursive
invocation, the bound on the maximum degree of the subgraph on which the procedure
is invoked is decreased by a factor of at least p/4c > 1. Consequently, the depth of the
recursion tree is at most logp/4c ∆. The running time of the procedure is given by T (d) =
T (4 · c · d/p) + O(p2 ) + log∗ n.
This recursive formula solves to T (∆) = O((p2 + log∗ n) · logp/4c ∆). 2

Consider a graph G with neighborhood independence bounded by c = O(1). By setting

p = ∆ǫ in Lemma 8.11, for an arbitrarilly small constant ǫ > 0, we obtain a legal O(∆)-
vertex-coloring of G in O(∆2ǫ + log∗ n) time. Alternatively, by setting p = (log ∆)ǫ , we
obtain a legal ∆1+o(1) -vertex-coloring in O((log ∆)1+2ǫ + log∗ n · logloglog∆∆ ) time. Finally, by
setting p = c′ for a large constant c′ ≫ c, we obtain a legal O(∆1+ǫ )-vertex-coloring in
O(log∗ n · log ∆) time. These results (due to [10]) are summarized in the following theorem.
98 8. EDGE-COLORING AND MAXIMAL MATCHING

Theorem 8.12 Consider a graph G with neighborhood independence bounded by c = O(1).

Let ǫ > 0 be an arbitrarilly small constant.
(1) An O(∆)-vertex-coloring of G can be computed in O(∆ǫ + log∗ n) time.
(2) A ∆1+o(1) -vertex-coloring of G can be computed in O((log ∆)1+ǫ + log∗ n · logloglog∆∆ )
time.
(3) An O(∆1+ǫ )-vertex-coloring of G can be computed in O(log∗ n · log ∆) time.
We conclude this section by arguing that the techniques described above can be used
to devise very efficient edge-coloring algorithms for general graphs. These algorithms are
based on the observation that line graphs have neighborhood independence bounded by 2.
(See the discussion in the beginning of this section).
Recall that for any graph G and positive integer k, a legal k-coloring of vertices of
L(G) is a legal k-coloring of edges of G, and vice versa. Recall also that the maximum
degree ∆(L(G)) of the line graph L(G) satisfies ∆(L(G)) ≤ 2(∆ − 1), where ∆ = ∆(G).
Consequently, if we are given a line graph L(G) of a graph G with ∆(G) = ∆, one can com-
pute an O(∆(L(G))) = O(∆)-vertex-coloring of L(G) in O(∆ǫ + log∗ n) time, for any con-
stant ǫ > 0. Similarly, one can also compute ∆1+o(1) -vertex-coloring (respectively, O(∆1+ǫ )-
vertex-coloring) of L(G) in O((log ∆)1+ǫ + log∗ n · logloglog∆∆ ) (resp., O(log∗ n · log ∆)) time.
These vertex colorings give rise directly to edge coloring of G with the same number of
colors.
On the other hand, in the distributed edge-coloring problem we are given as input the
graph G, rather than its line graph L(G). Nevertheless, one can simulate the distributed
computation of an algorithm on L(G) using the network G = (V, E). To this end each vertex
of L(G) is simulated by one endpoint of an appropriate edge in G. Consequently, a message
sent over an edge of L(G) will be sent over at most two edges in the simulation on G.
Lemma 8.13 Any algorithm with running time T for the line graph L(G) of the input
graph G can be simulated by G, and requires at most 2T + O(1) time.
Proof. For each edge e ∈ E, one of the endpoints of e simulates a vertex in L(G) that
corresponds to e. (Note that each vertex in G may simulate many vertices of L(G).) Specif-
ically, for each edge e = (u, v) ∈ E, such that Id(u) < Id(v), the vertex that corresponds to
e in L(G) is simulated by u. We denote the vertex in L(G) that corresponds to e by ve . The
Id of ve is set as the ordered pair hId(u),Id(v)i. This guarantees unique Ids for vertices in
L(G). Sending a message from a vertex w in L(G) to its neighbor w′ is simulated as follows.
If the vertices that simulate w and w′ are neighbors in G, the message is sent directly. Oth-
erwise, the distance between the simulating vertices is 2. The vertices w and w′ correspond
to edges e and e′ in E that share a common endpoint v ′ . In this case the message is sent
from the vertex that simulates w to v ′ , and from v ′ to the vertex that simulates w′ . Hence
any algorithm for the line graph can be simulated on the original graph, increasing the
running time by a factor of at most 2. The additive term of O(1) in the running time above
reflects the time spent for computing unique Ids for vertices of L(G). 2
8.2. EDGE-COLORING USING BOUNDED NEIGHBORHOOD INDEPENDENCE 99
Since L(G) has neighborhood independence bounded by 2, we can apply Lemma 8.13
in conjunction with Theorem 8.12, and obtain the following theorem.

Theorem 8.14 Consider a graph G = (V, E), and let ǫ > 0 be an arbitrarilly small con-
stant.
(1) An O(∆)-edge-coloring of G can be computed in O(∆ǫ + log∗ n) time.
(2) A ∆1+o(1) -edge-coloring of G can be computed in O((log ∆)1+ǫ + log∗ n · logloglog∆∆ ) time.
(3) An O(∆1+ǫ )-edge-coloring of G can be computed in O(log∗ n · log ∆) time.
100

CHAPTER 9

Network Decompositions
In this chapter we describe an important general technique for solving distributed sym-
metry breaking problems, called the network decomposition technique. Algorithms that are
based on this technique consist of two stages. In the first stage a network decomposition is
constructed, and in the second stage this decomposition is used to solve a problem at hand.
A network decomposition of a graph G = (V, E) with positive integer parame-
ters α and β is a partition of G into clusters of radius at most α, which satisfies
an additional property. Given a partition P = {C1 , C2 , ..., Cq } of the graph G = (V, E),
S
C∈P C = V , Ci ∩ Cj = ∅ for i 6= j, the supergraph G = (P, E) induced by P is given by
E = {(C, C ′ ) | C, C ′ ∈ P, ∃(v, v ′ ) ∈ E, v ∈ C, v ′ ∈ C ′ }. In a network decomposition P with
parameters α and β, the chromatic number χ(G) of the supergraph G is required to be at
most β. In a strong (repectively, weak) network decomposition the strong (resp., weak)
dimeter of each cluster C, given by Diam(C) = max{distG(C) (v, v ′ ) | v, v ′ ∈ C} (resp.,
Diam(C) = max{distG (v, v ′ ) | v, v ′ ∈ C}) is required to be at most α. In addition, each
cluster C ∈ P has a designated vertex xc , called the center of C.
The network decomposition technique was invented by Awerbuch et al. [5]. They de-
veloped a deterministic algorithm
√
for constructing a strong √
network decomposition with the
parameters α = β = 2O( log n log log n) that requires 2O( log n log log n) time. Panconesi and
Srinivasan [69] improved upon this and devised a√deterministic algorithm √
for constructing
strong network decompositions with α = β = 2O( log n) that requires 2O( log n) time. Linial
and Saks [57] came up with a randomized algorithm for building weak network decomposi-
tions with α = β = O(log n), with running time O(log2 n). Barenboim [6] recently devised
a randomized O(1)-time algorithm for constructing strong network decompositions with
α = O(1) and β = n1/2+ǫ , for an arbitrarily small constant ǫ > 0.
The algorihms of [5, √
69] gave rise to deterministic algorithms for MIS and (∆ + 1)-
coloring that require 2O( log n) time. Remarkably, these algorithm are the current state-
of-the-art deterministic algorithms for these problems. (For the MM problem, Hanckowiak
et al. [35] showed that one can outperform an algorithm based on network decompositions
by a different approach.) The algorithm of Linial and Saks [57] gives rise to a randomized
MIS, (∆ + 1)-coloring and MM algorithms that require O(log2 n) time. As we will see in
Chapter 10, one can do much better for these problems when randomization is allowed
using a different approach (which is not based on network decompositions).
This chapter is based on the paper of Awerbuch et al. [5]. In Section 9.1 we show
how network decompositions can be used for solving distributed symmetry breaking prob-
 9.1. APPLICATIONS OF NETWORK DECOMPOSITIONS 101
lems. In Sections 9.2 and 9.3 we describe
√
deterministic algorithms for computing network
O( log n log log n)
decompositions with α = β = 2 .

9.1 APPLICATIONS OF NETWORK DECOMPOSITIONS

Suppose that we are given a (strong or weak) network decomposition P = (C1 , C2 , ..., Cq ),
with parameters α and β. Suppose also that each center xi of a cluster Ci , for i ∈ [q], is
provided with a color ϕ(Ci ) = ϕi ∈ [β], so that ϕ is a legal β-coloring for the supergraph
G = (P, E) induced by the decomposition P. Next we show that this decomposition can be
used to compute an MIS of G within O(α · β) time.
For all clusters C with ϕ(C) = 1, the center x = xC of each cluster C collects in
parallel the data about the graph G(C) induced by C into x. In addition, x learns the
states of all vertices in Γ(C) = {u | u ∈ Γ(v), v ∈ C}, i.e., for each u ∈ Γ(C), the center x
learns if u belongs to the MIS U that was constructed so far, or not. (The set U is initialized
as an empty set.) Once x knows the topology of G(C) and the states of vertices in Γ(C), it
computes locally the subset C ′ ⊆ C of vertices that are not adjacent to a vertex from U .
Then x computes locally an MIS for G(C ′ ), and adds this MIS to the set U both locally,
and by informing all vertices in C. This is done in parallel by all clusters C with ϕ(C) = 1.
This completes the first phase of the algorithm. Then the same computation is done in
parallel for clusters of color 2 (phase 2), and then for clusters of color 3, etc. Overall there
are β phases, each of which lasts for O(α) rounds. Hence the total running time of this
computation is O(α · β).
S Si
For each i = 1, 2, ..., β, let Zi = {C ∈ P | ϕ(C) = i}, and Ẑi = j=1 Zi .
Lemma 9.1 For i = 1, 2, ..., β, after i phases of the algorithm, the set U = Ui is an MIS
for Ẑi .
Proof. The proof is by induction on i.
Base: For any pair C, C ′ of clusters ϕ-colored by 1, distG (C, C ′ ) ≥ 2. Also, in the beginning
of phase 1 the set U = U0 is empty. Hence the algorithm computes an MIS IC for each
S S
cluster C with ϕ(C) = 1 , and U1 = {IC | ϕ(C) = 1}. Since Ẑ1 = Z1 = {C | ϕ(C) = 1},
it follows that U1 is an MIS for Z1 .
Step: For some i < β, we assume that Ui is an MIS for Ẑi . For every cluster C with ϕ(C) =
i + 1, let C ′ = kernel(C) ⊆ C be its subset of vertices which have no neighbors in Ui . Now
′
S
let Zi+1 = {kernel(C) | ϕ(C) = i + 1}. Observe that for every pair of clusters C, Ĉ with
ϕ(C) = ϕ(Ĉ) = i + 1, it holds that distG (C, Ĉ) ≥ 2, and so distG (kernel(C), kernel(Ĉ)) ≥ 2
as well. The algorithm computes an MIS IC for kernel(C), for each C with ϕ(C) = i + 1.
S ′ ′
Hence {IC | ϕ(C) = i + 1} is an MIS for Zi+1 . Also, Ui is an MIS for Ẑi ∪ (Zi+1 \ Zi+1 )=
′
S ′
S ′
Ẑi+1 \ Zi+1 . Hence Ui+1 = Ui ∪ {IC | ϕ(C) = i + 1} is an MIS for (Ẑi+1 \ Zi+1 ) Zi+1 =
Ẑi+1 . 2
Observe that a similar algorithm can solve also the (∆ + 1)-coloring problem.
102 9. NETWORK DECOMPOSITIONS

Corollary 9.2 [5] Given a network decomposition with parameters α and β, the MIS and
the (∆ + 1)-coloring problems can be solved in O(α · β) deterministic time.

9.2 RULING SETS AND FORESTS

In this section we describe a procedure for computing a ruling set. Ruling sets (to be defined
in the sequel) are used in the deterministic construction of network decompositions due to
[5], which we will present in Section 9.3.
Definition 9.3 For a graph G = (V, E), a subset W ⊆ V of vertices, and a pair of positive
integers λ and ρ, a set I ⊆ W is said to be a (λ, ρ)-ruling set for W in G if
(1) for every pair of distinct vertices v, v ′ ∈ I, it holds that distG (v, v ′ ) ≥ λ, and
(2) for every vertex u ∈ W \ I, there exists a “ruling” vertex v ∈ I, such that dist(v, u) ≤ ρ.
Observe that an MIS for W is a (2, 1)-ruling set for W .
Next we present a procedure for constructing (c, c · ⌈log n⌉)-ruling sets, for an ar-
bitrary parameter c ≥ 1, which requires O(log n) time. The procedure is called Procedure
Ruling-Set. The construction is due to Goldberg et al. [31]. The procedure starts with parti-
tioning all vertices of W into two disjoint sets W0 ∪ W1 = W , where W0 (respectively, W1 )
is the subset of vertices of W with even (resp., odd) Ids. Then the procedure is invoked
recursively in parallel on W0 and W1 . This computation returns (c, c · ⌈log n/2⌉)-ruling sets
I0 and I1 , for W0 and W1 respectively. Now the unified ruling set I for W is constructed
in the following way. All vertices of I0 join I. Also, all vertices z ∈ I1 that are at distance
at most c in G from some vertex of I0 are knocked out. All other vertices z from I1 join I.
This completes the computation of I. In other words I ← I0 ∪ {z ∈ I1 | distG (I0 , z) > c}.
To complete the description of this procedure we only need to specify the termination
condition of the recursion. We do this next. When vertices of W join W0 or W1 , the least
significant bit of their Ids is truncated. So if the Ids of verices in W contain ⌈log n⌉ bits,
then Ids of vertices in W0 and W1 contain ⌈log n/2⌉ = ⌈log n⌉ − 1 bits. When we are left
with a set W with single-bit Ids, the ruling set I for it is computed in the following way.
At this time |W | ≤ 2. Then the vertex in W with Id 0, if exists, joins I. Next, the vertex
with Id 1 in W , if exists, joins I if there is no other vertex in I at distance at most c from
it in G. This completes the description of Procedure Ruling-Set.
Lemma 9.4 Procedure Ruling-Set invoked on W ⊆ V with a parameter c returns a (c, c ·
⌈log n⌉)-ruling set in O(log n) time.
Proof. The proof is by induction on the number of bits in Ids of vertices in W .
Base (1 bit): The set I computed by the algorithm is a (c, c)-ruling set for W .
Step (i + 1 bits): By induction hypothesis, I0 (respectively, I1 ) is a (c, c · i)-ruling set for
W0 (resp., W1 ). Recall that I = I0 ∪ {z ∈ I1 | distG (I0 , z) > c}. Obviously, for every v, v ′ ∈
I, it holds that distG (v, v ′ ) > c. Consider some u ∈ W . If u ∈ W0 then, by the induction
 9.3. CONSTRUCTING NETWORK DECOMPOSITIONS 103
hypothesis, there exists a vertex v0 ∈ I0 such that distG (v0 , u) ≤ c · i. Otherwise, u ∈ W1 .
Then, by the induction hypothesis, there exists v1 ∈ I1 such that distG (v1 , u) ≤ c · i. If
v1 ∈ I then we are done. Otherwise, there exists v0 ∈ I0 such that distG (v0 , v1 ) ≤ c, and so
distG (v0 , u) ≤ c · (i + 1).
This proves that I is a (c, c · ⌈log n⌉)-ruling set. For the running time analysis note
that each level of the recursion requires O(c) time, and there are ⌈log n⌉ levels. 2

A notion of ruling forests is closely related to that of ruling sets.

Definition 9.5 For a graph G = (V, E), a subset W ⊆ V of vertices, and a pair of positive
integer parameters λ and ρ, a (λ, ρ)-ruling forest F = {(T1 , r1 ), (T2 , r2 ), ..., (Tq , rq )}, for
some integer q, is a collection of vertex-disjoint rooted trees whose roots form a (λ, ρ)-ruling
set for W in G. Moreover, for every u ∈ W there exists a root ri of a tree (Ti , ri ) ∈ F, such
that distTi (ri , u) ≤ ρ.

Given a (λ, ρ)-ruling set I for W it is easy to construct a (λ, ρ)-ruling forest F for
W . Specifically, we conduct a breadth-first-search (henceforth, BFS) to distance ρ from
each vertex v ∈ I in parallel. If a vertex x is discovered in parallel by two BFSs originated
in v and v ′ , v, v ′ ∈ I, then x joins one of these BFS trees arbitrarily. Once a vertex x
joins a BFS tree rooted at a vertex v ∈ I, it never switches loyality, i.e., it stays in the
tree of v ′ forever. It is easy to verify that the resulting collection of the BFS trees rooted
at vertices of I is a (λ, ρ)-ruling forest for U . Its computation requires O(ρ) time. We
will henceforth refer to this computation as Procedure Ruling-Forest. It accepts as input a
positive integer parameter c and a set W ⊆ V . It first computes a (c, c · ⌈log n⌉)-ruling set
I for W by invoking Procedure Ruling-Set, and then converts it into a ruling forest in the
way described above.

Corollary 9.6 Procecedure Ruling-Forest invoked on W ⊆ V with a parameter c returns a

(c, c · ⌈log n⌉)-ruling forest F for W .

9.3 CONSTRUCTING NETWORK DECOMPOSITIONS

In this section we describe an algorithm (due to [5]) for constructing network decompo-
sitions. It uses Procedure Ruling-Forest described in Section 9.2 as a blackbox. Let k be
a positive integer parameter. In a graph G = (V, E), let Z = Z0 be a set of vertices with
degrees at least n1/k . We construct a (3, 3 · ⌈log n⌉)-ruling forest F = F0 for Z = Z0 by in-
voking Procedure Ruling-Forest with parameters W = Z and c = 3. (The parameter c will
be set as c = 3 in all invocations of Procedure Ruling-Forest.) Denote U = V \ V (F ) = U0 .
For every u ∈ U0 , it holds that deg(U ) < n1/k . For each of these vertices u ∈ U0 , we form
a singleton cluster {u}, and add it to the initially empty partition P. We denote by P ′ the
partition that will be ultimately built by the algorithm. Some of the neighbors of u may
104 9. NETWORK DECOMPOSITIONS

later be merged into the same cluster. However, the degree of the cluster {u} in the sub-
graph G induced by the resulting partition P ′ (which is currently under construction) will
still be less than n1/k . Each of the trees (T, r) ∈ F becomes a 1-level cluster C = C(T, r)
centered at r. The singleton clusters {u} for u ∈ V are 0-level clusters.
Write V̂0 = {{v}} | v ∈ V } and V̂1 = {C = C(T, r) | (T, r) ∈ F0 }. Denote also Û0 =
{{u}k u ∈ U0 }, and let Ĝ0 be the supergraph induced by the partition V̂0 of G into singleton
clusters. Analogously, let Ĝ1 be the supergraph induced by the set V̂1 of clusters. Specifically,
the edge set Ê1 of Ĝ1 is given by Ê1 = {(C, C ′ ) | C, C ′ ∈ V̂1 , ∃(v, v ′ ) ∈ E, v ∈ C, v ′ ∈ C ′ }.
Let Ẑ1 be the set of clusters of V̂1 with degree at least n1/k in Ĝ1 . Let Û1 = V̂1 \ Ẑ1 be
the clusters of degree less than n1/k in Ĝ1 . The clusters of Û1 are now added to P. The
edges between clusters of Û0 and Û1 are oriented towards clusters of Û1 . More generally, the
algorithm will now construct a sequence of sets Û0 , Û1 , .... The edges between clusters of Ûi
and Ûj for i < j are oriented towards clusters of Ûj . The edges between clusters of Ûi , for
some i = 0, 1, 2, ..., are oriented arbitrarily. Denote by µ the orientation of the supergraph
G that we have just defined.
Observe that similarly to the clusters of Û0 , for each cluster C ∈ Û1 , its out-degree
under the orientation µ is less than n1/k . Indeed, its degree in Ĝ1 is less than n1/k , and its
out-degree under µ in P ′ will not be greater than that. (Because some clusters of Ĝ1 may
get merged into a single cluster of P ′ , but no clusters of Ĝ1 will be splitted.)
Next, the algorithm invokes Procedure Ruling-Forest to compute a (3, 3 · ⌈log n⌉)-
ruling forest F1 for Ẑ1 . Each tree (T, r) ∈ F1 (observe that r is a cluster of V̂1 and T is
a tree in Ĝ1 , i.e., each node of T is a cluster of V̂1 ) is now merged into a 2-level cluster
C. Specifically, C is a union of all 1-level clusters that belong to the tree T . These 2-
level clusters form the vertex set V̂2 of the supergraph Ĝ2 , and the algorithm proceeds
with clustering them according to the same rule. Specifically, for each i = 0, 1, 2, ..., we are
given a set V̂i of i-level clusters, and a supergraph Ĝi induced by it. The clusters of V̂i of
degree less than n1/k in Ĝi are added to P. (The set of these clusters is called Ûi .) The
Procedure Ruling-Forest is invoked in the graph Ĝi with the set Ẑi = V̂i \ Ûi to form a
(3, 3 · ⌈log n⌉)-rulig forest F̂i . Each tree of F̂i becomes a cluster of level i + 1.
This continues for k phases. After k phases we have a partition P = Uˆ0 ∪ Û2 ∪ ... ∪
Ûk−2 , and the set of (k − 1)-level clusters V̂k−1 . We will promptly show that |V̂k−1 | ≤ n1/k .
The clusters of V̂k−1 are now added to the partition P to form the ultimate partition P ′
Sk−1
which the algorithm returns. We write Ûk−1 = V̂k−1 and P = P ′ = i=0 Ûi . This completes
the description of the algorithm. As was argued above, under the orientation µ which
was defined above, assuming |V̂k−1 | ≤ n1/k , the out-degree of any cluster C ∈ P ′ in the
supergraph G is at most n1/k .
In the next lemma we argue that |V̂k−1 | ≤ n1/k .

Lemma 9.7 For i = 0, 1, ..., k − 1, it holds that |V̂i | ≤ n1−i/k .

 9.3. CONSTRUCTING NETWORK DECOMPOSITIONS 105

Proof. We prove by induction on i that for every cluster C ∈ V̂i , it holds that |C| ≥ ni/k .
Base: V̂0 = {{v} | v ∈ V }, and so each C = {v} ∈ V̂0 has size 1 = n0/k .
Step: For a non-negative integer i < k − 1, suppose that for every cluster C ∈ V̂i , it holds
that C ≥ ni/k . Ẑi is the subset of i-level clusters with degree at least n1/k in Ĝi , and Fi
is a (3, 3 · ⌈log n⌉)-ruling forest for Ẑi in Ĝi . Each (i + 1)-level cluster C ∈ V̂i+1 is formed
by merging all clusters of a tree (T, r) ∈ Fi . For two roots r, r′ ∈ Ẑi of two distinct trees
(T, r), (T ′ , r′ ) ∈ Fi , the distance between them in Ĝi is at least 3.
Also, since r, r′ ∈ Ẑi , their degrees in Ĝi are at least n1/k . Hence the tree (T, r)
(respectively, (T ′ , r′ )) contains at least n1/k distinct i-level clusters which are neighbors
of r (resp., r′ ) in Ĝi . (If r and r′ would have a common neighboring i-level cluster, the
distance between them in Ĝi would be at most 2, contradiction.) Hence the size of an
(i + 1)-level cluster C is at least n1/k multiplied by the minimum size of an i-level cluster,
i.e., |C| ≥ n1/k · ni/k = n(i+1)/k , proving the inductive assertion. The assertion obviously
implies the lemma. 2
By substituting i = k − 1, we derive |V̂k−1 | ≤ n1/k .
We proved that the partition P = P ′ constructed by the algorithm has an orientation
µ (also computed by the algorithm) with out-degree at most n1/k . By Lemma 3.3, χ(G) ≤
n1/k + 1, where G is the supergraph induced by the partition P. Observe that each cluster
C ∈ P has a designated center xC . Indeed, for a 0-level cluster C = {v} ∈ V̂0 , the cluster
C is centered at v. For i, 0 ≤ i ≤ k − 2, an (i + 1)-level cluster C is formed by merging all
vertices of the tree (T, r) of Fi into a single cluster C. The tree (T, r) is rooted at an i-level
cluster r. The center of r becomes the center of C as well.
Denote t = 6 · ⌈log n⌉. In the next lemma we provide an upper bound on the diameters
of clusters in P.

Lemma 9.8 For every i = 0, 1, ..., k − 1, a cluster C ∈ V̂i (i.e., an i-level cluster C) has
strong diameter at most (t + 1)i+1 − 1.

Proof. The proof is by induction on i.

Base (i = 0): 0-level clusters have diameter 0.
Step: For some i, 0 ≤ i ≤ k − 2, suppose that each cluster C ∈ V̂i has strong diameter
at most (t + 1)i+1 − 1. Consider an (i + 1)-level cluster Ĉ. The cluster Ĉ is obtained by
merging all vertices from i-level clusters C that belong to a tree (T, r) ∈ Fi . Recall that the
radius of the tree (T, r) in Ĝi with respect to the i-level cluster r is at most t/2 = 3 · ⌈log n⌉,
and thus its diameter is at most t.
Let v, v ′ ∈ Ĉ be some two vertices in Ĉ. Let C, C ′ be the i-level clusters such that
v ∈ C, v ′ ∈ C. If C = C ′ then by the induction hypothesis distG(Ĉ) (v, v ′ ) ≤ distG(C) (v, v ′ ) ≤
(t + 1)i − 1, and we are done. Otherwise both clusters C, C ′ belong to the tree (T, r) ∈ Fi .
whose clusters were merged to obtain Ĉ. The distance between C and C ′ in (T, r) is at
most t. Let (C = C0 , C1 , ..., Cℓ = C ′ ), ℓ ≤ t + 1, be the (unique) path connecting C and C ′
106 9. NETWORK DECOMPOSITIONS

Figure 9.1: A path between two vertices v and v ′ in an (i + 1)-level cluster Ĉ.

in (T, r). The superedges (C0 , C1 ), (C1 , C2 ), ..., (Cℓ−1 , Cℓ ) belong to (T, r), and thus they
′
belong to Ĝi . Hence there exist edges e01 = (v0′ , v1 ), e12 = (v1′ , v2 ), ..., eℓ−1,ℓ = (vℓ−1 , vℓ ) ∈ E
′ ′
so that v0 ∈ C0 , vi , vi ∈ Ci for 1 ≤ i ≤ ℓ − 1, and vℓ ∈ Cℓ . See Figure 9.1 for an illustration.
Denote also v0 = v and vℓ′ = v ′ . For i, 0 ≤ i ≤ ℓ, let Pi be the shortest path in G(Ci )
between Vi and vi′ . By the induction hypothesis, |Pi | ≤ (t + 1)i − 1. Let P = P0 ◦ e01 ◦
P1 ◦ e12 ◦ ... ◦ eℓ−1,ℓ ◦ Pℓ be the concatenation of paths P0 , P1 , ..., Pℓ , alternating with edges
e01 , e12 , ..., eℓ−1,ℓ . Observe that P is a path in Ĉ connecting v and v ′ . It follows that
ℓ
X
distG(Ĉ) (v, v ′ ) ≤ |Pi | + ℓ ≤ (ℓ + 1) · ((t + 1)i − 1) + ℓ
i=0
≤ (t + 1) · ((t + 1)i − 1) + t = (t + 1)i+1 − 1,

proving the lemma. 2

Since the level i of clusters in P is at most k − 1, we conclude the the strong diameter of
P is at most (t + 1)k − 1.
Theorem 9.9 [5] The network decomposition algorithm that was described in this section
invoked on an n-vertex graph with an integer parameter k = 1, 2, ... constructs a network
decomposition with strong diameter α ≤ (6 · ⌈log n⌉ + 1)k and β ≤ n1/k + 1. The algorithm
requires O(logk+2 n) · 2O(k) deterministic time.
Proof. It only remains to analyze the running time of the algorithm. In level i, for i =
0, 1, ..., k − 2, the algorithm constructs a (3, 3 · ⌈log n⌉)-ruling forest Fi in the supergraph
Ĝi . In a graph such computation requires O(log n) time. (See Lemma 9.4). However, in the
supergraph Ĝi each node is in fact a cluster of diameter 2O(i) logi+1 n. Hence the overall
running time of this computation is 2O(i) · logi+2 n. The dominant term in the running time
is the term with i = k, proving the theorem. 2
 9.3. CONSTRUCTING NETWORK DECOMPOSITIONS 107
1/k
Given this network decomposition P it is not difficult also to compute an O(n )-coloring
of the supergraph G induced by it. Indeed we have a partition of P = Uˆ0 ∪ Û1 ∪ ... ∪ Ûk−1 .
Within each set Ûi , 0 ≤ i ≤ k − 1, the maximum degree ∆i in G(Ûi ) is at most n1/k . Thus
an (n1/k + 1)-coloring ϕ for G(Ûi ) can be computed by an algorithm of either [8] or [48].
(See Chapter 6.) The running time of these algorithms is O(∆i ) + 21 log∗ n. However, since
G(Ûi ) is a supergraph with clusters of diameter 2O(i) · logi+2 n, simulating a step of an
algorithm of [8] or [48] requires 2O(i) · logi+2 n time. Hence the total running time of this
step is 2O(i) · logi+2 n · n1/k ≤ 2O(k) · logk+2 n · n1/k .
Given the colorings ϕ0 , ϕ1 , ..., ϕk−1 , we can compute a single O(n1/k )-coloring ψ for
G by the following recoloring process. (It is closely related to O(a)-coloring that requires
O(a log n) time. See Section 5.2.) Clusters of Ûk−1 retain their colors. Clusters C ∈ Ûk−2
with ϕk−2 (C) = 1 recolor themselves in parallel into an admissible color from the palette
[n1/k + 1]. They can do so because they have at most n1/k neighbors in Ûk−1 . Then clusters
C ∈ Ûk−2 with ϕk−2 (C) = 2 do so. (Observe that they have at most n1/k neighboring
clusters in Ûk−2 ∪ Ûk−1 .) This process continues up until the color classes of Ûk−2 are
exhausted, and then we recolor color classes of Ûk−3 , Ûk−4 , ..., Û0 . Altogether there are
O(n1/k · k) recoloring steps. Since each step involves communication between neighboring
clusters of diameter at most 2O(k) · logk+2 n, it follows that the overall running time of the
recoloring phase is O(kn1/k · 2O(k) · logk+2 n).
We summarize this discussion below.

Theorem 9.10 [5] The network decomposition algorithm invoked on n-vertex graphs with
a parameter k, k = 1, 2, ..., constructs a network decomposition P with parameters
α ≤ 2O(k) · logk+2 n and β ≤ n1/k + 1 in deterministic O(logk+2 n) · 2O(k) . Moreover, in ad-
ditional time 2O(k) · O(n1/k logk+2 n) it computes an O(n1/k )-coloring for the supergraph G
induced by P.

As was argued in Section 9.1 (see Corollary 9.2), given this decomposition one can compute
an MIS or a (∆ + 1)-coloring of the original graph within additional α · β ≤ 2O(k) · logk+2 n ·
(n1/k + 1) time. Hence the overall running time for computing
p an MIS or a (∆ + 1)-coloring
O(k) k+2 1/k
by this algorithm is 2 · O(log n·n √ ). Set k = log n/ log log n to optimize this
expression. The resulting running time is 2O( log n log log n) .

Corollary 9.11 [5] Using the network decomposition√algorithm one can compute an MIS
or a (∆ + 1)-coloring of an n-vertex graph within 2O( log n log log n) deterministic time.

As was mentioned above, this result was improved by Panconesi and Srinivasan
√
[69]. The
O( log n)
running time of their network decomposition (and MIS) algorithm is 2 .
A more extensive treatment of network decompositions of various types can be found
in [67].
108

C H A P T E R 10

Introduction to Distributed
Randomized Algorithms
In the previous sections we dealt with deterministic algorithms. In the current section
we turn to describing randomized ones. The best currently known randomized algorithms
for distributed symmetry breaking problems are much more efficient than the best-known
deterministic ones (unless the maximum degree of the input graph is very small). However,
randomized algorithms have the drawback that with some (very small) probability over the
coin tosses of the algorithms they may fail or not terminate within the expected time.

10.1 SIMPLE ALGORITHMS

Many randomized algorithms adhere to the following approach.1 The algorithm proceeds
in phases. In each phase each vertex randomly selects a value from some appropriate set.
Based on the selected value and the values of the neighbors, each vertex either makes a
final decision (e.g., of a color), or continues to the next phase. All vertices that make their
final decision form a subset of a correct solution. Then these vertices are removed from the
graph, and the algorithm continues in the same way on the residual subgraph. An important
requirement in this approach is that partial solutions should be correct not only inside each
subset, but also in the union of all subsets that were removed from the graph, after each
phase. Once the algorithm terminates, the union of all subsets forms the input graph with
the required solution.
We begin with describing a 2∆-vertex-coloring algorithm that works according to
the approach described above. The algorithm is called Procedure Rand-2Delta. It accepts
as input a graph G. In each round each vertex v draws uniformly at random (henceforth,
u.a.r.) a color cv from the set [2∆] = {1, 2, ..., 2∆}. If a vertex selects a color that is different
from the selections of all its neighbors, and from the final decisions of all its neighbors, then
cv becomes the final decision of v. In this case v terminates. Otherwise it discards the color
cv , and proceeds to the next round. This completes the description of the procedure. Its
pseudocode is provided below. Its properties are analyzed in the following lemmas.

1 Thisapproach dates back to Luby’s randomized O(log n)-time algorithm for the MIS problem [60]. The algo-
rithms we describe in this section can be viewed as simplified variants of the algorithms from [60, 61].
 10.1. SIMPLE ALGORITHMS 109

Algorithm 18 Procedure Rand-2Delta(G)

An algorithm for each vertex v ∈ V .
Initialy Tv = ∅, Fv = ∅, for each v ∈ V .
/* Tv is the set of temporary colors selected by neighbors of v. */
/* Fv is the set of final colors selected by neighbors of v. */
1: for each round do
2: Tv = ∅
3: cv := draw a color from [2∆] u.a.r., independently of other vertices
4: send the color cv to all neighbors
5: for each received color cu from a neighbor u do
6: Tv := Tv ∪ {cu }
7: end for
8: if cv ∈/ Tv ∪ Fv then
9: send the message ”final cv ” to all neighbors
10: select cv as the final color ϕv of v and terminate
11: else
12: for each received message ”final cu ” from a neighbor u do
13: Fv := Fv ∪ {cu }
14: end for
15: discard cv and continue to the next round
16: end if
17: end for

For a vertex v ∈ V , denote by ϕ(v) the final color of v (if v terminates). Otherwise
ϕ(v) is undefined.

Lemma 10.1 If all vertices terminate, Procedure Rand-2Delta computes a legal 2∆-vertex-
coloring of the input graph.

Proof. If all vertices terminate, then each vertex selects a color from the set [2∆]. Consider
a pair of neighbors u, v ∈ V . Let i, j be the rounds in which u and v terminate, respectively.
Suppose for contradiction that ϕ(u) = ϕ(v). Then, obviously, i 6= j. (Otherwise, in round i it
holds that cu = cv , and thus both vertices continue to round i + 1. This is a contradiction.)
Suppose without loss of generaility that i < j. Then after round i it holds that ϕ(u) ∈ Fv .
Therefore, ϕ(v) 6= ϕ(u) since ϕ(v) ∈ / Tv ∪ Fv . Again, a contradiction. 2

Lemma 10.2 During the execution of Procedure Rand-2Delta all vertices terminate within
O(log n) rounds with probability 1 − 1/nc , for an arbitrarilly large constant c.

Proof. Consider a vertex v ∈ V . We analyze the probability that v terminates in round

i, conditioned on that it has not terminated before round i, for any i > 0. Notice that the
110 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

size of the set Tv ∪ Fv is at most ∆, since each neighbor of v contributes at most one color
to this set. Consequently, there are at least ∆ available colors for v in [2∆] \ (Tv ∪ Fv ).
Thus, the probability that cv is such a color is at least ∆/2∆ = 1/2. Hence, assuming that
v did not terminate before round i, it terminates in round i with probability at least 1/2,
independently of all other vertices.
The probability that some given vertex v does not terminate within i rounds is at
most (1/2)i . By the union bound, the probability that there exists a vertex v ∈ V that does
not terminate within i rounds is at most n · (1/2)i . Hence, after (c + 1) · log n rounds, with
probability at least 1 − n · (1/2)i ≥ 1 − 1/nc , all vertices terminate. 2

A slight modification of Procedure Rand-2Delta allows computing a (∆ + 1)-coloring

within O(log n) time. To this end, each vertex in each round selects a color from the set
{0, 1, 2, ..., ∆ + 1}. The color 0 is a special color whose selection probability is 1/2. For
any other available color c ∈ {1, 2, ..., ∆ + 1} \ Fv , the color c is selected with probability
1
2(∆+1−|Fv |) . Note that the colors in Fv are permanently selected by neighbors of v, and,
therefore, are not considered for selection by v. (Thus their selection probability is 0). The
other steps of the procedure remain the same, except that the color 0 is never set as a
final color. A vertex that selects 0 will continue to the next round. The pseudocode of the
modified procedure, Procedure Rand-Delta-Plus1 is provided below.
It can be easily verified that if all vertices terminate then the graph is colored with
(∆ + 1) colors. The next lemma shows that all vertices terminate within O(log n) rounds
with high probability.

Lemma 10.3 During the execution of Procedure Rand-Delta-Plus1 all vertices terminate
within O(log n) rounds with probability 1 − 1/nc , for an arbitrarilly large constant c.

Proof. Consider a vertex v ∈ V . We analyze the probability the v terminates in round

i, conditioned on that it has not terminated before round i, for any i > 0. This is the
probability that v selects a color cv > 0, and that it is different from the selections of
all neighbors. Suppose that indeed cv > 0. Then cv is distinct from all colors in Fv . The
probability that a given neighbor u of v selects the same color cu = cv in this round is at
1
most 2(∆+1−|F v |)
. (Because the probability that u selects a color greater than 0 is 1/2, and
v has ∆ + 1 − |Fv | different colors to select from.) By the union bound, the probability
that v selects a color that is equal to a color of some neighbor of v is at most (∆ + 1 −
1
|Fv |) · 2(∆+1−|F V |)
= 1/2. Thus, if v selects a color cv > 0, it is distinct from the colors of
its neighbors with probability at least 1/2. It holds that cv > 0 with probability 1/2. Thus
v terminates with probability at least 1/4.
The probability that some given vertex v does not terminate within i rounds is at
most (3/4)i . By the union bound, the probability that there exists a vertex v ∈ V that does
not terminate within i rounds is at most n · (3/4)i . Hence, after (c + 1) · 4 log n rounds,
with probability at least 1 − n · (3/4)i ≥ 1 − 1/nc , all vertices terminate. 2
 10.1. SIMPLE ALGORITHMS 111

Algorithm 19 Procedure Rand-Delta-Plus1(G)

An algorithm for each vertex v ∈ V .
Initialy Tv = ∅, Fv = ∅, for each v ∈ V .
1: for each round do
2: Tv := ∅
3: cv := draw u.a.r. a bit from {0, 1}
4: if cv = 0 then
5: discard cv and continue to the next round
6: else
7: cv := draw u.a.r. a color from [∆ + 1] \ Fv , independently of other vertices
8: send the color cv to all neighbors
9: for each received color cu from a neighbor u do
10: Tv := Tv ∪ {cu }
11: end for
12: if cv ∈/ Tv ∪ Fv then
13: send the message ”final cv ” to all neighbors
14: select cv as the final color ϕv of v and terminate
15: else
16: for each received meassage ”final cu ” from a neighbor u do
17: Fv := Fv ∪ {cu }
18: end for
19: discard cv and continue to the next round
20: end if
21: end if
22: end for

We summarize this discussion with the following theorem.

Theorem 10.4 A (∆ + 1)-coloring of a graph G can be computed within O(log n) time
with high probability.
We conclude this section by presenting an extremely simple algorithm that computes an
O(log n)-defective O(∆/ log n)-coloring within O(1) time. Actually, the algorithm does not
require any communication whatsoever. It is called Procedure Rand-DC. It consists of one
single line. Its pseudocode is provided below.

Algorithm 20 Procedure Rand-DC(G)

An algorithm for each vertex v ∈ V .
1: select a color from the set {1, 2, ..., ⌈deg(v)/(ρ · log n)⌉} uniformly at random
/* ρ is a sufficiently large fixed constant. */
112 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

We analyze the performance of Procedure Rand-DC in the next theorem.

Theorem 10.5 Procedure Rand-DC computes an O(log n)-defective O(∆/ log n)-coloring
of the input graph G within O(1) time, with probability 1 − 1/nc , for an arbitrarilly large
constant c.
Proof. The running time analysis is trivial. Next we prove the correctness of the algorithm.
Consider a vertex v ∈ V . If deg(v) ≤ ρ · log n, then v has at most O(log n) neighbors that
have selected the same color as v did, and we are done. Otherwise, for each neighbor u
of v, let Xu denote the random indicator variable, such that Xu = 1 if u selects the same
P
color as v, and Xu = 0 otherwise. Let X = u∈Γ(v) Xu be the sum of at most ∆ indicator
variables. The expected number of neighbors of v that select the same color as v is IIE(X) =
deg(v) 1
⌈deg(v)/(ρ·log n)⌉ ≤ ρ log n. Observe also that IIE(X) > 2 ρ log n, since deg(v) > ρ · log n. By
Chernoff bound for upper tails (see, e.g., [2], Chapter A.1), for any γ > 0, it holds that
 IIE(X)
eγ
P r[X > (1 + γ)IIE(X)] < .
(1 + γ)1+γ

We set γ ≥ 1. It holds that P r[X > 2IIE(X)] < (e/4)IIE(X) < 1/nc+1 , for a sufficiently large
constant ρ. By the union bound the probability that all vertices have at most 2ρ log n
neighbors with the same color is 1 − n/nc+1 = 1 − 1/nc . 2

10.2 A FASTER O(∆)-COLORING ALGORITHM

In this section we describe a more sophisticated algorithm that achieves a running time
√
of O( log n) for O(∆)-vertex-coloring. This result is due to Kothapalli et al. [47], but the
algorithm and the analysis that we present here are different from those of [47]. (Interest-
ingly, the algorithm in [47] can be extended within roughly the same running time while
communicating only single-bit messages between neighboring vertices. This is not the case
for the algorithm we present in this section.) The algorithm proceeds in two stages. The
first stage is similar to the algorithms described in the previous section, but it is performed
√
for O( log n) rounds instead of O(log n). It is probable that as a result some vertices do not
terminate by the end of this stage. Nevertheless, the subgraph of remaining vertices has,
with high probability, some helpful properties. These properties are used to complete the
solution in the second stage. Specifically, given an acyclic orientation of the input graph, in
the beginning of the second stage the length of the orientation restricted to the remaining
√
graph is O( log n) with high probability. This allows one to use Property 3.3 (see Section
3.3) for computing a (∆ + 1)-coloring of the remaining subgraph. If a fresh palette of size
(∆ + 1) is used in the second stage, a legal O(∆)-coloring for the entire input graph is
obtained.
The procedure for computing an O(∆)-coloring is called Fast-Rand-Color. It accepts
as input the graph G. In the first stage it computes an acyclic orientation by directing
 10.2. A FASTER O(∆)-COLORING ALGORITHM 113
all
 √edges towards endpoints with greater Ids. Then it invokes Procedure Rand-2Delta for
ρ log n rounds, for a sufficiently large constant ρ. In the second stage a (∆ + 1)-coloring is
computed using Property 3.3 on the subgrph of remaining vertices (that have not terminated
in the previous stage). This completes the description of the algorithm. Its pseudocode is
provided below.

Algorithm 21 Procedure Fast-Rand-Color(G)

An algorithm for each vertex v ∈ V .
1: for each neighbor u of v do
2: orient the edge (u, v) towards the endpoint with greater Id
3: end for
 √ 
4: for round R = 1, 2, ..., ρ log n do
5: execute an iteration of Rand-2Delta(G)
6: end for
7: if v has not terminated then
8: compute a coloring using the palette {2∆ + 1, 2∆ + 2, ..., 3∆ + 1} by using Property
3.3
9: end if

By the correctness of Procedure Rand-2Delta, it follows that Procedure Fast-Rand-

Color computes a legal O(∆)-coloring on the subgraph of vertices that terminate in the first
stage (lines 1-6). By Property 3.3, the coloring computed in the second stage (lines 7-9) on
the remaining vertices is a legal (∆ + 1)-colorings. Since the palettes used in the two stage
are disjoint, the final coloring is a legal (3∆ + 1)-coloring. For the running time analysis, it
is sufficient to show that in the beginning of the second stage all consistently-oriented paths
√
have length at most log n, with high probability. (In this case a (∆ + 1)-coloring can be
√
computed within√
at most log n rounds, by Property 3.3.) We will prove this for graphs
with ∆ < 2o( log n) . For graphs with larger degree, a slightly different algorithm (which will
be described in the sequel) provides the desired results.

Lemma
√
10.6 Suppose that Procedure Fast-Rand-Color is invoked on a raph G with ∆ <
2o( log n) . In the beginning of the second stage (lines 7-9 of Procedure Fast-Rand-Color)
√
all consistently-oriented paths have length at most log n with probability 1 − 1/nc , for an
arbitrarilly large constant c.

Proof.
√ Consider some consistently-oriented path P = hv1 , v2 , ..., vk i in G of length k =
log n (with respect to the orientation computed in lines 1-3). We show that with high
probability at least one vertex of P terminates during the first stage. Each vertex of P
terminates with probability at least 1/2 in each
 round, and remains active with probability
√
at most 1/2. In any given round R ∈ {1, 2, ..., ρ log n }, for i = 1, 2, ..., k, the probability
114 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

that vi remains active conditioned on that v1 , v2 , ..., vi−1 remain active in round R is at
least 1/2 as well. (One can assume without loss of generality that vi draws a color after
v1 , v2 , ..., vi−1 do so.) Thus the probabilitythat all vertices
 of P remain active during a single
√
round is at most 1/2k . For R ∈ {1, 2, ..., ρ log n }, the probability that all vertices of P
remain active in round R conditioned on that they all remain active  √ in rounds
 1, 2, ..., R − 1,
is 1/2k . Thus, the probability of all of them to remain for ρ log n rounds is at most
√
1/2k·⌈ρ log n⌉ ≤ 1/2ρ·log n = 1/nc+2 , for a constant ρ = c + 2.
√
The number of different paths of length k is at most n · ∆k ≤ n2 . (Recall that ∆ <
2o( log n) .) Thus, by the union bound, the probability that there exists
 a consistently-
√
oriented path of length k in which all vertices remain for ρ log n rounds is at most
n2 · (1/nc+2 ) = 1/nc . 2
√
To complete the analysis we need to consider the case that ∆ ≥ 2Ω( log n) . In this case
before executing Procedure Fast-Rand-Color, we invoke Procedure Rand-DC (see Algo-
rithm 20) that partitions the input graph into O(∆/ log n) vertex-disjoint subgraphs with
maximum degree O(log n). By Lemma 10.6, executing Procedure Fast-Rand-Color in all
these subgraphs in parallel results in an O(log n)-coloring in each of them with probability
1 − 1/nc . By using disjoint palettes, one obtains an O(∆)-coloring of the input graph. The
n
success probability is at least (1 − 1/nc ) > 1 − 1/nc−2 . We summarize this section with
the following theorem.
√
Theorem 10.7 An O(∆)-coloring of an input graph G can be computed in O( log n) time,
with probability 1 − 1/nc , for an arbitrarilly large constant c.

This result was recently improved in [11]. Specifically, Barenboim et al.√[11] devised a
randomized (∆ + 1)-coloring algorithm with running time O(log ∆) + 2O( log log n) . Prior
to this result Schneider and Wattenhofer [78] showed that O(∆ + log n)-coloring can be
constructed within O(log∗ n) randomized time. Combining these
√
two results [11] devised a
O( log log n)
randomized O(∆)-coloring algorithm with running time 2 .

10.3 RANDOMIZED MIS

10.3.1 A HIGH-LEVEL DESCRIPTION
√
In this section we describe a randomized algorithm √
that computes an MIS in O(log ∆ log n)
time. This result is due to [11]. Since for ∆ = 2Ω( log n) the algorithm of Luby [60] computes
√ √
an MIS in time O(log n) ≤ O(log ∆ log n), we henceforth assume that ∆ ≤ 2 log n . Before
we describe the algorithm we introduce a defenition that will be useful in this section.

Definition 10.8 Given a graph G = (V, E) and a vertex set C ⊆ V , the weak radius of
C with respect to a vertex v ∈ C, denoted wrad(C, v), is the maximum distance in G of a
 10.3. RANDOMIZED MIS 115
vertex u ∈ C from v. The weak radius of C, denoted by wrad(C), is given by

wrad(c) = min{wrad(C, v)}.

v∈C

The algorithm consists of two main stages. In the first stage it computes an indepen-
dent set I of the input graph G, which is, however, not necessarily maximal. Nevertheless,
with high probability, it satisfies some very helpful properties. Next, the vertices of I and
their neighbors are removed from G. Let G′ be the subgraph induced by the set of remaining
vertices. In the second stage an MIS I ′ of G′ is computed. (Observe that I ∪ I ′ is an MIS of
G.) This computation relies upon properties that hold with high probability after the first
stage. Specifically, with high probability, all connected components of G′ have weak radius
√ √
O( log n). Consequently, an MIS of G′ can be computed in O( log n) time.
We start with presenting a high-level description of the algorithm. Initially all vertices
are active. During an execution vertices become inactive. In the beginning an empty set U
is initialized. During the execution certain active vertices join U . The vertices join in such
a way that the set U remains independent throughout the entire execution, and it is an
MIS once the execution terminates. A vertex becomes inactive if it joins U , or if at least
one of its neighbors joins U . The algorithm terminates once all vertices become inactive.
Suppose first that we are given a procedure Decide() that is executed by each vertex
and requires one round. Procedure Decide satisfies the following four properties: (1) After
a single execution of Procedure Decide by all vertices, each vertex becomes inactive with
probability at least ρ, for a constant 0 < ρ < 1. (2) For a vertex v, denote by E(v) the event
that v becomes inactive as a result of invoking Procedure Decide by all vertices in the same
round. For any subset of vertices X ⊆ V , such that for any pair x, x′ of distinct vertices
from X, it holds that distG (x, x′ ) ≥ 5, the events {E(x) | x ∈ X} are mutually independent.
(3) If a pair of active neighbors execute Procedure Decide, at most one of them joins U
(even if these executions are performed in distinct rounds). (4) If in a certain round a vertex
v decides to join U , then in that round all its neighbors decide not to join. (Consequently,
v and all its neighbors become inactive.)
Denote λ = ⌊log n⌋. In the first stage the algorithm executes Procedure Decide() for
√
d · λ = O( log n) rounds, for a positive constant d to be determined later. In each of these
rounds it is executed on the set of remaining active vertices. Let V ′ denote the set of
remaining active vertices once the first stage completes. In the second stage, it computes
an MIS of the set V ′ as follows. Denote the graph induced by V ′ by G′ = G(V ′ ). Each
active vertex v collects the topology of the connected component in G′ that contains v, and
computes an MIS of this connected component locally. By the ”topology” of a vertex set
Z ∈ V we mean the identities of all vertices of Z, the edge set E(Z), and all local variables
of vertices in Z. This completes the high-level description of the algorithm. Its pseudocode
is provided below.
116 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

Algorithm 22 A high-level description of the randomized MIS algorithm

An algorithm for each vertex v ∈ V . Initially, all vertices are active.
√ 
1: for i = 1, 2, ..., d · log n do
2: if v is active then
3: Decide()
4: end if
5: end for
6: if v is active then
7: Denote by G′ the subgraph induced by all active vertices
8: G′v := collect the topology of the connected component in G′ that contains v
9: Compute an MIS of G′v locally
10: end if

We assume that all vertices of a connected component G′v run locally the same cen-
tralized deterministic procedure Central-MIS for computing an MIS. Since any two vertices
u, w in G′v collect the same topology on line 8 of Algorithm 22, their inputs to Procedure
Central-MIS are identical. Thus executions of Procedure Central-MIS on different vertices
of G′v produce the same output. Hence the MIS is computed in a consistent way by different
vertices of the same connected component. Finally, each vertex v ∈ G′v selects the output
for v based on the output for v of Procedure Central-MIS invoked on G′v .
The correctness of the algorithm follows from the fact that in the first stage (lines
1 - 5) all inactive vertices are either belong to U , or have a neighbor in U . In addition,
by property (3) of Procedure Decide, no two neighbors can join U . In the second stage
(lines 6-10) an MIS is computed on connected components of the graph G′ induced by the
remaining active vertices. Hence each vertex in G′ either joins U , or has a neighbor in its
connected component that joins U . Moreover, any pair of vertices that belong to distinct
connected components and join U , are not connected by an edge. Therefore, all vertices of
G either belong to U or have neighbors that belong to U , and no two neighbors in G join
U . (A pair of vertices that join U in distinct stages are not connected, because all neighbors
of a vertex that joins in the first stage do not join. This is guaranteed by property (4) of
Procedure Decide.) Therefore, U is an MIS. We summarize this discussion in the following
theorem.

Theorem 10.9 Algorithm 22 computes a Maximal Independent Set of G.

Next, we analyze the running time of the algorithm. We will show that all connected
√
components of G′ have weak diameter at most log n with high probability. In other words,
√
for any pair of vertices u, v, such that distG (u, v) > log n, there is no path in G′ connecting
u and v. Consequently, each vertex can collect the entire information of its connected
√
component in O( log n) time. The next lemma analyzes the probability that all vertices
 10.3. RANDOMIZED MIS 117
on a certain path remain active after a certain number of rounds. (Recall that E(v) is the
event that a vertex v becomes inactive as a result of executing Procedure Decide, and ρ is
a lower bound on the probability that E(v) occurs, for any v ∈ V .)
Lemma 10.10 Let P be a path in G that contains k vertices u1 , u2 , ..., uk , such that
E(u1 ), E(u2 ), ..., E(uk ) are independent. Suppose also that all vertices execute Procedure
Decide for ℓ rounds. Then the probability that all the vertices of P remain active is at most
(1 − ρ)k·ℓ .
Proof. Since the events are independent, the probability that u1 , u2 , ..., uk remain active
in a single round is at most (1 − ρ)k . We now prove the assertion of the lemma by induction
on ℓ. The induction base, ℓ = 1, was already shown. For the induction step observe that the
probability that u1 , u2 , ..., uk survive (i.e., remain active) for ℓ rounds conditioned on them
surviving for ℓ − 1 rounds is Πki=1 IIP(E(ui )) ≤ (1 − ρ)k . This completes the proof. 2
√
Suppose that a path contains k ≥ 1/5 · log n vertices u1 , u2 , ..., uk , such that the events
E(u1 ), E(u2 ), ..., E(uk ) are independent. Then the probability that all vertices u1 , u2 , ..., uk
√
remain active for d · log n rounds is at most
√ √ ′
(1 − ρ)1/5· log n·d· log n
= ((1 − ρ)log n )d/5 ≤ 1/nc ,

for c′ = c′ (d). The exponent c′ can be made as large as one wishes, by increasing√the value
of d. (Recall that (1 − ρ) ≤ 1 is a positive constant.)
√ Note also that since
√
∆ ≤ 2 log n , the
log n
number of different paths in G of length µ = log n is at most n · ∆ = O(n2 ).
Let P be the set containing all the paths P in G of length µ that satisfy the following
√
property: the path P contains k ≥ 1/5 · log n vertices u1 , u2 , ..., uk , such that the events
E(u1 ), E(u2 ), ..., E(uk ) are independent. By the union bound, the probability that after the
′ ′′
first stage there remains a path in P in which all vertices are active is O(n2 /nc ) ≤ 1/nc ,
for an arbitrarily large constant c′′ > 0. However, this fact by itself is insufficient to show
that all connected components of G′ (the graph induced by the active vertices remaining
√
after the first stage) have weak diameter O( log n). We next prove a stronger claim that
√
says that for each pair of vertices u, v such that distG (u, v) ≥ log n, there is no path in
G′ connecting u and v.
Definition 10.11 A sequence Q = (q0 , q1 , ..., qk ) of vertices is called a well-spread sequence
if there exists a path R = (r0 , r1 , ..., r5k ) in G = (V, E) such that the following two conditions
hold:
(1) For every index j ∈ [0, k], it holds that r5j = qj .
(2) For every pair of distinct indices i, j ∈ [0, k], it holds that distG (qi , qj ) ≥ 5.
Lemma 10.12 Let P be a simple path between a pair of vertices u, v ∈ V with distG (u, v) ≥
5k, for some integer k ≥ 0. Then P contains a well-spread sequence Q ⊆ V (P ) of length
|Q| = k + 1.
118 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

Figure 10.1: Obtaining the path hr0 , r1 , ..., r5k i. The vertex rj+5 equals to wr′ , for the maxi-
mum r′ such that distG (rj , wr′ ) = 5. The path P is depicted by a thick line.

Proof. Denote P = (u = w0 , w1 , ..., v = wt ), t ≥ 5k. The proof is by induction on k.

Base (k = 0): Set Q = (q0 = w0 ), R = (r0 = q0 = w0 ). This completes the proof of
the induction base.
Step (k ≥ 1): Let i be the largest index such that distG (w0 , wi ) = 5.
It follows that distG (wi , wt ) ≥ distG (w0 , wt ) − distG (w0 , wi ) ≥ 5(k − 1). Let σ = (r0 =
w0 , r1 , r2 , r3 , r4 , r5 = wi ) be an arbitrary shortest path between w0 and wi in G. Let
P ′ = (wi , wi+1 , ..., wt ). Denote also q0 = w0 . By the choice of i, for every index j ∈
[i, t], distG (q0 , wj ) ≥ 5. By the induction hypothesis, there exists a well-spread sequence
Q′ = (q0′ , q1′ , ..., qk−1
′
), Q′ ⊆ V (P ′ ). Hence there exists a path R′ = (r0′ , r1′ , ..., r5(k−1)
′
) with
r5j = qj , for every j ∈ [0, k − 1]. We form the well-spread sequence Q = (q0 ) ◦ Q′ , by con-
′ ′

catenating the sequence (q0 ) with the sequence Q′ . The respective path R is formed by
R = σ ◦ R′ . Observe that qj+1 = qj′ , for every index j ∈ [0, k − 1], and r5+i = ri′ , for every
i ∈ [0, 5(k − 1)]. See Figure 10.1 for an illustration.
By induction hypothesis, for every pair of distinct indices i, j ∈ [1, k], distG (qi , qj ) =
′ ′ ′
distG (qi−1 , qj−1 ) ≥ 5. Also, since for every index j ∈ [1, k], qj = qj−1 ∈ V (P ′ ), it follows
that distG (q0 , qj ) ≥ 5 as well. 2

Recall that for a well-spread sequence Q = (q0 , q1 , ..., qk ), the events {E(qj ) | j ∈ [0, k]}
are mutually independent. (See the properties of Procedure Decide in the beginning of this
section.)

Corollary 10.13 A path P that satisfies the conditions from the assertion of Lemma 10.12
contains a sequence Q ⊆ V (P ), Q = (q0 , q1 , ..., qk ) such that the events {E(qj ) | j ∈ [0, k]}
are mutually independent.
 10.3. RANDOMIZED MIS 119
√ 
Let R denote the set of all paths of length µ = log n in G = (V, E). Let Q′ denote
the set of well-spread sequences of length ⌊µ/5⌋. Observe that |R| ≤ n · ∆µ ≤ n2 , and so
|Q′ | ≤ n · ∆µ ≤ n2 (10.1)
as well. The probability that after the first stage there remains a path P that connects
two vertices at distance at least µ whose all vertices are active is at most the probability
that there remains a well-spread sequence Q ∈ Q′ of length ⌊µ/5⌋ with all vertices active.
′′
The latter probability is at most 1/nc , for an arbitrary large constant c′′√> 0. (Because
√
the probability of all these vertices to remain active is at most (1 − ρ)1/5· log n·d· log n =
((1 − ρ)log n )d/5 , for a large constant d.) Hence, after the first stage, with high probability,
there is no path P in G consisting of active vertices, that connects a pair of vertices u, v such
√
that distG (u, v) ≥ log n. Thus, the graph G′ induced vertices that remain active after the
√
first stage has weak diameter smaller than log n, with high probability. We summarize
this discussion in the following lemma.
Lemma 10.14 After the first stage of Algorithm 22 (lines 1 - 5) the weak diameter of
√
the subgraph G′ induced by the remaining active vertices is smaller than log n, with high
probability.
√
For a graph G′ with weak diameter K < log n, an MIS is computed within K rounds in the
following way. For i = 1, 2, ..., K, suppose that before the beginning of round i, each vertex
v knows its entire (i − 1)-hop neighborhood Γ̂i−1 (v, G) with respect to G. On round i, each
vertex v sends the representation of G(Γ̂i−1 (v, G)) to all its neighbors in G. Once v receives
a message from all its neighbors it computes the representation of G(Γ̂i (v, G)). In round
k̂ each vertex v computes the representation of G(Γ̂K (v, G)). Denote by G′v the connected
component of v in G′ . For any u ∈ G′v it holds that distG (v, u) ≤ K. Therefore u ∈ Γ̂K (v).
Hence G′v is a subgraph of the graph G(Γ̂K (v, G)) induced by Γ̂K (v, G). Next, v computes
G′v from Γ̂K (v), and runs a deterministic local centralized algorithm for computing an
MIS on G′v . All vertices in G′v perform the same local deterministic computation (run
Procedure Central-MIS), resulting in an identical MIS of G′v for all vertices in this connected
component. In particular, for each vertex in G′v this computation determines whether it
should join the MIS.
To summarize, the second stage of Algorithm 22 (lines 6 - 10) requires, with high
√
probability, O( log n) time as well. We summarize the properties of Algorithm 22 in the
following theorem.
Theorem 10.15 Given Procedure Decide that satisfies the four properties mentioned above
√
and has running time τ , Algorithm 22√computes an MIS in O( log n · τ ) time, for an input
graph G with maximum degree ∆ ≤ 2 log n .
√ √
As was mentioned above, for ∆ > 2 log n the running time of O(log ∆ · log n) follows
trivially from Luby’s logarithmic bound of O(log n).
120 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

10.3.2 PROCEDURE DECIDE

In this section we describe a variant of Procedure Decide that is used in conjunction with
Algorithm 22. This variant, however, does not compute an MIS for the entire input graph,
but rather for the subraph of G induced by vertices with degree at least ∆/2. (Although
the MIS may include some vertices of G with smaller degrees.) This computation eliminates
the vertices with large degrees, and the residual subgraph has maximum degree at most
∆/2. This stage is repeated for log ∆ iterations to eliminate all vertices. As a result we
obtain an MIS for the entire input graph.
Procedure Decide accepts an input a parameter γ > 1. It draws a biased random bit,
1 1
with 1 having probability γ+1 , and 0 having probability 1 − γ+1 . Denote this probability
distribution by D(γ). Each vertex sends its random bit to all its neighbors. Once a vertex
receives the bits of all its neighbors, it decides to join the MIS (and becomes inactive) if it
has drawn 1 and all its neighbors have drawn 0. In this case its neighbors decide not to join,
and become inactive as well. If a vertex does not decide to join, and none of its neighbors
decides to join, then it remains active. This completes the description of the procedure. Its
pseudocode is provided below.

Algorithm 23 Procedure Decide(γ)

An algorithm for each vertex v ∈ V .
1: b := draw a bit from D(γ)
2: send b to all neighbors
3: for all active neighbors u of v in parallel do
4: bu := receive a bit from u
5: end for
6: if b = 1 and for all active neighbors u of v it holds that bu = 0 then
7: v joins the MIS
8: v sends ”joined MIS” to all neighbors and becomes inactive
9: end if
10: if v receives the message ”joined MIS” from a neighbor then
11: v does not join the MIS and becomes inactive
12: end if

Next, we describe a variant of Algorithm 22 that employs Procedure Decide. This

algorithm is called Procedure Compute-MIS. The algorithm proceeds in phases. For j =
0, 1, ..., ⌊log ∆⌋, in phase j the algorithm invokes Procedure Decide with the parameter
√
γ = ∆/2j for O( log n) times. As a result, with high probability, all connected compo-
nents in the subgraph induced by active vertices with sufficiently large number of active
√
neighbors have weak diameter O( log n). (Specifically, it holds for the subgraph induced
by active vertices with at least γ/2 active neighbors each. Henceforth, we call the number
 10.3. RANDOMIZED MIS 121
of active neighbors of a vertex v the active degree of v, and denote it actdeg(v).) Next, an
MIS is computed in these connected components, and all their vertices become inactive.
Consequently, the remaining active vertices induce a subgraph with maximum degree at
most γ/2. After phase ⌊log ∆⌋, with high probability, all remaining active vertices have
active degree 0. Thus, they constitute an independent set. All these remaining vertices join
the MIS, and the algorithm terminates. The pseudocode of Procedure Compute-MIS is
provided below.

Algorithm 24 Procedure Compute-MIS()

An algorithm for each vertex v ∈ V . Initially, all vertices are active.
1: for j = 0, 1, ..., ⌊log ∆⌋ do
2: γ = ∆/2j √ 
3: for i = 1, 2, ..., d · log n do
4: /* d is a large constant */
5: if v is active then
6: Decide(γ) /* See Algorithm 23 */
7: end if
8: end for
9: if v is active then
10: Denote by G′ the subgraph induced by active vertices u with actdeg(u) ≥ γ/2
11: if v ∈ G′ then
12: G′v := collect the topology of the connected component in G′ that contains v
13: Compute an MIS of G′v locally
14: end if
15: if v joins the MIS or a neighbor of v joins the MIS then
16: v becomes inactive
17: end if
18: end if
19: end for
20: if v is active and has no active neighbors then
21: v joins the MIS and becomes inactive
22: end if

Observe that if at the beginning of iteration j of the external for-loop of Algorithm 24

(lines 1-19) (henceforth, phase j), for j = 0, 1, ..., ⌊log ∆⌋, the graph induced by the active
vertices has maximum degree γj = ∆/2j , then in the end of phase j the graph induced by
the active vertices has maximum degree at most γj /2. (Because an MIS is computed on the
subgraph G′ induced by the active vertices that have at least γj /2 active neighbors each.
See lines 10-14 of Algorithm 24. Consequently, all vertices of G′ become inactive.) Thus,
122 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

once the algorithm terminates, no active vertices remain. This implies the correctness of
the algorithm, because each inactive vertex either belongs to the MIS or has a neighbor in
the MIS, and no two neighbors join the MIS. This discussion is summarized in the following
theorem.
Theorem 10.16 Procedure Compute-MIS computes an MIS of the input graph.
For the procedure to be efficient, collecting the information of connected components should
√
require log n rounds. Thus, the following requirement√ to
 Algorithm 24 has to be added.
Line 12 of Algorithm 24 must terminate in µ = log n rounds. If it does not terminate
on time, then the algorithm fails to produce an MIS. Fortunately, it is possible to show that
with high probability all such computations terminate on time. To this end we will show
that with high probability weak diameters of all connected components in G′ are smaller
√
than log n, for anyphase j.  (Observe also that if this is indeed the case, then the vertices
√
can devote exactly log n rounds for performing lines 9-18. Consequently, all vertices
start a phase j in the same time, for all j = 0, 1, ..., ⌊log ∆⌋.)
Let Ĝj denote the subgraph induced by the vertices that are active in the beginning
j
of phase j, and that have active degree at least γj /2 = ∆/2
2 . The maximum degree of Ĝj
is at most γj . First, we show that Procedure Decide that accepts γj as input satisfies the
following four required properties.
Lemma 10.17 Suppose that Procedure Decide(γj ) is executed by all active vertices. Then
the following four assertions hold.
(1) Each vertex v in Ĝj becomes inactive with probability ρ, for a constant 0 < ρ < 1.
(2) For any well-spread sequence Q = (u1 , u2 , ...uk ) ⊆ V , for some integer k > 0, the events
E(u1 ), E(u2 ), ..., E(uk ) are independent.
(3) If a pair of active neighbors execute Procedure Decide, at most one of them joins the
MIS.
(4) If a vertex v decides to join the MIS, then all its neighbors decide not to join. Conse-
quently, v and all its neighbors become inactive.
Proof. (1) A vertex v ∈ Ĝj has k active neighbors, for some integer k, γj /2 ≤ k ≤ γj . The
vertex v becomes inactive if either it joins the MIS or one of its neighbors joins the MIS.
In other words, it becomes inactive if either (a) v draws bv = 1 and all its active neighbors
draw 0, or (b) v draws bv = 0, an active neighbor w of v draws bw = 1, and all the active
neighbors of w draw 0.
Denote by {w1 , w2 , ..., wk } the set of active neighbors of v. Denote γ = γj . First, we
compute the probability that exactly one of the vertices {v, w1 , w2 , ..., wk } draws 1 and all
the rest draw 0. We denote this event by E. The probability of E is
 k    γ+1
1 1 γ 1 1 1
IIP(E) = (k + 1) · · 1− ≥ +1 · · 1− ≥ .
γ+1 γ+1 2 γ+1 γ+1 8
 10.3. RANDOMIZED MIS 123

Figure 10.2: In this example w2 is the only vertex in Γ̂(v) that has drawn 1. All its neighbors
z1 , z2 , ..., zγ have drawn 0.

Consider a vertex w ∈ {v, w1 , w2 , ..., wk }. Let E ′ (w) denote the event that all active neigh-
bors of w that are not in {v, w1 , w2 , ..., wk } have drawn 0. The probability of E ′ (w) is
 γ
′ 1
IIP(E (w)) ≥ 1 − ≥ 1/4. (10.2)
γ+1

See Figure 10.2 for an illustration.

Recall that bw denotes the bit that w has drawn. Observe that

IIP(v becomes inactive) ≥ IIP(E ∧ (∃w such that ((bw = 1) ∧ E ′ (w))))

= IIP(∃w such that ((bw = 1) ∧ E ′ (w)) | E) · IIP(E)
1
≥ · IIP(∃w such that ((bw = 1) ∧ E ′ (w)) | E).
8
Observe that conditioned on E, there necessarily exists a vertex w ∈ {v, w1 , w2 , ..., wk }
with bw = 1. Also, by (10.2), for this vertex w it holds that IIP(E ′ (w)) ≥ 1/4. Hence

IIP(∃w such that ((bw = 1) ∧ E ′ (w)) | E) ≥ 1/4.

Hence IIP(v becomes inactive ) ≥ 1/32. Hence the first assertion holds with ρ = 1/32.
(2) The decision of a vertex q ∈ {u1 , u2 , ..., uk } whether to become inactive depends
only on bits drawn by vertices from its 2-neighborhood Γ̂2 (q). Therefore, the event E(q) that
q becomes inactive is independent from each of the events E(x) for x ∈ {{u1 , u2 , ..., uk } \ q},
since each of these vertices x is at distance at least 5 from q in G. (Hence Γ̂2 (q) ∩ Γ̂2 (x) = ∅.)
124 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

(3) A vertex joins the MIS only if it draws 1 and all its neighbors draw 0. Therefore,
a pair of neighbors cannot join the MIS.
(4) By description of Procedure Decide, if a vertex v decides to join the MIS, then
all its neighbors decide not to join. 2
Next, we show that all connected components in G′ (which is defined in line 10 of
√
Algorithm 24) have weak diameter smaller than log n with high probability. (This does
not follow directly from Lemma 10.14, because Ĝj does not contain all active vertices of G
in the beginning of phase j. Rather it contains only those of them that have active degree at
least γj /2. Therefore, certain modifications in the proof are required. However, the general
idea of the proof is similar to that of Lemma 10.14.)
Lemma 10.18 For j = 0, 1, ..., ⌊log ∆⌋, and γ = γj = ∆/2j , in phase j of Algorithm 24,
consider the graph G′ induced by the active vertices that have active degree at least γj /2.
(See line 10 of Algorithm 24.) All connected components of G′ have weak diameter smaller
√
than log n, with high probability.
Proof. Consider the subgraph Ĝj of vertices that are active in the beginning of iteration
j and that have at least γj /2 active neighbors each. The graph G′ which was mentioned
in the statement of this lemma is the graph obtained from Ĝj by running the internal
for-loop (lines 3-8) of Algorithm 24 on iteration j of the external for-loop (lines 1-19)
of the
√algorithm.
 Recall that Q′ is the set of all well-spread sequences of length ⌊µ/5⌋,
µ= log n . Recall also that by (10.1), it holds that |Q′ | = O(n2 ). By Lemma 10.12, for
√
any pair of vertices u, v ∈ V (Ĝj ), such that distG (u, v) ≥ log n ≥ µ, and any path P in
Ĝj that connects u and v, there exists a well-spread sequence Q ∈ Q′ of length ⌊µ/5⌋ with
Q ⊆ V (P ). Also, by Corollary 10.13, the events {E(q) | q ∈ Q} are mutually independent.
Thus, by union bound, the probability that after d · µ iterations there remains a well-
spread sequence Q ∈ Q′ , Q ⊆ V (P ), whose all vertices q ∈ Q are active and have at least
γj /2 active neighbors each is at most O(n2 ) · (1 − ρ)d·µ·⌊µ/5⌋ .
Let c′ be an arbitrarily large constant. For a sufficiently large constant d it holds that
′
1
O(n ) · ((1 − ρ)log n )d/5 ≤ 1/nc . (Recall that ρ = 32
2
. See the proof of Lemma 10.17 (1).)
Therefore, once the internal for-loop of Algorithm 24 (lines 3-8) is completed, with high
probability, no path P that satisfies all the following properties survives. (a) All vertices of
P are active, (b) each vertex of P has at least γj /2 active neighbors, and (c) the endpoints of
√
P have distance (in G) at least log n one from another. Therefore, in line 10 of Algorithm
√
24, all connected components of G′ have weak diameter smaller than log n with high
probability. 2
Lemma 10.18 implies that, with high probability, a single phase of Algorithm 24 (that
is, a single iteration of the external for-loop, lines 1-19 of Algorithm 24) terminates success-
fully within d · µ + µ rounds, for a constant d. Specifically, lines 3-8 require at most d · µ
rounds, and lines 9-18 require at most µ rounds. Next, we analyze the success probability
 10.4. RANDOMIZED MAXIMAL MATCHING 125
′ ′
of the entire algorithm. Let c be an arbitrarily large constant. For any ĉ > c , for a suf-
′
ficiently large n, it holds that (1 − 1/nĉ )log ∆ ≥ 1 − 1/nc . Thus, with probability at least
′
1 − 1/nc , for an arbitrarily large constant c′ , all phases
√ complete
 successfully within overall
time ⌊log ∆⌋ · (d · µ + µ) + O(1). Recall that µ = log n . We summarize this discussion
in the following theorem.

Theorem 10.19 Procedure Compute-MIS computes, with high probability, an MIS of a

√
log n
√
graph G with degree ∆ ≤ 2 in time O(log ∆ log n).
√
We remark that when ∆ > 2 log n , the running time of the algorithm of Luby [60] is
√
O(log n) = O(log ∆ log n). Hence we derive the following corollary.

Corollary 10.20 An MIS on n-vertex graphs wiht maximum degree at most ∆ can be
√
computed, with high probability, within O(log ∆ log n) time.

The above result is due to [11]. It is also shown in [11] that if ∆ is at most
√
polylogarithmic in
n, then an MIS can be computed, with high probability, in time 2O( log log n) . We remark
that that the algorithm for computing MIS that was described in this section requires
sending large messages. This is also the case for the MM algorithm presented in the next
section. Devising algorithms with a similar time complexity that employ only short (say,
log n-bit sized) messages is an open problem.

10.4 RANDOMIZED MAXIMAL MATCHING

In this section we describe a randomized Maximal Matching algorithm due to [11] with
√
running time O( log n + log ∆), for graphs with maximum degree ∆, for the entire range
1 ≤ ∆ ≤ n. The general framework of the algorithm is similar to Algorithm 22 (Section
10.3.1). In the first stage vertices execute a procedure, called Procedure Decide-Match, for
√
O( log n + log ∆) rounds. In each round some edges are matched, and become inactive.
Edges incident to the matched ones become inactive as well. A vertex becomes inactive once
all the edges it belongs to become inactive. Thus, once an edge is matched, its endpoints
become inactive.
Like in Section 10.3, here too we refer to the number of active edges incident on a
vertex as its active degree. Procedure Decide-Match guarantees that the active degree of a
vertex is reduced by a multiplicative constant factor in each round, with high probability,
for sufficiently large degrees. Once the first stage completes, with high probability, all con-
nected components of the subgraph induced by active vertices with sufficiently large degree
√
have weak diameter O( log n + log ∆). The subgraph induced by remaining active vertices
satisfies certain properties. These properties enable us to compute a Maximal Matching
√
of this subgraph within additional O( log n + log ∆) time. The pseudocode of Procedure
Decide-Match is provided below.
126 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

Algorithm 25 Procedure Decide-Match()

An algorithm for each vertex v ∈ V .
1: Initialize the forest F1 and the matching MM by F1 := ∅ and MM := ∅
2: Select uniformly at random an active neighbor u of v, and add the arc hv, ui to F1
3: /* We say that v selected u. */
4: if v has indegree at least 1 in F1 then
5: /* if v is selected */
6: Select an arbitrary incoming neighbor w, and insert the arc hw, vi into F2
7: /* F2 is a vertex disjoint set of oriented paths and cycles. */
8: end if
9: Toss a random bit b(v)
10: if b(v) = 0 and there is an edge hv, ui in F2 such that b(u) = 1 then
11: hv, ui joins M M
12: hv, ui and all edges incident on it become inactive
13: end if

Next, we describe Procedure Compute-MM that employs Procedure Decide-Match to

compute a Maximal Matching of the input graph G. First, it completes the first stage,
in which Procedure Decide-Match is invoked in each round. Next, it computes a Maximal
Matching of the subgraph G′ of active vertices with active degrees greater than ∆′ , for
a parameter ∆′ that will be determined later. In the sequel we show that the subgraph
√
G′ has weak diameter O( log n + log ∆), with high probability. This property enables us
√
to compute a Maximal Matching of G′ in O( log n + log ∆) time. After this stage the
subgraph induced by the set X of yet remaining active vertices decomposes as X = Z ∪ Y ,
where Z is an independent set of unmatched vertices which are left after the previous
stages, and Y is a set of vertices that induce a subgraph with maximum active degree
at most ∆′ . In the sequel we show that a Maximal Matching for X can be computed in
O(∆′ + log∗ n) time. The procedure that computes a maximal matching for such a graph
will be called Procedure Complete-MM. Once it is computed, all vertices and edges become
inactive, and the algorithm terminates. The pseudocode of the procedure Compute-MM is
√
provided below. The notation f (n, ∆) stands for max{ log n, log ∆}.
 10.4. RANDOMIZED MAXIMAL MATCHING 127

Algorithm 26 Procedure Compute-MM(∆′ )

An algorithm for each vertex v ∈ V . Initially, all vertices and edges are active.
1: ℓ := ⌊cℓ · f (n, ∆)⌋ /* cℓ is a large constant */
2: for i = 1, 2, ..., ℓ do
3: if v is active then
4: Decide-Match()
5: end if
6: end for
7: if v is active then
8: Denote by G′ the subgraph induced by active vertices u, with actdeg(u) > ∆′
9: /* The parameter ∆′ will be determined in the sequel */
10: if v ∈ G′ then
11: G′v := collect the topology of the connected component in G′ that contains v
12: Compute a Maximal Matching M of G′v locally
13: end if
14: if v belongs to an edge e that joins the Maximal Matching (i.e., e ∈ M ) then
15: The vertex v and all edges that are incident on it become inactive
16: end if
17: end if
18: Compute a Maximal Matching of the remaining active edges (by Procedure Complete-
MM that will be described in the sequel)

In what follows we show that once the first stage (lines 1-6 of algorithm 26) com-
pletes, all connected components in the subgraph G′ (defined in line 8) have weak di-
ameter O(f (n, ∆)), with high probability. The main idea is that the probability that the
active degree of a vertex v remains greater than ∆′ = Θ(f (n, ∆)) after ℓ = ⌊cℓ · f (n, ∆)⌋
rounds is, roughly speaking, exp{−ℓ} = exp{− ⌊cℓ · f (n, ∆)⌋}. Consequently, the proba-
bility that for a path P̂ connecting the vertices u, v such that distG (u, v) ≥ f (n, ∆), all
vertices
 of P̂ have active degrees greater than ∆′ , is at most p = exp{−ℓ · f (n, ∆)} =
√
exp −cℓ · max{ log n, log ∆}2 . The number of different paths of length f (n, ∆) in G
is at most D = n · ∆f (n,∆) = exp{log n + log ∆ · f (n, ∆)}. Hence, by the union bound, the
probability that some path P̂ as above survives is at most p · D ≤ 1/poly(n).
We will use the following variant of Chernoff’s bound (see, e.g., [2], Chapter A.1).

Theorem 10.21 Let Y be the sum of mutually independent indicator random variables,
with µ = IIE(Y ). Let t ≥ µ be a real. Then for all ǫ > 0,

IIP(Y > µ + ǫ(t + 1)) < 2 · exp{−cǫ · t},

where cǫ > 0 depends only on ǫ.

128 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

For a fixed vertex v ∈ V and index i ∈ [ℓ] of an iteration, let deg(i) (v) denote the
active degree of v at the beginning of iteration i. We say that v is in Case 3 in iteration i if
during iteration i the active degree of v becomes smaller than ∆′ . We say that v is in Case
1 in iteration i if it is not in Case 3, and the number of neighbors of v that were selected
in iteration i by some vertex other than v is at least deg(i) (v)/2. (See line 2 of Algorithm
25 for the definition of ”selected”.) If in iteration i the vertex v is not in Case 3 and not in
Case 1, we say that v is in Case 2 in iteration i.
For an active vertex u at the beginning of iteration i, let Ii+1 (u) be the indicator
random variable which is equal to 1 if u survives the i th iteration (i.e., does not get
matched on this iteration).
Denote by Γ(i) (v) the set of (immediate) active neighbors of v at the beginning of
iteration i. By definition, |Γ(i) (v)| = deg(i) (v).
Denote by Si (v) (respectively, Ui (v)) the subset of Γ(i) (v) of neighbors of v that were
selected (resp., were not selected) on iteration i by some vertex other than v. If the vertex
v is in Case 1 in iteration i, then |Si (v)| ≥ deg(i) (v)/2.
Next, we analyze the probability that the active degree of a vertex in Case 1 or Case
2 is reduced by some multiplicative factor.
Case 1
In this section we assume that the vertex v is in Case 1 in iteration i.
Consider a pair of distinct neighbors u, u′ ∈ Si (v), u 6= u′ , of v. If u and u′ belong
to different connected components (i.e., paths of cycles) of F2 , then Ii+1 (u) and Ii+1 (u′ )
are independent random variables. Moreover, if u and u′ belong to the same connected
component of F2 and the distance between them in F2 is at least 3, then these random
variables are independent as well.
Next, we construct a subset Si′ (v) ⊆ Si (v) of neighbors of v, such that the set
{Ii+1 (u) | u ∈ Si′ (v)} of their respective random variables is independent. The set Si′ (v)
is initialized as an empty set. Then we pick an arbitrary neighbor u ∈ Si (v) of v and add
it to Si′ (v). Also, all other neighbors u′ ∈ Si (v) of v that are at distance at most 2 from
u in F2 are removed from Si (v). We iterate this until the set Si (v) becomes empty. (We
remark that the set Si′ (v) is constructed only for the analysis. The algorithm itself does not
construct this set.)
It is easy to see that the set {Ii+1 (u) | u ∈ Si′ (v)} is a set of independent random
variables. Moreover, since the degree of any vertex in F2 is at most 2, the size s′i (v) of
Si′ (v) is at least a constant fraction of the size si (v) of Si (v). Specifically, s′i (v) ≥ si (v)/5.
Since the vertex v is in Case 1 in iteration i, it follows that si (v) ≥ deg(i) (v)/2, and so
s′i (v) ≥ deg(i) (v)/10.
The degree of v after iteration i, deg(i+1) (v), satisfies
X X
deg(i+1) (v) ≤ Ii+1 (u) ≤ ′
Ii+1 (u) , (10.3)
u∈Γ(i) (v) u∈Γ(i) (v)
 10.4. RANDOMIZED MAXIMAL MATCHING 129
where 
′ 1, u ∈ Γ(i) (v) \ Si′ (v),
Ii+1 (u) = (10.4)
Ii+1 (u), u ∈ Si′ (v).
Observe that when u ∈ Si′ (v), the random variable Ii+1′
(u) depends upon the random bit
b(u) and upon at most two additional random bits b(x) and b(y), where x and y are the
neighbors of u in (an unoriented version of) F2 . (Since each connected component of F2 is
a path or cycle, u has at most 2 neighbors in F2 .)
Denote by X
deg′(i+1) (v) = ′
Ii+1 (u). (10.5)
u∈Γ(i) (v)

By (10.3), deg′(i+1) (v) stochastically dominates deg(i+1) (v). Then

X
deg′(i+1) (v) = (deg(i) (v) − s′i (v)) + ′
Ii+1 (u) .
u∈Si′ (v)

Hence X
IIE(deg′(i+1) (v)) = (deg(i) (v) − s′i (v)) + ′
IIE(Ii+1 (u)) .
u∈Si′ (v)

(The expectation above is taken over the random bits that determine random variables
′
Ii+1 (u), for u ∈ Si′ (v). In other words, on this stage deg(i) (v) and s′i (v) are already fixed.)
For u ∈ Si′ (v), IIE(Ii+1
′ ′
(u)) = IIP(Ii+1 (u) = 1). It is easy to verify that if u has two
neighbors in F2 then this probability is 1/2, and if it has just one neighbor (i.e., if it is an
endpoint of a path) then this probability 3/4. Hence IIE(deg′(i+1) (v)) = deg(i) (v) − s′i (v)(1 −
ρ), for 1/2 ≤ ρ ≤ 3/4. Since v is in Case 1 in iteration i, it follows that s′i (v) ≥ deg(i) (v)/10.
Hence
9+ρ 39
IIE(deg′(i+1) (v)) ≤ deg(i) (v) ≤ deg(i) (v) . (10.6)
10 40
This completes the analisys for case 1.
Case 2
Next, we consider a vertex v that is in Case 2 in iteration i.
In this case v has at least deg(i) (v)/2 neighbors that were not selected by any vertex
other than v. If v selects one of them (and it does so with probability at least 1/2), then
this selected neighbor u has no choice but to insert the edge hu, vi into F2 . Hence the vertex
v reachs V (F2 ) on iteration i with probability at least 1/2. If it does, then with probability
at least 1/4 it gets matched.
Denote the event “v selects one of these deg(i) (v)/2 neighbors on iteration i” by
′
αi+1 (v), and the event “v gets matched on iteration i” by Mi+1 (v). Denote also by Mi+1 (v)
the event that v gets matched in the particular way that was described above. Specifically,
that v selects one of its neighbors that were not selected by any vertex other than v, and gets
130 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS
′
matched by a matching computed for F2 . Observe that Mi+1 (v) ⊆ Mi+1 (v), and therefore
′
IIP(Mi+1 (v)) ≤ IIP(Mi+1 (v)).
′
It follows that IIP(αi+1 (v)) ≥ 1/2, and IIP(Mi+1 (v) | αi+1 (v)) ≥ 1/4. Hence
′ ′
IIP(Mi+1 (v)) ≥ IIP(Mi+1 (v)) ≥ IIP(αi+1 (v) and Mi+1 (v)) (10.7)
′
= IIP(Mi+1 (v) | αi+1 (v)) · IIP(αi+1 (v)) ≥ 1/8,

i.e., the probability of v to get matched in this case is at least 1/8.

Consider a subset W ⊆ V of vertices that are in Case 2 in iteration i. Assume that for
every pair of vertices u, w ∈ W , distG (u, w) ≥ 3. (The subset W will be later constructed in
′
a way that satisfies this assumption.) Then the events {Mi+1 (u) | u ∈ W } are (mutually)
′
independent. This is because an event Mi+1 (v) is determined by random bits tossed by the
vertex v and some of its (immediate) neighbors. On the other hand, for a set W as above
and two vertices u, w ∈ W , the neighborhoods Γ(u) and Γ(v) are disjoint.
This completes the analisys for case 2.
We now return to the analysis of Algorithm 26. The next lemma shows that after the
first stage of Algorithm 26 (lines 1-6), with high probability, all connected components of
the graph induced by remaining active vertices with sufficiently large degrees have weak
√
diameter O( log n + log ∆).

Lemma 10.22 After the first stage of Algorithm 26, with probability at least 1 − 1/poly(n),
√
for all pairs u, v ∈ V of vertices such that distG (u, v) ≥ k, for k = Θ( log n + ∆), each path
√
between u and w contains a vertex whose active degree is at most ∆′ = O( log n + log ∆).
√ j k
Proof. Denote f = f (n, ∆) = max{ log n, log ∆}, ∆′ = c∆ · f , k = cQ̂ · f , ℓ = ⌊cℓ · f ⌋,
where c∆ , cQ̂ , cℓ are positive constants to be determined later. Denote by degi (v) = deg(i) (v)
the active degree of a vertex v ∈ V in the beginning of iteration i of Algorithm 26 (lines
2-5). Denote also deg′i+1 (v) = deg′(i+1) (v) (see (10.5)).
Fix a pair of vertices u, v with distG (u, v) ≥ k, and a path P between them. Let
Q̂ = Q̂(P ) ⊆ V (P ) be a well-spread sequence of length at least ⌊k/5⌋. Such a sequence
exists, by Lemma 10.12.
Denote by Q̂3 (i) ⊆ Q̂ the set of vertices q with degi (q) ≤ ∆′ = c∆ · f (i.e., vertices in
Case 3 in iteration i). Denote by Q̂1 (i) ⊆ Q̂ the set of vertices q not in Case 3 that are in
Case 1 in iteration i (i.e., at least 21 degi (q) of q’s neighbors were selected by someone else).
Denote by Q̂2 (i) ⊆ Q̂ the set of vertices q not in Case 3 that are in Case 2 in iteration i
(i.e., less than 12 degi (q) of q’s neighbors were selected by someone else).
We say that an iteration i is of type 3 if Q̂3 (i) 6= ∅. An iteration i is of type 1 if
it is not of type 3 and |Q̂1 (i)| ≥ Q̂ 2 . An iteration i is of type 2 if it is not of type 3 and
|Q̂2 (i)| > Q̂
2.
Our analysis now splits into a number of cases, depending on the type of iteration i.
 10.4. RANDOMIZED MAXIMAL MATCHING 131
(1) For an iteration i of type 1:
39
By inequality (10.6), for every vertex q ∈ Q̂1 (i), it holds that IIE deg′i+1 (q) ≤ 40 degi (q).
P
By Chernoff’s bound (applicable because deg′i+1 (q) = u∈Γ(i) (v) Ii+1 ′
(u) is a sum of inde-
pendent indicator random variables),

 
79
IIP deg′i+1 (q) ≥ degi (q) ≤ exp{−Ω(degi (q))} ≤ exp{−Ω(∆′ )} = exp{−Ω(c∆ · f )}.
80

It follows that
 
79
IIP ∃q ∈ Q̂1 (i) such that deg′i+1 (q) > degi (q) ≤ |Q̂| · exp{−Ω(c∆ · f )} (10.8)
80
≤ cQ̂ · f · exp{−Ω(c∆ · f )}
≤ exp{−Ω(c∆ · f )}.

(Because f = f (n, ∆) tends to infinity when n tends to infinity. Note that, we can assume
without loss of generality that ∆ = ω(1), because for ∆ = O(1) there is an existing very
fast algorithm by Panconesi and Rizzi [68] for computing a maximal matching. The latter
algorithm requires O(∆ + log∗ n) time.)
n An iteration i of type 1 o is called bad if the event
′ 79
∃q ∈ Q̂1 (i) such that degi+1 (q) > 80 degi (q) occurs. Denote by Bad(i) the event
that iteration i is bad, and by T1 (i) (respectively, T2 (i); respectively, T3 (i)) the event that
iteration i is of type 1 (resp., of type 2; resp., of type 3). Inequality (10.8) implies that
IIP(Bad(i) | T1 (i)) ≤ exp{−Ω(c∆ · f )}.
(2) For an iteration of type 2:
We say that a vertex is eliminated if it is matched or all its neighbors are matched. For an
iteration i of type 2, it holds that |Q̂2 (i)| ≥ |Q̂|/2. Also, recall that by (10.7), for a vertex
q ∈ Q̂2 (i), IIP(q is not matched ) ≤ 7/8. Hence

IIP(∀q ∈ Q̂2 (i), q is not eliminated ) ≤ IIP(∀q ∈ Q̂2 (i), q is not mathced )
 |Q̂2 (i)|  |Q̂|/2
7 7
≤ ≤
8 8
= exp{−Ω(|Q̂|)} = exp{−Ω(cQ̂ · f )}.

An iteration of type 2 is called bad if neither of the vertices of Q̂2 (i) is eliminated. It follows
that IIP(Bad(i) | T2 (i)) ≤ exp{−Ω(cQ̂ · f )}.
(3) An iteration of type 3 is never bad.
Hence IIP(Bad(i) | T3 (i)) = 0 < exp{−Ω(min{c∆ , cQ̂ } · f )}.
132 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

Thus
3
X
IIP(Bad(i)) = IIP(Bad(i) | Tj (i)) · IIP(Tj (i)) (10.9)
j=1
3
X
≤ exp{−Ω(min{c∆ , cQ̂ } · f )} · IIP(Tj (i)) = exp{−Ω(min{c∆ , cQ̂ } · f )}.
j=1

ℓ


Lemma 10.23 IIP(∃ ℓ/2 bad iterations ) ≤ ℓ/2 · exp{−Ω( 2ℓ · min{c∆ , cQ̂ } · f )}.
Proof. For given ℓ/2 iterations i1 , i2 , ..., iℓ/2 , for each ij among them

IIP(Bad(ij ) | Bad(i1 ), Bad(i2 ), ..., Bad(ij−1 )) ≤ exp{−Ω(min{c∆ , cQ̂ } · f )}.

Indeed, the analysis that results in inequality (10.9) applies even when the event Bad(i) is
conditioned on the event (Bad(i1 ) ∧ ... ∧ Bad(ij−1 )), for i1 , ..., ij−1 < i. The meaning of the
event (Bad(i1 ) ∧ ... ∧ Bad(ij−1 )) is the following one. First, it means that no vertex of Q̂
was eliminated on iterations i1 , i2 , ..., ij−1 , and that no vertex of Q̂ ended up having active
degree below ∆′ on any of these iterations. In addition, the event (Bad(i1 ) ∧ ... ∧ Bad(ij−1 ))
means that in each iteration h ∈ {i1 , i2 , ..., ij−1 } that was of type 1, there exists a vertex
79
q (h) ∈ Q̂ whose active degree did not decrease in iteration h by a factor 80 or less.
Hence
IIP(Bad(i1 ), Bad(i2 ), ..., Bad(iℓ/2 ))

= IIP(Bad(iℓ/2 ) | Bad(i1 ), Bad(i2 ), ..., Bad(iℓ/2−1 )) · IIP(Bad(i1 ), Bad(i2 ), ..., Bad(iℓ/2−1 ))

= exp{−Ω(min{c∆ , cq̂ } · f )} · IIP(Bad(i1 ), Bad(i2 ), ..., Bad(iℓ/2−1 ))
ℓ
≤ exp{−Ω( · min{c∆ , cq̂ } · f )} = exp{−Ω(f 2 · cℓ · min{c∆ , cq̂ })}.
2
Hence

IIP(∃ ℓ/2 bad iterations) ≤ 2ℓ · exp{−Ω(f 2 · cℓ · min{c∆ , cQ̂ })}

n o
= exp cℓ · f − Ω(f 2 · cℓ · min{c∆ , cQ̂ })
n o
= exp −Ω(f 2 · cℓ · min{c∆ , cQ̂ })

2
By Lemma 10.12, each such path P contains a well-spread sequence of length ⌊k/5⌋ +
1. Let P denote the set of all paths whose endpoints u, v satisfy distG (u, v) > k. Let Q̂ be the
set of well-spread sequences of length ⌊k/5⌋ + 1. Then for each path P ∈ P there is a well-
spread sequence Q̂ ∈ Q̂, Q̂ ⊆ V (P ). Since the size of Q̂ is at most n · ∆5k+5 ≤ n · ∆O(cQ̂ ·f ) .
Hence, by the union bound,
 10.4. RANDOMIZED MAXIMAL MATCHING 133
IIP(∃ path P between some pair of vertices u, v such that distG (u, v) > k, such that
n o
∃ ℓ/2 bad iterations for Q̂ = Q̂(P )) ≤ n · ∆O(cQ̂ ·f ) · exp −Ω(f 2 · cℓ · min{c∆ , cQ̂ }) .
(10.10)
The right-hand side of (10.10) is at most
n o
exp log n + O(log ∆ · cQ̂ · f ) − Ω(f 2 · cℓ · min{c∆ , cQ̂ })

n o
≤ exp log n + O(cQ̂ · f 2 ) − Ω(f 2 · cℓ · min{c∆ , cQ̂ })
n o
= exp −Ω(f 2 · cℓ · min{c∆ , cQ̂ }) ≤ 1/poly(n),
√
for a large constant cℓ and c∆ ≥ cQ̂ . (Because f = max{log ∆, log n}.)
Hence with probability at least 1 − 1/poly(n), for all well-spread sequences Q̂ of length at
least ⌊k/5⌋ + 1 there at least ℓ/2 good iterations.
Consider again a fixed pair of vertices u, v with distG (u, v) ≥ k, a path P between
them, and the well-spread sequence Q̂ = Q̂(P ) of this path. If there is at least one good
iteration of type 3 for Q̂, then we are done (one of the vertices of Q̂ gets degree at most
∆′ ). If there is at least one good iteration of type 2, then one of the vertices of Q̂ gets
matched, and we are again done. So we are left with the case that there are at least ℓ/2
good iterations of type 1.
Denote by i1 , i2 , ..., iℓ/2 the indices of the first ℓ/2 such iterations. For each index
j ∈ [ℓ/2], denote Q̂(j) = Q̂1 (ij ). Denote ℓ′ = ℓ/2, k = |Q̂|. We know that for all j ∈ [ℓ′ ],

|Q̂|
|Q̂(j) | = |Q̂1 (ij )| ≥ = k/2.
2
Also for every q ∈ Q̂(j) = Q̂1 (ij ), deg′ij +1 (q) ≤ 80
79
· degij (q). (Because ij is a good iteration
of type 1, and all vertices of Q̂1 (ij ) are vertices of type 1 in iteration ij .) The overall number
D of distinct pairs (q, j) such that q ∈ Q̂(j) is at least ℓ′ · |Q̂|
2 . For a given q ∈ Q̂ denote by
D(q) the number of pairs (q, j) as above that involve the particular vertex q. Note that
D(q) is the number of sets Q̂(j) to which q belongs. Hence
X |Q̂|
D= D(q) ≥ ℓ′ · .
2
q∈Q̂

′
By the pigeonhole principle, there exists a vertex q ∈ Q̂ with D(q) ≥ ℓ2 . In other words,
there exists a vertex q ∈ Q̂ that belongs to at least ℓ′ /2 = ℓ/4 sets Q̂(j) .
Fix a specific vertex q ∈ Q̂ with D(q) ≥ ℓ/4. Let p1 , p2 , ..., pℓ/4 denote the indices
of distinct iterations such that q ∈ Q̂(p1 ) , q ∈ Q̂(p2 ) , ..., q ∈ Q̂(pℓ/4 ) . For each pj , j ∈ [ℓ/4], it
134 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

holds that deg′pj +1 (q) ≤ 79 d

80 · degpj (q). Denote by deg(q) the active degree of q after all these
d
iterations. Then deg(q) ≤ ( 79 )ℓ/4 · deg(q). Set ℓ so that ( 79 )ℓ/4 < 1 . (We set ℓ = ⌊cℓ · f ⌋,
80 80 ∆
4
for a sufficiently large constant cℓ . Specifically, cℓ > log(80/79) .)
d
It follows that deg(q) 1
< · deg (q) ≤ 1. Hence deg(q)d = 0. Hence with probability at
∆ 0
least 1 − exp{−Ω(f 2 )}, for all well-spread sequences Q̂, at least one of the vertices of Q̂ is
either eliminated (due to all its neighbors being matched, or because it itself got matched),
or its degree becomes at most ∆′ . (The latter happens if there is a good iteration of type
3.) Hence with probability at least 1 − 1/poly(n), for all pairs u, v ∈ V of vertices such
that distG (u, v) ≥ k, k = Θ(|Q̂|) = Θ(cQ̂ · f ), each path between u and w contains a vertex
whose active degree is at most ∆′ . This completes the proof of Lemma 10.22. 2

By Lemma 10.22, once the first stage of Algorithm 26 terminates, all connected com-
ponents induced by vertices with active degree greater than ∆′ have weak diameter
√
O( log n + log ∆), with high probability. In the next stage, the algorithm computes a
Maximal Matching in these connected components. This is done in the same way as in
the algorithm for computing an MIS. Specifically, each vertex v collects the topology of
√
its O( log n + log ∆)-neighborhood. Consider the graph G′ induced by vertices that have
active degree at least ∆′ at this stage. The vertex v computes locally the topology of the
connected component G′v of G′ to which v belongs. Then v computes locally a Maximal
Matching for G′v . This matching is computed by the same centralized procedure by all
vertices u in G′v . Therefore, the resulting matching is computed consistently by all vertices.
Consequently, with high probability, for each edge e that remains after this stage (hence-
forth, active edge) at least one of the endpoints of e has active degree at most ∆′ . Let X
denote the set of remaining active vertices once lines 1-16 of Algorithm 26 complete. Let Y
be the subset of X containing all vertices with active degree at most ∆′ . Let Z = X \ Y .
Since for each remaining active edge, at least one of its endpoints belongs to Y , the set Z
is an independent set.
To successfuly complete Algorithm 26, we need to compute a Maximal Matching
of G(X) in line 17. Next, we describe Procedure Complete-MM that performs this task.
This procedure starts with invoking the algorithm of Panconesi and Rizzi [68] on G(Y ),
and removing all matched edges, and the edges incident on them. This invocation requires
O(∆′ + log∗ n) time. Consequently all edges whose both endpoints belong to Y become
inactive. Therefore, the yet remaining edges have one endpoint in Y and one endpoint in
Z. In other words, the subgraph induced by the remaining active vertices is a bipartite
graph, where all vertices in Y have active degree at most ∆′ . A Maximal Matching in such
graph can be computed in O(∆′ ) rounds in the following way. In each round, a vertex
from Y selects an arbitrary neighbor from Z. Next, each selected neighbor from Z selects
an arbitrary neighbor from Y that has selected it. All edges selected by vertices from
Z become matched, and, therefore, these edges and the edges incident to them become
 10.5. GRAPHS WITH BOUNDED ARBORICITY 135
inactive. Consequently, the active degree of each vertex v in Y decreases, either because v
is matched and becomes inactive, or because the neighbor selected by v becomes matched.
Hence, after O(∆′ ) rounds, the active degree of all vertices in Y become zero, and no active
edges remain in the graph. We summarize this discussion in the following theorem.
Theorem 10.24 Algorithm 26 (Procedure Compute-MM) invoked with the input parame-
√
ter ∆′ = O( log n + log ∆), computes a Maximal Matching of the input graph, with high
√
probability, in time O( log n + log ∆).
It is instructive to compare this result with the lower bound of Kuhn et al. [50, 52]. The
latter lower bound shows that there are (infinitely many) n-vertex graphs with maximum
√
Θ( log n)
√
degree ∆ = 2 , on which any algorithm for Maximal Matching requires Ω( log n) =
√
Ω(log ∆) time. This result implies that Maximal Matching requires Ω(min{ log n, log ∆})
time. Therefore,
√
the upper bound in Theorem 10.24 is tight up to constant factors, for
Θ( log n)
∆=2 .
Finally, we remark that the current state-of-the-art randomized algorithm for the
MM problem requires O(log ∆ + log4 log n) time [11].

10.5 GRAPHS WITH BOUNDED ARBORICITY

In this section we describe randomized MIS and MM algorithms for graphs with bounded
arboricity. These algorithms are based on a randomized reduction that transforms a graph
with arboricity at most a into a graph with maximum degree at most t · a, for some pa-
rameter t ≥ 1, within O(logt n) rounds. An MIS or MM in the resulting graph gives rise to
an MIS or MM in the original graph. This reduction and its corollaries are due to [11].
Theorem 10.25 Let G = (V, E) be a graph of arboricity a. Let t ≥ max{118 · a8 , (4(c +
1) ln n)7 } be a parameter, where c is a sufficiently large positive constant. In O(logt n) time
one can find a matching M ⊆ E (or an independent set I ⊆ V ) so that with probability at
least 1 − 1/nc , the maximum degree of the graph G(V \ V (M )) (or G(V \ Γ̂(I))) is at most
t · a.
Proof. In O(logt n) phases, each of which lasts for O(1) rounds, we commit edges to
M (or vertices to I) and remove all incident edges (or incident vertices). Let G be the
graph still under consideration before some phase and let H = {v ∈ V | degG (v) ≥ t · a}
be the remaining set of high-degree vertices. Our goal is to reduce the size of H by a
roughly t1/7 factor within one phase. As a result, after O(logt n) phases (and rounds) no
high-degree vertices will be left in the graph. Let J = {v ∈ H | deg(v, H) ≥ t·a
2 }, i.e., J
is the subset of H that contains all vertices whose “inner” degree (degree into H) is at
least t·a ′ ′ t·a t·a
2 . Let H = H \ J . For a vertex v ∈ H , deg(v, H) ≤ 2 and deg(v) ≥ 2 . Hence
t·a ′ ′
deg(v, V \ H) ≥ 2 , for v ∈ H . We form an edge set Ẽ ⊆ E(H , V \ H) by picking, for
every v ∈ H′ , some arbitrary t·a 2 edges incident on v whose other endpoint is in V \ H.
Hence |Ẽ| = t·a
2 · |H|.
136 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS

Figure 10.3: The sets H, H′ , J , Ẽ and S.

For an edge set A and a vertex u, let degA (u) denote the number of edges in A
incident on u. Under this terminology, degẼ (v) = t·a ′
2 , for every v ∈ H . See Figure 10.3 for
an illustration.
Let S = {u | v ∈ H′ , (v, u) ∈ Ẽ} be the neighborhood of H′ with respect to Ẽ. Observe
that |S| ≤ t·a ′
2 · |H |. Let β = t
1/7
. We define bad vertices of S, bad edges of Ẽ and bad
′
vertices of H , as follows. The set BS of bad vertices of S is given by

BS = {u ∈ S | degẼ (u) ≥ β or deg(u, S) ≥ β 2 }.

(These vertices of S either have a too large degree in Ẽ, or a too large degree in S. If we
are only interested in the MM problem, the second condition can be dropped.) Also, let
1
BẼ = {(v, u) ∈ Ẽ | u ∈ BS , degẼ (u) ≥ β},
2
BẼ = {(v, u) ∈ Ẽ | u ∈ BS , deg(u, S) ≥ β 2 }.
1 2 1
We also write BẼ = {(v, u) ∈ Ẽ | u ∈ BS }. Observe that BẼ = BẼ ∪ (BẼ \ BẼ ). (The set
′
BẼ is the set of bad edges of Ẽ.) Finally, the set of bad vertices in H is given by BH′ =
{v ∈ H′ | degẼ\B (v) < a·t
4 }.
Ẽ
1 t·a
Consider an edge (v, u) ∈ BẼ . Then degẼ (v) = 2 and degẼ (u) ≥ β = t1/7 , i.e., the
degrees in Ẽ of both endpoints are at least β. Hence, by Lemma 2.28, |BẼ 1
| ≤ a·| Ẽ|
β−a ≤
a ′ t·a 2
β−a · |H | · 2 . Also, by Lemma 2.28, the number of vertices u in S with deg(u, S) ≥ β is
 10.5. GRAPHS WITH BOUNDED ARBORICITY 137
a·|S| 2 1
at most β 2 −a .
Each of these vertices contributes to BẼ \ BẼ less than β edges. (Because if
1
for u ∈ S, degẼ (u) ≥ β, then the Ẽ-edges incident on u are in BẼ .) Hence

2 1 a · |S| a t·a
|BẼ \ BẼ |≤ 2
· (β − 1) ≤ 2 · (β − 1) · · |H′ |.
β −a β −a 2

In total, since β ≥ 118/7 a8/7 , we have

 
1 2 t·a ′ a a
|BẼ | ≤ + |BẼ | |BẼ
≤ |H | ·| + · (β − 1)
2 β − a β2 − a
a2 t 2.2a |H′ | 2.2a
≤ 1.1 · |H′ | · = · (t · a · )= · |Ẽ|.
β β 2 β

To summarize, the size of the set of bad edges BẼ is just a small fraction of |Ẽ|.
A bad vertex v ∈ H′ is incident to more that t·a
4 edges in BẼ (because degẼ (v) =
t·a
2
|B |
and degẼ\B (v) ≤ t·a a ′
4 ). Hence, by Lemma 2.28, |BH | < t·a/4 < 4.4 · β · |H |, i.e., the size
′
Ẽ
Ẽ
′
of the set of bad vertices BH′ is also a small fraction of |H |. Moreover, recall that J = {v ∈
H | deg(v, H) ≥ t·a ′
2 } and H = {v ∈ V | degG (v) ≥ t · a}. Hence for every v ∈ H = H \ J ,
t·a H·a H
it holds that deg(v, V \ H) ≥ 2 . Also, by Lemma 2.28, |J | ≤ t·a −a = t/2−1 .
2
Hence |J | is a small fraction of |H|, i.e., most of the vertices of H are in H′ . Moreover,
|BH′ | is a small fraction of H′ , i.e., most of the vertices of H are in H′ \ BH′ . The latter
vertices v satisfy degẼ\B (v) ≥ a·t ′′ ′
4 . Specifically, denote H = H \ BH . Then
′
Ẽ
  
a 1 4.4a
|H′′ | ≥ (1 − 4.4 · ) · |H′ | ≥ 1− 1− · |H|, (10.11)
β t/2 − 1 t1/7
a·t
and for every v ∈ H′′ , it holds that degẼ\B (v) ≥ 4 . Recall that BẼ = {(v, u) ∈ Ẽ | u ∈
Ẽ
′′ a·t
BS }, i.e., each v ∈ H has at least edges of Ẽ \ BẼ incident on it that lead to S ′ =
4
S \ BS . In addition for every u ∈ S it holds that degẼ (u) < β and deg(u, S) < β 2 . Observe
′

that S ′ is not empty; indeed, otherwise S = BS and so BẼ = Ẽ. However, we saw that
|BẼ | ≤ 2.2a ′
β · |Ẽ|, a contradiction. Finally, note that vertices of S can locally recognize that
′
they belong to S .
Our algorithm and its analysis splits here into two cases. The first is the case of MIS,
and the second is the case of MM.
MIS: Each vertex u ∈ S ′ selects a random number and joins the MIS if it holds a local
maximum in S ′ . Observe that for every u ∈ S ′ , it holds that deg(u, S ′ ) < β 2 . Hence
1 1
IIP(u joins M IS) = ≥ 2.
deg(u, S ′ ) + 1 β
The event {u joins MIS} is independent of all events {u′ joins MIS} for u and u′ at distance
at least 3 in G(S ′ ). Recall that for all v ∈ H′′ , it holds that degẼ\B (v) ≥ t·a
4 . Hence the Ẽ
138 10. INTRODUCTION TO DISTRIBUTED RANDOMIZED ALGORITHMS
t·a
neighborhood of each v ∈ H′′ within S ′ contains at least 4·β 4 vertices, each pair of which
′
are at distance at least 3 in G(S ). The probability that no neighbor of v joins the MIS is
at most   t·a
1 4β4 − t·a a·β 1
1− 2 < e 4β6 = e− 4 ≤ c+1 .
β n
(Recall that t ≥ (4(c + 1) ln n)7 , β = t1/7 .) Hence, with high probability, all vertices of H′′
are knocked off, i.e., the set H of high-degree vertices is decimated by a factor of (see
1
(10.11)) Ω(t1/56 )
. Therefore, after O(logt n) phases all vertices in the residual graph have
degrees at most t · a, as required.
MM: Here each vertex u ∈ S ′ chooses an edge (v, u) from Ẽ \ BẼ uniformly at random
and proposes to v to include (v, u) in the matching. Any vertex v ∈ H′′ = H′ \ BH′ that
receives a proposal accepts an arbitrary one among the proposals and becomes matched.
Recall that a vertex v ∈ H′′ has degẼ\B (v) ≥ t·a ′
4 neighbors in S . Each of the latter neigh-
Ẽ

bors has less than β neighbors in H′ (with respect to edges of Ẽ). The probability that
none of them proposes to v is at most
  t·a  
1 4 t·a t6/7 a 1
1− < e− 4β = e− 4 ≤O .
β nc+1

Hence, with high probability, all vertices of H′′ are matched, and so the number of high-
1
degree vertices is decimated by a factor of Ω(t1/56 )
. Within O(logt n) phases all high-degree
vertices are eliminated, and we are done. 2
The reduction given by Theorem 10.25 is very powerful. Next we show how it can be used
in conjunction with the MIS and MM algorithms from Sections 10.3 and 10.4 to obtain fast
MIS and MM algorithms for graphs of bounded arboricity.
For the MM problem in graphs with arboricity a we start with running the reduction
√ √
with t = exp{ log n}. As a result, in O( log n) rounds the problem reduces to the MM
√
problems in graphs with ∆ ≤ exp{ log n} · a, with high probability. By running the MM
algorithm from Section 10.4 in this graph we get an MM within additional time of O(log ∆ +
√ √
log n) = O(log a + log n), again with high probability. We summarize this argument in
the next corollary.

Corollary 10.26 [11] The MM problem on n-vertex graphs with arboricity a can be solved
√
in randomized O(log a + log n) time.
√
In particular, for graphs with a ≤ exp{O( log n)}, the running time of this algorithm is
√
O( log n). Recal that the best deterministic algorithms for graphs of small arboricity a
run in O( logloglogn n ) time for a < log1−ǫ n, for some arbitrarily small constant ǫ > 0. So the
randomized algorithm from Corollary 10.26 is almost quadratically faster than that, and
applies to a much wider family of graphs. Moreover, in view of the lower bound of [11] that
 10.5. GRAPHS WITH BOUNDED ARBORICITY 139
√
shows that the MM problem in unoriented trees requires Ω( log n) time, it follows that for
√
a ≤ exp{O( log n)} the result of Corollary 10.26 is tight up to constant factors!
For the MIS problem we set t = exp{log1/4 n}. As a result within O(log3/4 n) time we
obtain a graph with ∆ ≤ a · exp{log1/4 n}. Running the algorithm from Section 10.3 in this
√ √
graph constructs an MIS within additional O(log ∆ log n) = O((log a + log1/4 n) · log n)
time.

Corollary 10.27 [11] The MIS problem in n-vertex graphs with arboricity a can be solved
√
in randomized O(log a · log n + log3/4 n) time.

In particular, for a ≤ exp{O(log1/4 n)} this results in an MIS algorithm with running time
O(log3/4 n). For small (e.g., constant) values of arboricity, there exists a faster randomized
algorithm for MIS [11]. That algorithm requires O(log2/3 n) time.
140

C H A P T E R 11

Conclusion and Open

Questions
11.1 PROBLEMS THAT CAN BE SOLVED IN
POLYLOGARITHMIC TIME
In this monograph we made an effort to reflect and make accessible to the reader the
significant progress that was achieved in the area of distributed symmetry breaking in
recent years. On the other hand, many central problems in this field are open, and some of
these problems are wide open. In this chapter we will overview the main open questions in
this area.
Perhaps the most fundamental open problem in this field is to understand the power
and limitations of randomization. For centralized algorithms there is a powerful method-
ology for derandomizing randomized algorithms, i.e., converting them into deterministic
ones while incurring only a bounded overhead. (See, e.g., [2], Chapter 16, and the refer-
ences therein.) The situation is similar for many distributed shared-memory models, such
as PRAM. However, in the distributed message-passing model there is currently no generic
derandomization technique known. Developing such a technique, even for a limited spec-
trum of algorithms, would be a very interesting advance. This leads us to our first open
problem.

Open Problem 11.1 Develop a general derandomization technique for the distributed
message-passing model.

The most notable specific problem that has to do with derandomization is whether the
symmetry breaking problems, specifically the MIS and the (∆ + 1)-coloring problems, can
be solved in deterministic polylogarithmic time. Solving an MIS appears to be more dificult
(or at least no easier) than solving a (∆ + 1)-coloring, as demonstrated by Luby’s reduction
(see Section 3.9). Hence it is natural to approach the (∆ + 1)-coloring problem first. For
both problems the state-of-the-art upper bound is √ the deterministic algorithm by Panconesi
O( log n)
and Srinivasan [69]. This algorithm requires 2 time. It is based on the network
decomposition approach.
√
In the lower bound front, the state-of-the-art is Ω( log n), due to Kuhn et al. [50, 52].
Narrowing this gap is probably the most outstanding problem in this area. We state this
open problem below.
 11.1. PROBLEMS THAT CAN BE SOLVED IN POLYLOGARITHMIC TIME 141
Open Problem 11.2 Devise a deterministic polylogarithmic time algorithm for the MIS
problem, or rule it out. As an intermediate state, narrow the gap between the upper bound of
√ √
2O( log n) due to [69] and the lower bound of Ω( log n) due to [50, 52]. The same question
for the (∆ + 1)-coloring is as interesting, and is even more widely open than this one. (See
below.)
In fact, for the (∆ + 1)-coloring problem the gap is even larger than for the MIS problem.
The lower bound of [50, 52] is not known to apply to the (∆ + 1)-coloring problem, and thus,
one can hope to come up with a log∗ n-time deterministic algorithm for (∆ + 1)-coloring.
The (∆ + 1)-coloring problem can be naturally relaxed, and one can ask whether
f (∆)-coloring can be computed in deterministic polylogarithmic time, for some mildly
growing super-linear function f (·). Linial [55] initiated the study of this relaxed question,
and showed that O(∆2 )-coloring can be computed in log∗ n + O(1) time. He also asked
if one can compute a coloring within significantly less than ∆2 colors in deterministic
polylogarithmic time. The authors of the current monograph answered this question in
the affirmative in [9], and showed that ∆1+O(1) -coloring can be computed in deterministic
polylogarithmic time. Specifically, in [9] we presented a ∆ · 2O(log ∆/ log log ∆) -coloring in
log n · log1+ǫ ∆ time, for an arbitrarily small constant ǫ > 0. (See Chapter 7.) Improving
the number of colors in this result would be very interesting.
Open Problem 11.3 Devise a ∆ · polylog(∆)-coloring in deterministic polylogarithmic
time. As an intermediate step, improve upon the result of [9].
Another related variant of the (∆ + 1)-coloring problem is the (2∆ − 1)-edge-coloring
problem. As we saw in Chapter 8 any algorithm for the former problem translates into
an algorithm with roughly the same running time for the latter. The best currently
known deterministic algorithm for the (2∆ − 1)-edge-coloring
√
problem is still the network-
O( log n)
decomposition algorithm of [69], which requires 2 time. The situation with lower
bounds is as appalling as for the (∆ + 1)-vertex-coloring problem.
One can try to use slightly more colors, and get deterministic polylogarithmic time.
There are two results along these lines known. The first one is a deterministic O(∆ · log n)-
edge-coloring algorithm by Czygrinow et al. [21] which requires O(log4 n) time. The second
one is an algorithm from [10] which provides a ∆ · 2O(log ∆/ log log ∆) -edge-coloring within
O(log1+ǫ ∆ + log∗ n logloglog∆∆ ) time, for an arbitrarily small constant ǫ > 0. We summarize
this problem below.
Open Problem 11.4 Devise or rule out a deterministic (2∆ − 1)-edge-coloring algorithm
that runs in polylogarithmic time. As an intermediate step, improve upon the aforemen-
tioned results of [21, 10]. Specifically, devise a ∆ · polylog(∆)-edge-coloring in deterministic
polylogarithmic time.
Another closely related problem is the MM problem. Unlike its sister symmetry breaking
problems (the MIS, the (∆ + 1)-vertex-coloring, and the (2∆ − 1)-edge-coloring), there is
142 11. CONCLUSION AND OPEN QUESTIONS

a polylogarithmic deterministic algorithm for the MM problem. The algorithm is due to

Hanckowiak et al. [35], and it requires O(log4 n) time. As we saw in chapter 8 the MM
problem reduces to the MIS problem in graphs with neighborhood independence bounded
by 2. However, for the latter problem there is no known deterministic polylogarithmic
algorithm. Solving it would be a good stepping stone towards the MIS problem in general
graphs.
Open Problem 11.5 Devise or rule out a deterministic polylogarithmic algorithm for the
MIS problem in graphs with neighborhood independence bounded by 2.
Another related open question is to improve the upper bound of [35] fo the MM problem.
(It is O(log4 n).)

11.2 PROBLEMS THAT CAN BE SOLVED IN (SUB)LINEAR IN

∆ TIME
The complexity of all the abovementioned problems was studied also in terms of the maxi-
mum degree parameter ∆. Specifically, Panconesi and Rizzi [68] showed that the MM and
the (2∆ − 1)-edge-coloring problems can be solved in O(∆) + log∗ n time. (See Section 8.1.)
The authors of the current monograph [7] and Kuhn [48] showed that this is also the case
for the MIS and the (∆ + 1)-vertex-coloring problems. (See Chapter 6.) In the lower bounds
front the Ω(log∗ n) lower bound is due to Linial [55], and for the MIS and the MM problems
there is also a lower bound of Ω(log ∆) due to Kuhn et al. [50, 52].
Open Problem 11.6 Devise or rule out an algorithm with running time o(∆) + log∗ n for
one of these problems.
Interestingly, in contrast to the previous problems, for Open Problem 11.6 there is no known
randomized algorithm that achieves the desired bound (of o(∆) + log∗ n).
The (∆ + 1)-coloring algorithms of [8, 48] are based on defective coloring (see Section
2.4 and Chapter 6). Lovasz showed that in a graph with maximum degree ∆, for any pa-
rameter p, 1 ≤ p ≤ ∆, there exists a (∆/p)-defective p-coloring [58]. The known distributed
counterparts of this result are substantially weaker. Specifically, Kuhn [48] showed that a
(∆/p)-defective O(p2 )-coloring can be computed in O(log∗ n) deterministic time. (See also
[8] for a weaker result obtained by a different technique.)
Open Problem 11.7 Devise an efficient distributed algorithm for computing a (∆/p)-
defective O(p)-coloring.
We remark that for graphs with bounded neighborhood independence such a result is
known [10]. It was used in [10] to devise a ∆1+ǫ -edge-coloring algorithm that requires
O(log ∆) + log∗ n time. Answering Open Problem 11.7 in the affirmative would lead to a
similar result for vertex-coloring. This, in turn, would be a significant improvement over
the best currently-known vertex-coloring algorithms [9, 11].
 11.3. ALGORITHMS FOR RESTRICTED GRAPH FAMILIES 143

11.3 ALGORITHMS FOR RESTRICTED GRAPH FAMILIES

Instead of graphs of bounded degree it is often instructive to consider graphs of bounded
arboricity. In [7] the authors of this monograph showed that for graphs with arboricity
a ≤ polylog(n), all these problems are solvable in deterministic polylogarithmic time.
Open Problem 11.8 Devise or rule out a deterministic polylogarithmic algorithm for one
of these problems, for graphs with a ≫ polylog(n). For example, for a = exp{logǫ n}, for
some fixed constant ǫ > 0.
In the context of graphs with bounded arboricity it is also natural to look on the logarithmic
barrier. In [7] we showed that the MIS and the (∆ + 1)-coloring problems can be solved
in deterministic time O( logloglogn n ), as long as a ≤ log1/2−ǫ n, and the MM and the (2∆ − 1)-
edge-coloring problems can be solved within the same time for a ≤ log1−ǫ n. (In both cases
ǫ > 0 is a fixed arbitrarily small constant.)
Open Problem 11.9 Devise a sublogarithmic deterministic algorithm for the MIS and
√
the (∆ + 1)-coloring problems for graphs with a < t(n), for some t(n) = Ω( log n), and
for the MM and the (2∆ − 1)-edge-coloring problems for graphs with a ≤ s(n), for some
s(n) = Ω(log n).
Closely related to Open Problem 11.9 are numerous questions regarding f (a)-coloring of
graphs with arboricity at most a, for various functions f (·). Those questions, in turn, are
closely related to the problem of computing forest decompositions. Recall that for a graph
of arboricity a one can compute a decomposition into (2 + ǫ) · a forests in O(log n) time.
One can also compute a 2a-forest-decomposition in O(a log n) time [7]. However, by Nash-
Williams’s theorem, there exists a forest decomposition into a forests. This leads to the
following open question.
Open Problem 11.10 Devise or rule out an efficient distributed algorithm for computing
a decomposition of a graph with arboricity a into less than 2a forests.
A progress in this question will probably lead to a progress for Open Problem 11.8, and for
the f (a)-coloring problems. One notable problem from the latter category is the following
one.
Open Problem 11.11 There exists a deterministic O(a2 )-coloring algorithm that requires
O(log n) time [7]. Can one use significantly less than a2 colors, and still stay within deter-
ministic O(log n) time?
This question is open even for randomized algorithms, though a significant progress in this
direction was recently achieved by Kothapalli and Pemmaraju [45]. On the other hand, it is
known that O(a2 )-coloring requires Ω(log n) time, and more generally, for a positive param-
eter q < n1/4 /a, computing O(a · q)-coloring requires Ω( log log n
a+log q ) time [7, 55]. Therefore,
144 11. CONCLUSION AND OPEN QUESTIONS

the running time of O(log n) cannot be improved if one wishes to employ O(a2 ) colors, but
it may be possible to improve the palette size, while spending only O(log n) time.

11.4 RANDOMIZED ALGORITHMS

Randomized complexity of symmetry breaking problems also poses major challenges. For
the MIS problem Luby [60] and Alon et al. [1] devised O(log n)-time randomized algorithms.
√
Barenboim et al. [11] have recently devised an O( log n log ∆)-time algorithm for this
problem. (See Section 10.3.) For ∆ ≤ polylog(n) √
the algorithm of [11] performs even better.
Specifically, its running time in this case is 2O( log log n) . Kuhn et al. [50, 52] proved a lower
√
bound of Ω(min{ log n, log ∆} time for this problem.
Open Problem 11.12 Devise or rule out a randomized algorithm for the MIS problem
√
in general graphs with running time O( log n). More generally, pin down the randomized
complexity of this fundamental problem.
The randomized complexity of the MIS problem was also studied for graphs with
bounded arboricity a. Barenboim et al. [11] devised an algorithm with running time
√
O(log a log n + log3/4 n) for this problem. Moreover, for a ≤ log1/3 n their algorithm re-
quires just O(log2/3 n) time. For a = 1 (the case of unoriented trees) Lenzen and Wat-
√
tenhofer [54] devised an MIS algorithm with running time O( log n log log n). This was
√
marginally improved to O( log n log log n) in [11].
Open Problem 11.13 Improve the results of [11, 54] for the MIS problem in graphs with
bounded arboricity.
For the closely related MM problem the classical O(log n)-time randomized algorithm of
Israeli and Itai [39] was recently improved to O(log ∆ + log4 log n) by [11].
√
Open Problem 11.14 Devise or rule out an O( log n)-time randomized algorithm for
the MM problem.
√
In graphs of arboricity a the MM problem can be solved in O(log a + log n) time [11].
√
The problem is also known to require √
Ω( log n) time even for unoriented trees [11, 50, 52].
Therefore, this is tight for a = 2O( log n) . Remarkably, this lower bound is not known to
apply to the MIS problem in unoriented trees.
Open Problem 11.15 Pin down the randomized complexity of the MIS problem in un-
√ √
oriented trees. We conjecture that it is Θ( log n). For an upper bound of Õ( log n) see
[11, 54].
The randomized complexity of the (∆ + 1)-coloring problem was also subject of intensive
research. The algorithms of Luby [60] and of Alon et al. [1], in conjunction with the reduction
from coloring to MIS (see Section 3.9), provide an O(log n)-time randomized algorithm for
 11.4. RANDOMIZED ALGORITHMS 145
the (∆ + 1) coloring problem. An explicit (∆ + 1)-coloring algorithm is given in [61]. This
√
result was recently improved by Schneider and Wattenhofer [78] to O(
√
log n + log ∆), and
consequently improved by Barenboim et al. [11] to O(log ∆) + 2O( log log n) . Remarkably,
the lower bounds of [50, 52] do not apply to the (∆ + 1)-coloring problem, and therefore,
the current state of knowledge does not preclude (∆ + 1)-coloring in 12 log∗ n time!

Open Problem 11.16 Determine the randomized complexity √

of the (∆ + 1)-coloring
problem. Specifically, either improve the O(log ∆) + 2O( log log n) upper bound from [11],
or prove a lower bound stronger than 12 log∗ n (due to [55]).

The related variant of the randomized (∆ + 1)-coloring problem in which we allow O(∆)
√
colors is also of great interest. Kothapalli et al. [47] devised an O( log n) time algorithm for
this problem. Schneider and Wattenhofer [78] showed that if ∆ > log1+ǫ n, for an arbitrarily
small constant ǫ > 0, then O(∆)-coloring can be computed in randomized O(log∗√n) time.
Barenboim et al. [11] devised an O(∆)-coloring algorithm with running time 2O( log log n) .

Open Problem 11.17 Can the randomized O(∆)-coloring algorithm of [78] that runs in
O(log∗ n) time be extended to sublogarithmic values of ∆?

Obviously, this list of open problems is by any means not exhaustive. Many other very good
open problems are left out. We however hope that it illustrates how much work is still left
to be done in this area. We invite the reader to roll up his sleeves, and indulge in solving
them!
146

Bibliography
[1] N. Alon, L. Babai, and A. Itai. A fast and simple randomized parallel algorithm for
the maximal independent set problem. Journal of Algorithms, 7(4):567–583, 1986.

[2] N. Alon, and J. Spencer. The probabilistic method. Wiley, 3rd ed., 2008.

[3] K. Appel, and W. Haken. The solution of the four color map problem. Scientific
American, 237(4): 108-121, 1977.

[4] H. Attiya, and J. Welch. Distributed Computing: Fundamentals, Simulations, and

Advanced Topics. Wiley, 2nd ed., 2004.

[5] B. Awerbuch, A. V. Goldberg, M. Luby, and S. Plotkin. Network decomposition

and locality in distributed computation. In Proc. of the 30th Annual Symposium on
Foundations of Computer Science, pages 364–369, 1989.

[6] L. Barenboim. On the locality of some NP-complete problems. In Proc. of the 39th
International Colloquium on Automata, Languages, and Programming, part II, pages
403-415, 2012.

[7] L. Barenboim, and M. Elkin. Sublogarithmic distributed MIS algorithm for sparse
graphs using Nash-Williams decomposition. In Proc. of the 27th ACM Symp. on
Principles of Distributed Computing, pages 25–34, 2008.

[8] L. Barenboim, and M. Elkin. Distributed (∆ + 1)-coloring in linear (in ∆) time. In

Proc. of the 41th ACM Symp. on Theory of Computing, pages 111-120, 2009.

[9] L. Barenboim, and M. Elkin. Deterministic distributed vertex coloring in polylogarith-

mic time. In Proc. 29th ACM Symp. on Principles of Distributed Computing, pages
410-419, 2010.

[10] L. Barenboim, and M. Elkin. Distributed deterministic edge coloring using bounded
neighborhood independence. In Proc. of the 30th ACM Symp. on Principles of Dis-
tributed Computing, pages 129 - 138, 2011.

[11] L. Barenboim, M. Elkin, S. Pettie, and J. Schneider. The locality of distributed sym-
metry breaking. In Proc. of the 53rd Annual Symposium on Foundations of Computer
Science, pages 321-330, 2012.
 BIBLIOGRAPHY 147
[12] M. Bellare, O. Goldreich, and M. Sudan. Free bits, PCPs, and nonapproximability -
towards tight results. SIAM Journal on Computing, 27(3):804–915, 1998.

[13] B. Bollobas. Modern Graph Theory. Springer, corrected edition, 1998.

[14] B. Bollobas. Random Graphs. Cambridge University Press, 2nd ed., 2001.

[15] B. Chen, M. Matsumoto, J. Wang, Z. Zhang, and J. Zhang. A short proof of Nash-
Williams’ theorem for the arboricity of a graph. Graphs and Combinatorics, 10(1):
27-28, 1994.

[16] F. Chierichetti, and A. Vattani. The Local Nature of List Colorings for Graphs of
High Girth. SIAM Journal on Computing, 39(6), 2232-2250.

[17] R. Cole, and L. Kowalik. New linear-time algorithms for edge-coloring planar graphs.
Algorithmica, 50(3): 351-368, 2008.

[18] R. Cole, and U. Vishkin. Deterministic coin tossing with applications to optimal
parallel list ranking. Information and Control, 70(1):32–53, 1986.

[19] L. Cowen, R. Cowen, and D. Woodall. Defective colorings of graphs in surfaces: parti-
tions into subgraphs of bounded valence. Journal of Graph Theory, 10:187–195, 1986.

[20] L. Cowen, W. Goddard, and C. Jesurum. Coloring with defect In Proc. of the 8th
ACM-SIAM Symp. on Discrete Algorithms, pages 548–557, 1997.

[21] A. Czygrinow, M. Hanckowiak, and M. Karonski. Distributed O(Delta logn)-edge-

coloring algorithm. In Proc. of the 9th Annual European Symposium on Algorithms,
pages 345–355, 2001.

[22] B. Descartes. Solution to advanced problem No. 4526. American Mathematical

Monthly, 61, page 532, 1954.

[23] R. Diestel. Graph Theory. Springer, 4th ed., 2010.

[24] D. Dubhashi, D. Grable, and A. Panconesi. Nearly-optimal distributed edge-colouring

via the nibble method. Theoretical Computer Science, a special issue for the best
papers of ESA95, 203(2):225–251, 1998.

[25] D. Dubhashi and A. Panconesi. Concentration of Measure for the Analysis of Ran-
domized Algorithms. Cambridge University Press, 2009.

[26] P. Erdős. Graph theory and probability. Canadian Journal of Mathematics, 11: 34-38,
1959.
148 BIBLIOGRAPHY

[27] P. Erdős, P. Frankl, and Z. Füredi. Families of finite sets in which no set is covered
by the union of r others. Israel Journal of Mathematics, 51:79–89, 1985.

[28] T. Gallai. On directed graphs and circuits. Theory of Graphs (Proceedings of the
Colloquium Tihany 1966), New York: Academic Press, pages 115-118, 1968.

[29] M. Garey, and D. Johnson. The complexity of near-optimal graph coloring. Journal
of ACM, 23(1): 43-49, 1976.

[30] B. Gfeller, and E. Vicari. A randomized distributed algorithm for the maximal inde-
pendent set problem in growth-bounded graphs. In Proc. of the 26th ACM Symp. on
Principles of Distributed Computing, pages 53-60, 2007.

[31] A. Goldberg, S. Plotkin, and G. Shannon. Parallel symmetry-breaking in sparse graphs.

SIAM Journal on Discrete Mathematics, 1(4):434–446, 1988.

[32] D. Grable, and A. Panconesi. Nearly optimal distributed edge colouring in O(log log
n) rounds. Random Structures and Algorithms, 10(3): 385-405, 1997.

[33] D. Grable, and A. Panconesi. Fast distributed algorithms for Brooks-Vizing colourings.
In Proc. of the 9th Annual ACM-SIAM Symposium on Discrete Algorithms, pages 473-
480, 1998.

[34] H. Grotzsch. Zur Theorie der diskreten Gebilde, VII: Ein Dreifarbensatz fur dreikre-
isfreie Netze auf der Kugel. Wiss. Z. Martin-Luther-U., Halle-Wittenberg, Math.-Nat.
Reihe 8: 109-120, 1959.

[35] M. Hanckowiak, M. Karonski, and A. Panconesi. On the distributed complexity of

computing maximal matchings. SIAM Journal on Discrete Mathematics, 15(1):41–57,
2001.

[36] F. Harary, and K. Jones. Conditional colorability II: Bipartite variations. Congressus
Numer, 50:205-218, 1985.

[37] G. Hardy, and E. Wright. An introduction to the theory of numbers. Oxford university
press, 5th edition, 1980.

[38] J. Hastad. Clique is Hard to Approximate Within n1−ǫ . In Proc. of the 37th Annual
Symposium on Foundations of Computer Science, pages 627-636, 1996.

[39] A. Israeli, and A. Itai. A fast and simple randomized parallel algorithm for maximal
matching. Information Processing Letters, 22(2):77-80, 1986.

[40] A. Israeli, and Y. Shiloach. An Improved Parallel Algorithm for Maximal Matching.
Information Processing Letters, 22(2):57-60, 1986.
 BIBLIOGRAPHY 149
[41] S. Janson, T. Luczak, and A. Rucinski. Random Graphs. Wiley-Interscience, 2000.
[42] Ö. Johansson. Simple distributed (∆ + 1)-coloring of graphs. Information Processing
Letters, 70(5):229–232, 1999.
[43] R. Karp Reducibility among combinatorial problems. Complexity of Computer Com-
putations, New York: Plenum Press, pages 85-103, 1972.
[44] A. Korman, J. Sereni, and L. Viennot. Toward more localized local algorithms: re-
moving assumptions concerning global knowledge. In Proc. of the 30th ACM Symp.
on Principles of Distributed Computing, pages 49-58, 2011.
[45] K. Kothapalli, and S. Pemmaraju. Distributed graph coloring in a few rounds. In
Proc. of the 30th ACM Symp. on Principles of Distributed Computing, pages 31-40,
2011.
[46] K. Kothapalli, and S. Pemmaraju. Super-Fast 3-Ruling Sets. In proc. of the 32nd
IARCS Annual Conference on Foundations of Software Technology and Theoretical
Computer Science, pages 136-147, 2012.
[47] K. Kothapalli, C. Scheideler, M. Onus, and C. Schindelhauer. Distributed coloring
√
in O( log n) bit rounds. In Proc. of the 20th International Parallel and Distributed
Processing Symposium, 2006.
[48] F. Kuhn. Weak graph colorings: distributed algorithms and applications. In Proc. of
the 21st ACM Symposium on Parallel Algorithms and Architectures, pages 138–144,
2009.
[49] F. Kuhn, T. Moscibroda, T. Nieberg, and R. Wattenhofer. Fast deterministic dis-
tributed maximal independent set computation on growth-bounded graphs. In Proc.
of the 19th International Symposium on Distributed Computing, pages 273-287, 2005.
[50] F. Kuhn, T. Moscibroda, and R. Wattenhofer. What cannot be computed locally! In
Proc. of the 23rd ACM Symp. on Principles of Distributed Computing, pages 300-309,
2004.
[51] F. Kuhn, T. Moscibroda, and R. Wattenhofer. On the locality of bounded growth. In
Proc. of the 24th ACM Symp. on Principles of Distributed Computing, pages 60 -68,
2005.
[52] F. Kuhn, T. Moscibroda, and R. Wattenhofer. Local Computation: Lower and Upper
Bounds. http://arXiv.org/abs/1011.5470, 2010.
[53] F. Kuhn, and R. Wattenhofer. On the complexity of distributed graph coloring. In
Proc. of the 25th ACM Symp. on Principles of Distributed Computing, pages 7–15,
2006.
150 BIBLIOGRAPHY

[54] C. Lenzen and R. Wattenhofer. MIS on trees. In Proc. of the 30th ACM Symp. on
Principles of Distributed Computing, pages 41-48, 2011.

[55] N. Linial. Distributive graph algorithms: Global solutions from local data In Proc. of
the 28th Annual Symp. on Foundation of Computer Science, pages 331–335, 1987.

[56] N. Linial. Locality in distributed graph algorithms. SIAM Journal on Computing,

21(1):193–201, 1992.

[57] N. Linial and M. Saks. Low diameter graph decomposition. Combinatorica 13: 441 -
454, 1993.

[58] L. Lovász. On decompositions of graphs. Studia Sci. Math. Hungar., 1:237–238, 1966.

[59] A. Lubotzky, R. Phillips, and P. Sarnak. Ramanujan graphs. Combinatorica, 8(3):

261–277, 1988.

[60] M. Luby. A simple parallel algorithm for the maximal independent set problem. SIAM
Journal on Computing, 15:1036-1053, 1986.

[61] M. Luby. Removing randomness in parallel computation without a processor penalty.

In Proc. of the 29th Annual Symposium on Foundations of Computer Science, pages
162-173, 1988.

[62] N. Lynch. Distributed Algorithms. Morgan Kaufmann, 1996.

[63] B. Mohar and C. Thomassen. Graphs on Surfaces. Johns Hopkins University Press,
2001.

[64] J. Mycielski. Sur le coloriage des graphes. Colloq. Math. 3: 161-162, 1955.

[65] M. Naor. A lower bound on probabilistic algorithms for distributive ring coloring.
SIAM Journal on Discrete Mathematics, 4(3):409-412, 1991.

[66] C. Nash-Williams. Decompositions of finite graphs into forests. J. London Math, 39:12,
1964.

[67] D. Peleg. Distributed Computing: A Locality-Sensitive Approach. SIAM, 2000.

[68] A. Panconesi, and R. Rizzi. Some simple distributed algorithms for sparse networks.
Distributed Computing, 14(2):97–100, 2001.

[69] A. Panconesi, and A. Srinivasan. On the complexity of distributed network decompo-

sition. Journal of Algorithms, 20(2):581-592, 1995.

[70] A. Panconesi, and A. Srinivasan. The local nature of ∆-coloring and its algorithmic
applications. Combinatorica, 15(2):255-280, 1995.
 BIBLIOGRAPHY 151
[71] A. Panconesi, and A. Srinivasan. Randomized Distributed Edge Coloring via an Exten-
sion of the Chernoff-Hoeffding Bounds. SIAM Journal on Computing, 26(2):350-368,
1997.

[72] D. Sanders, and Y. Zhao. Planar Graphs of Maximum Degree Seven are Class I.
Journal of Combinatorial Theory, Series B, 83(2):201-212, 2001.

[73] N. Santoro. Design and Analysis of Distributed Algorithms. Wiley, 2006.

[74] M. Szegedy, and S. Vishwanathan. Locality based graph coloring. In Proc. of the 25th
ACM Symp. on Theory of Computing, pages 201-207, 1993.

[75] V. Vizing. On an estimate of the chromatic class of a p-graph. Metody Diskret. Analiz,
3: 25-30, 1964.

[76] V. Vizing. Critical graphs with given chromatic index. Metody Diskret. Analiz, 5: 9-17,
1965.

[77] J. Schneider, and R. Wattenhofer. A log-star distributed Maximal Independent Set

algorithm for Growth Bounded Graphs. In Proc. of the 27th ACM Symp. on Principles
of Distributed Computing, pages 35–44, 2008.

[78] J. Schneider, and R. Wattenhofer. A new technique for distributed symmetry breaking.
In Proc. of the 29th ACM Symp. on Principles of Distributed Computing, pages 257-
266, 2010.

[79] D. Zuckerman. Linear Degree Extractors and the Inapproximability of Max Clique
and Chromatic Number. Theory of Computing, 3(1):103–128. 2007.
 153

Authors’ Biographies

MICHAEL ELKIN
Michael Elkin received his PhD in Computer Science and Math-
ematics from the Weizmann Institute, Rehovot, Israel, in 2002. He
held positions in the Institute for Advanced Study in Princeton and
in Yale University, before joining the Ben-Gurion University of the
Negev in 2004. He is an Associate Professor in the Computer Sci-
ence department in the Ben-Gurion University. His main research
interests are distributed algorithms, graph algorithms and metric
embeddings.

LEONID BARENBOIM
Leonid Barenboim performed his PhD research in Computer Sci-
ence in Ben-Gurion University of the Negev. His research deals with
distributed algorithms for symmetry-breaking and synchronization.
His research interests also include graph theory, randomized algo-
rithms and approximation algorithms. He served as a lecturer of a
course on implementation of distributed algorithms and a course
on object oriented programming. In 2013 he was accepted to the
joint research program of Berkeley and I-CORE that deals with the
theory of big data analysis and large-scale networks.