SuperFast 3Ruling Sets
F S T T C S
SuperFast 3Ruling Sets?
Kishore Kothapalli 0
Sriram Pemmaraju 0
0 International Institute of Information Technology, Hyderabad, India 500 032 Department of Computer Science, The University of Iowa , Iowa City, IA 522421419 , USA
A truling set of a graph G = (V, E) is a vertexsubset S ? V that is independent and satisfies the property that every vertex v ? V is at a distance of at most t from some vertex in S. A maximal independent set (MIS) is a 1ruling set. The problem of computing an MIS on a network is a fundamental problem in distributed algorithms and the fastest algorithm for this problem is the O(log n)round algorithm due to Luby (SICOMP 1986) and Alon et al. (J. Algorithms 1986) from more than 25 years ago. Since then the problem has resisted all efforts to yield to a sublogarithmic round algorithm. There has been recent progress on this problem, most importantly an O(log ? ? ?log n)round algorithm on graphs with n vertices and maximum degree ?, due to Barenboim et al. (to appear FOCS 2012). The time complexity of this algorithm is sublogarithmic for ? = 2o(?log n). We approach the MIS problem from a different angle and ask if O(1)ruling sets can be computed faster than the currently known fastest algorithm for an MIS? As an answer to this question, we show how to compute a 2ruling set of an nvertex graph in O((log n)3/4) rounds. We also show that the above result can be improved for special classes of graphs. For instance, on high girth graphs (girth 6 or more), trees, and graphs of bounded arboricity, we show how to compute 3ruling sets in exp(O(?log log n)) rounds, O((log log n)2 ? log log log n) rounds, and O((log log n)3) rounds, respectively. Our main technique involves randomized sparsification that rapidly reduces the graph degree while ensuring that every deleted vertex is close to some vertex that remains. This technique may have further applications in other contexts, e.g., in designing sublogarithmic distributed approximation algorithms. Our results raise intriguing questions about how quickly an MIS (or 1ruling sets) can be computed, given that 2ruling sets can be computed in sublogarithmic rounds. 1998 ACM Subject Classification G.2.2 Graph algorithms ? Part of this work was done while the first author was visiting the University of Iowa as an IndoUS Science and Technology Forum Research Fellow. The work of the second author is supported in part by National Science Foundation grant CCF 0915543.
and phrases MIS; ruling sets; graph sparsification; distributed algorithms

Symmetry breaking is a fundamental theme in distributed computing and a classic example of
symmetry breaking arises in the computation of a maximal independent set (MIS) of a given
graph. About 25 years ago Alon et al. [1] and Luby [12] independently devised randomized
algorithms for the MIS problem, running in O(log n) communication rounds. Since then, all
attempts to devise an algorithm for MIS that runs in sublogarithmic rounds (for general
graphs) have failed. Recently, Kuhn et al. [10] proved that there exist nvertex graphs for
which any distributed algorithm, even randomized, that solves the MIS problem requires
?(?log n) communication rounds. Closing this gap between the O(log n) upper bound and
the ?(?log n) lower bound is one of the fundamental challenges in distributed computing.
There has been some exciting recent progress in closing this gap. Barenboim et al. [5]
present an algorithm that runs in O(log ??log n) rounds on nvertex graphs with maximum
degree ?. This is sublogarithmic for ? ? 2o(?log n). This result uses techniques developed
in a paper by Kothapalli et al. [8] for deriving an O(?log n)round algorithm for computing
an O(?)coloring of a nvertex graph with maximum degree ?. Barenboim et al. [5] also
present an algorithm for computing an MIS on trees in O(?log n log log n) rounds. This is
a small improvement over an algorithm from PODC 2011 for computing an MIS on trees
due to Lenzen and Wattenhofer [11] that runs in O(?log n ? log log n) rounds. Barenboim et
al. extend their result on MIS on trees to graphs with girth at least 6 and to graphs with
bounded arboricity.
A problem closely related to MIS, that also involves symmetry breaking at its core, is the
problem of computing truling sets. A truling set of a graph G = (V, E) is an independent
subset S of vertices with the property that every vertex v ? V is at a distance of at most
t from some vertex in S. Thus an MIS is a 1ruling set1. In this paper we investigate the
distributed complexity of the problem of computing truling sets for t = O(1) with the aim of
determining whether an O(1)ruling set can be computed more efficiently than an MIS. For
general graphs and for various graph subclasses we show that it is indeed possible to compute
truling sets, for small constant t, in time that is much smaller than the best currently
known running time for a corresponding MIS algorithm. In our first result, we present an
algorithm that computes a 2ruling set in O((log n)3/4) rounds on general graphs. Thus we
have a sublogarithmic algorithm for a seemingly minor ?relaxation? of the MIS problem.
We improve on this result substantially for trees, graphs of girth at least 6, and graphs of
bounded arboricity. For all these subclasses, we present algorithms for computing 3ruling
sets whose runtime (in rounds) is exponentially faster than the fastest currently known
corresponding MIS algorithms. For example, for trees our algorithm computes a 3ruling set
in O((log log n)2 ? log log log n) communication rounds, whereas the fastest currently known
algorithm for MIS on trees takes O(?log n log log n) rounds [5].
Our work raises intriguing questions on the possibility of faster MIS algorithms and on
the separation between the distributed complexity of O(1)ruling sets and MIS. For example,
could we design algorithms for MIS that first compute a 2 or 3ruling set and then quickly
convert that subset to a 1ruling set? Is it possible that there are MIS algorithms for trees
and related graph subclasses that run in O(poly(log log n)) rounds? Alternately, could the
MIS problem be strictly harder than the problem of computing a truling set for some small
constant t?
Our results should also be viewed in the context of results by Gfeller and Vicari [7].
These authors showed how to compute in O(log log n) rounds a vertexsubset T of a given
nvertex graph G = (V, E) such that (i) every vertex is at most O(log log n) hops from some
vertex in T and (ii) the subgraph induced by T has maximum degree O(log5 n). One can use
the Barenboim et al. O(log ??log n)round MIS algorithm on G[T ] and sparsify T into an
O(log log n)ruling set in an additional O(?log n ? log log n) rounds. Thus, by combining the
1 In the definition of Gfeller and Vicari [7], a truling set need not be independent, and what we call a
truling set, they call an independent truling set.
GfellerVicari algorithm with the Barenboim et al. algorithm one can compute an O(log log
n)ruling set in general graphs in O(?log n ? log log n) rounds. Our result can be viewed as
extending the GfellerVicari result by using t = O(1) instead of t = O(log log n). Also worth
noting is the fact that Gfeller and Vicari use their O(log log n)ruling set computation as
an intermediate step to computing an MIS on growthbounded graphs. While the techniques
that work for growthbounded graphs do not work for general graphs or for the other graph
subclasses we consider, this suggests the possibility of getting to an MIS via a truling set for
small t.
Our technique involves a rapid sparsification of the graph while ensuring that nodes that
are removed from further consideration are close (within one or two hops) to some remaining
node. Using this technique we show how to reduce the degrees of graphs rapidly and after
sufficiently reducing the degrees, we can apply MIS algorithms due to Barenboim et al. [5]
that take advantage of the low maximum degree. For example, given a graph G = (V, E) and
a parameter , 0 < < 1, our sparsification procedure can run in O (llooggn?) rounds and
partition V into subsets M and W such that with high probability (i) G[M ] has maximum
degree O(2(log n) ) and (ii) every vertex in W has a neighbor in M . At this stage, we can
apply the MIS algorithm of Barenboim et al. [5] that runs in O(log ? ? ?log n) rounds on
G[M ]. Since ?(G[M ]) = O(2(log n) ), this step takes O((log n)1/2+ ) rounds, leading to a
2ruling set algorithm that runs in O (llooggn?) + (log n)1/2+
rounds. Picking
= 1/4 yields
the O((log n)3/4) rounds 2ruling set algorithm mentioned above. We use a similar rapid
sparsification approach to derive faster ruling set algorithms for different graph subclasses.
We believe that the sparsification technique may be of independent interest in itself, especially
in designing distributed approximation algorithms that run in sublogarithmic number of
rounds.
1.1
Model
We consider distributed systems that can be modeled by a graph G = (V, E) with the
vertices representing the computational entities and the edges representing communication
links between pairs of computational entities. We use the standard synchronous, message
passing model of communication in which each node, in each round, can send a possibly
distinct message along each incident edge. All of our algorithms are structured as a series of
?sparsification? steps interleaved with calls to subroutines implementing MIS algorithms on
low degree graphs, due to Barenboim et al. [5]. During the sparsification steps, each node
only needs to inform its neighbors of its membership in some set and therefore each node only
needs to send the same single bit to all of its neighbors. Therefore, communication during
the sparsification steps can be viewed as occuring in in a fairly restrictive communication
model in which each node is only allowed to (locally) broadcast a single bit to all neighbors.
However, some of the MIS algorithms in Barenboim et al. [5] run in the LOCAL model,
which allows each node to send a message of arbitrary size to each neighbor in each round.
Thus, due to their dependency on the MIS algorithms of Barenboim et al. [5], the algorithms
in this paper also require the use of the LOCAL model.
1.2
Definitions and Notation
Given a graph G = (V, E), we denote by N (v) the neighborhood of v and by degG(v) the
quantity N (v). Let distG(u, v) refer to the shortest distance between any two vertices u and
v in G. For a subset of vertices V 0 ? V , let G[V 0] be the subgraph induced by the subset V 0.
Our calculations make use of Chernoff bounds for tail inequalities on the sum of
independent random variables. In particular, let X := Pn
i=1 Xi with E[Xi] = p for each 1 ? i ? n.
The upper tail version of Chernoff bounds that we utilize is: Pr[X ? E[X] ? (1 + )] ?
exp(?E[X] 2/3) for any 0 < < 1.
In our work, we derive a 3ruling set algorithm for graphs with bounded arboricity. Let
the density of a graph G = (V, E), V  ? 2, be the ratio dE/(V  ? 1)e. Let the density of a
singlevertex graph be 1. The arboricity of a graph G = (V, E), denoted a(G), can be defined
as a(G) := max{density(G0)  G0 is a subgraph of G}. By the celebrated NashWilliams
decomposition theorem [14], the arboricity of a graph is exactly equal to the minimum number
of forests that its edge set can be decomposed into. For example, trees have arboricity one.
The family of graphs with arboricity a(G) = O(1) includes all planar graphs, graphs with
treewidth bounded by a constant, graphs with genus bounded by a constant, and the family
of graphs that exclude a fixed minor. A property of graphs with arboricity a(G) that has been
found useful in distributed computing [2, 3, 4] is that the edges of such graphs can be oriented
so that each node has at most a(G) incident edges oriented away from it. However, finding
such an orientation takes ? lolgoag(nG) rounds by a lower bound result due to Barenboim and
Elkin [2] and since we are interested in sublogarithmic algorithms, we cannot rely on the
availability of such an orientation for a(G) = O(1).
1.3
Our Results
Here we summarize the results in this paper.
1. An algorithm, that with high probability, computes a 2ruling set on general graphs
in O (llooggn?) + (log n)1/2+ rounds for any 0 < < 1. Substituting = 1/4 into this
running time expression simplifies it to O((log n)3/4).
2. An algorithm, that with high probability, computes a 3ruling set on graphs of girth at
least 6 in exp(O(?log log n)) rounds.
3. An algorithm, that with high probability, computes a 3ruling set in
O((log log n)2 log log log n) rounds on trees.
4. An algorithm, that with high probability, computes a 3ruling set on graphs of bounded
arboricity in O((log log n)3) rounds.
Note that all our results run significantly faster than currently known fastest corresponding
algorithms for MIS. In fact, for trees and graphs of bounded arboricity, our results improve
the corresponding results exponentially. This is illustrated further in Table 1.
1.4
Related Work
The work most closely related to ours, which includes the recent work of Barenboim et al. [5]
and the work of Gfeller and Vicari [7], has already been reviewed earlier in this section.
Other work on the MIS problem that is worth mentioning is the elegant MIS algorithm of
M?tivier et al. [13]. In this algorithm, each vertex picks a real uniformly at random from the
interval [0, 1] and joins the MIS if its chosen value is a local maxima. This can be viewed as
a variant of Luby?s algorithm [12] and like Luby?s algorithm, runs in O(log n) rounds. Due
to its simplicity, this MIS algorithm is used in part by the MIS algorithm on trees by Lenzen
and Wattenhofer [11] and also by Barenboim et al. [5].
The MIS problem on the class of growthbounded graphs has attracted fair bit of attention
[9, 7, 15]. Growthbounded graphs have the property that the rneighborhood of any vertex
v has at most O(rc) independent vertices in it, for some constant c > 0. In other words, the
rate of the growth of independent sets is polynomial in the radius of the ?ball? around a
vertex. Schneider and Wattenhofer [15] showed that there is a deterministic MIS algorithm
on growthbounded graphs that runs in O(log? n) rounds. Growthbounded graphs have
been used to model wireless networks because the number of independent vertices in any
spatial region is usually bounded by the area or volume of that region. In contrast to
growthbounded graphs, the graph subclasses we consider in this paper tend to have arbitrarily
many independent vertices in any neighborhood.
Fast algorithms for O(1)ruling sets may have applications in distributed approximation
algorithms. For example, in a recent paper by Berns et al. [6] a 2ruling set is computed as a
way of obtaining a O(1)factor approximation to the metric facility location problem. Our
work raises questions about the existence of sublogarithmic round algorithms for problems
such as minimum dominating set, vertex cover, etc., at least for special graph classes.
1.5
Organization of the Paper
The rest of the paper is organized as follows. Section 2 shows our result for general graphs.
Section 3 shows our results for graphs of girth at least 6, and for trees. Section 4 extends the
results of Section 3 to graphs of arboricity bounded by a constant.
2
2Ruling Sets in General Graphs
In this section we describe Algorithm RulingSetGG, that runs in sublogarithmic rounds
and computes a 2ruling set in general graphs. The reader is encouraged to consult the
pseudocode of this algorithm while reading the following text. Let f be the quantity 2(log n)
for some parameter 0 < < 1. Let i? be the smallest positive integer such that f i?+1 ? ?.
Thus i? = dlogf ?e ? 1. It is also useful to note that i? = O (llooggn?) . The algorithm
proceeds in stages and there are i? stages, indexed by i = 1, 2, . . . , i?. In Stage i, all ?high
degree? vertices, i.e., vertices with degrees greater than f?i , are processed. Roughly speaking,
in each stage we peel off from the ?high degree? vertex set, a subgraph with degree bounded
above by O(f ? log n). Following this we also peel off all neighbors of this subgraph. More
precisely, in Stage i each ?high degree? vertex joins a set Mi with probability 6 log n?fi (Line
?
6). Later we will show (in Lemma 1) that with high probability any vertex that is in V at
the start of Stage i has degree at most ?/f i?1. (This is trivially true for i = 1.) Therefore,
it is easy to see that any vertex in the graph induced by Mi has expected degree at most
O(f ? log n). In fact, this is true with high probability, as shown in Lemma 2. This degree
bound allows the efficient computation of an MIS on the subgraph induced by Mi. Following
the identification of the set Mi, all neighbors of Mi that are outside Mi are placed in a set
Wi (Line 9). Both sets Mi and Wi are then deleted from the vertex set V . The sets Wi play
a critical role in our algorithm. For one, given the probability 6 log n?fi of joining Mi, we can
?
show that with high probability every ?high degree? vertex ends up either in Mi or in Wi.
This ensures that all ?high degree? vertices are deleted from V in each Stage i. Also, the
sets Wi act as ?buffers? between the Mi?s ensuring that there are no edges between Mi and
Mi0 for i 6= i0. As a result the graph induced by ?iMi also has low degree, i.e., O(f ? log n).
Therefore, we can compute an MIS on the graph induced by ?iMi in ?one shot? rather than
deal with each of the graphs induced by M1, M2, . . . one by one.
Given the way in which ?high degree? vertices disappear from V , at the end of all i? stages,
the graph G induced by vertices that still remain in V would have shrunk to the point where
the maximum degree of a vertex in G is O(f ). The algorithm ends by computing an MIS on
the graph induced by V ? (?iMi). As mentioned before, the Mi?s do not interact with each
other or with V and therefore the degree of the graph induced by (?iMi) ? V is O(f ? log n).
We use the MIS algorithm due of Barenboim et al. [5] that runs in O(log ? ? ?log n) rounds
for this purpose. Since ? = O(f ? log n) and f = 2(log n) , this step runs in O((log n) 21 + )
rounds. In the algorithm described below, we denote by MISLOWDEG the subroutine that
implements the Barenboim et al. algorithm. We use H to denote a static copy of the input
graph G.
Algorithm RulingSetGG(G = (V, E))
1. f ? 2(log n) ; H ? G
2.
for i ? 1, 2, . . . , i? do
/* Stage i */
3.
4.
5.
6.
7.
8.
9.
10.
11.
Mi ? ?; Wi ? ?;
for each v ? V in parallel do
if degG(v) > f?i then
Mi ? Mi ? {v} with probability 6 log n?fi
?
for each v ? V in parallel do
if v ? N (Mi) \ Mi then
Wi ? Wi ? {v}
V ? V \ (Mi ? Wi)
endfor(i)
I ? MISLOWDEG(H[(?iMi) ? V ])
return I;
I Lemma 1. At the end of Stage i, 1 ? i ? i?, with probability at least 1 ? n15 all vertices
still in V have degree at most f?i .
Proof. Consider a ?high degree? vertex v, i.e., a vertex with degree more than ?/f i, at the
start of Stage i. Then,
Pr[v is added to Mi ? Wi] ? 1 ?
1 ?
?
6 log n ? f i fi
?
1
? 1 ? e?6?log n ? 1 ? n6 .
Therefore, using the union bound, we see that with probability at least 1 ? n15 all vertices in
V that have degree more than ?/f i at the start of Stage i will join Mi ? Wi in Stage i. J
I Lemma 2. Consider a Stage i, 1 ? i ? i?. With probability at least 1 ? n2 , the subgraph
induced by Mi (i.e., H[Mi]) has maximum degree 12 log n ? f .
Proof. We condition on the event that all vertices that are in V at the beginning of Stage i
have degree at most fi??1 . For i = 1, this event happens with probability 1 and for i > 1,
Lemma 1 implies that this event happens with probability at least 1 ? 1/n5. Consider a
vertex v ? V that is added to Mi. Let degMi (v) denote the degree of vertex v in H[Mi].
Then, E[degMi (v)] ? fi??1 ? 6 log?n?fi = 6 log n ? f. Here we use the fact that degG(v) ? fi??1
for all v ? V at the start of Stage i. Since vertices join Mi independently, using Chernoff
bounds we conclude that Pr[degMi (v) ? 12 log n ? f ] ? 1/n2. Therefore, with probability
at least 1 ? 1/n the maximum degree of H[Mi] is at most 12 log n ? f . We now drop the
conditioning on the event that all vertices that are in V at the beginning of Stage i have
degree at most fi??1 and use Lemma 1 and the union bound to obtain the lemma. J
I Theorem 3. Algorithm RulingSetGG computes a 2ruling set of the input graph G in
O( (llooggn?) + (log n)1/2+ ) rounds.
Proof. It is easy to see that every stage of the algorithm runs in O(1) communication rounds.
log ?
Since there are i? stages and since i? = O (log n) , the running time of the stages all
log ?
together is O (log n) . From Lemma 1 we see that the vertex set V remaining after all
i? stages induces a graph with maximum degree f with high probability. From Lemma
2 we see that the maximum degree of every H[Mi] is bounded above by O(f ? log n) with
high probability. Furthermore, since there is no interaction between any pair of Mi?s and
also between V and the Mi?s, the maximum degree of the graph induced by (?iMi) ? V is
also O(f ? log n). Therefore, with high probability, the MIS computation at the end of the
algorithm takes O((log n)1/2+ ) rounds using [5, Theorem 4.3]. Together these observations
yield the claimed running time.
To see that I is a 2ruling set, first observe that every vertex v ends up in Mi ? Wi for
some 1 ? i ? i? or remains in V until the end. If v ends up in Wi, it is at most 2 hops from
a vertex in I that belongs to the MIS of H[Mi]. Otherwise, v is at most 1 hop away from a
vertex in I. J
Using = 1/4 in the above theorem results in Corollary 4. A further optimization on the
choice of for graphs with degree in 2?(?log n) is shown in Corollary 5.
I Corollary 4. Algorithm RulingSetGG computes a 2ruling set of the input graph G in
O((log n)3/4) rounds.
I Corollary 5. (i) For a graph G with ? = 2O(?log n), Algorithm RulingSetGG computes
a 2ruling set of the input graph G in O((log n)1/2+ ) rounds for any > 0. (i) For a graph
G with ? = 2?(?log n), Algorithm RulingSetGG computes a 2ruling set of the input
graph G in O((log n)1/4plog ?) rounds.
Proof. We get (i) by simply plugging ? = 2O(?log n) into the running time expression from
Theorem 3. (ii) In this case, we know that log ? = ?(?log n) and log ? ? log n. Consider
the two expressions (llooggn?) and (log n)1/2+ in the running time expression from Theorem
3. At = 0 the first term is larger and as we increase , the first term falls and the second
term increases. By the time = 1/4 the second term is larger. We find a minimum value by
equating the two terms and solving for . This yields an ?optimal? value of
log log ? 1
=
2 log log n ? 4
and plugging this into the running time expression yields the running time bound of
O((log n)1/4 ? plog ?) rounds. J
3Ruling Sets for High Girth Graphs and Trees
Our goal in this section is to devise an O(1)ruling set algorithm for high girth graphs and
trees that is much faster than the 2ruling set algorithm for general graphs from the previous
section. In Algorithm RulingSetGG we allow the graph induced by Mi to have degree as
high as O(f ? log n) where f = 2(log n) . Computing an MIS on a graph with degree as high
as this is too time consuming for our purposes. We could try to reduce f , but this will result
in a corresponding increase in the number of stages. Therefore, we need to use additional
ideas to help simultaneously keep the maximum degree of the graphs H[?iMi] small and
also the number of stages small.
Let G = (V, E) be a graph with n vertices, maximum degree ?, and girth at least 6.
Let i? be the smallest positive integer such that ?1/2i? ? 6 ? log n. It is easy to check that
i? = O(log log ?).
Let M1 and M2 be disjoints subsets of V such that the maximum vertex degree in G[M1]
and in G[M2] is bounded by O(log n). We use MISTWOSTAGE(G, M1, M2) to denote a call to
the following algorithm for computing an MIS on G[M1 ? M2].
1. Compute an MIS I1 on G[M1] using the algorithm of Barenboim et al. ([5], Theorem
7.2).
2. Compute an MIS I2 on G[M2 \ N (I1)] using the algorithm of Barenboim et al. ([5],
Theorem 7.2).
3. return I1 ? I2.
This algorithm runs in exp(O(?log log n)) rounds since the maximum degree in G[M1]
and in G[M2] is bounded by O(log n) and therefore by Theorem 7.2 [5] each of the MIS
computations requires exp(O(?log log n)) rounds. If G were a tree, then we could use
Theorem 7.3 in Barenboim et al. [5], which tells us that we can compute an MIS on a tree
with maximum degree O(log n) in O(log log n ? log log log n) rounds. From this we see that a
call to MISTWOSTAGE(G, M1, M2) runs in O(log log n ? log log log n) rounds when G is a tree.
In our previous algorithm, Algorithm RulingSetGG, we used degree ranges ( ? , ?],
f
( f?2 , ?f ], etc. Here we use even larger degree ranges: (?1/2, ?], (?1/4, ?1/2], etc. The
algorithm proceeds in stages and in Stage i all vertices with degrees in the range (?1/2i , ?1/2i?1 ]
are processed. To understand the algorithm and why it works consider what happens in
Stage 1. (It may be helpful to consult the pseudocode of Algorithm RulingSetHG while
reading the following.) In Line 6 we allow ?high degree? vertices (i.e., those with degree more
than ??) to join a set M1 with a probability 6 lo?g n . This probability is small enough that it
ensures that the expected maximum degree of the subgraph induced by M1 is O(log n). In
fact, this also holds with high probability, as shown in Lemma 8. However, as can be seen
easily, there are lots of ?high degree? vertices that have no neighbor in M1. We use two ideas
to remedy this situation. The first idea is to allow ?low degree? vertices (i.e., those with
degree at most ??) also to join a set M2, with the somewhat higher probability of 6 ?lo?gn
(Line 7). This probability is low enough to ensure that the graph induced by M2 has O(log n)
maximum degree, but it is also high enough to ensure that if a ?high degree? node has lots
of ?low degree? neighbors, it will see some neighbor in M2, with high probability. This still
leaves untouched ?high degree? vertices with lots of ?high degree? neighbors. To deal with
these vertices, we remove not just the neighborhood of M1, but also the 2neighborhood of
M1. The fact that G has a high girth ensures that a ?high degree? vertex that has many
?high degree? neighbors has lots of vertices in its 2neighborhood. This allows us to show that
such ?high degree? vertices are also removed with high probability. The above arguments
are formalized in Lemma 6. We repeat this procedure for smaller degree ranges until the
M2
Low Degree
M1
W
High Degree
degree of the graph that remains is polylogarithmic. Figure 1 shows one iteration of the
algorithm. Pseudocode of our algorithm appears as Algorithm RulingSetHG below.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
Algorithm RulingSetHG(G = (V, E))
1. I ? ?
2. for i = 1, 2, ? ? ? , i? do
/* Stage i */
M1 ? ?; M2 ? ?; W ? ?
for v ? V in parallel do
if deg(v) > ?1/2i then
M1 ? M1 ? {v} with probability ?61?l/o2gi?n1
else if deg(v) ? ?1/2i then
M2 ? M2 ? {v} with probability 6?log n
?1/2i
I ? I ? MISTWOSTAGE(G, M1, M2)
for v ? V \ (M1 ? M2) in parallel do
if dist(v, M1 ? M2) ? 2 then
W ? W ? {v}
V ? V \ (M1 ? M2 ? W )
endfor(i)
I ? I ? MIS(G)
return I;
In the following, we analyze Algorithm RulingSetHG. We show in Lemma 6 that all
nodes of degree at least ?1/2i can be processed in the ith iteration. This is followed by
Lemma 8 that argues that the degree of G[M1 ? M2] is O(log n), and finally Theorem 9 that
shows our result for graph of girth at least 6 and trees.
I Lemma 6. For 1 ? i ? i?, with probability at least 1 ? 1/n2, all vertices still in V have
degree at most ?1/2i at the end of iteration i.
Proof. Consider a vertex v ? V at the start of iteration i that has degree greater than ?1/2i .
Vertex v can have one of two types:
Type I : v is of Type I if at least half of v?s neighbors have degree greater than ?1/2i .
Type II : v is of Type II if fewer than half of v?s neighbors have degree greater than ?1/2i .
If v is of Type I, then there are at least 1/2 ? ?1/2i ? ?1/2i = ?1/2i?1 /2 vertices in v?s
2neighborhood. Here we use the fact that G has girth at least 6. Now note that any
6?log n
we see that Pr[v is added to M1 ?M2 ?W ] ? 1? 1 ? ?1/2i?1
vertex u in v?s 2neighborhood is added to M1 ? M2 with probability at least ?61l/o2gi?n1 .
Therefore, the probability that no vertex in v?s 2neighborhood is added to M1 ?M2 is at most
(1 ? ?61l/o2gi?n1 )N2(v), where N2(v) denotes the 2neighborhood of vertex v. Here we use the fact
I Corollary 7. With probability at least 1 ? 1/n2, after all i? iterations of the forloop in
Algorithm RulingSetHG, the graph G has maximum degree at most 6 log n.
I Lemma 8. Consider an arbitrary iteration 1 ? i ? i? and let H = G[M1 ? M2]. With
probability at least 1 ? 2/n, the maximum degree of a vertex in H[Mj ], j = 1, 2 is at most
12 ? log n.
Proof. We condition on the event that all vertices that are in V at the beginning of an
iteration i have degree at most ?1/2i?1 . For i = 1, this event happens with probability 1 and
for i > 1, Lemma 6 implies that this event happens with probability at least 1?1/n2. Consider
a vertex v ? V that is added to M1. Let degM1 (v) denote the degree of vertex v in G[M1].
Then, E[degM1 (v)] ? ?1/2i?1 ? ?61?l/o2gi?n1 = 6 ? log n. Here we use the fact that deg(v) ? ?1/2i?1
for all v ? V at the start of iteration i. Similarly, for a vertex v ? V that is added to M2, let
degM2 (v) denote the degree of vertex v in G[M2]. Then, E[degM2 (v)] ? ?1/2i ? 6??l1o/g2ni = 6?log n.
Here we use the fact that v is added to M2 only if deg(v) ? ?1/2i . Since vertices join M1
independently, using Chernoff bounds we conclude that Pr[degM1 (v) ? 12 ? log n] ? 1/n2.
Similarly, we conclude that Pr[degM2 (v) ? 12 ? log n] ? 1/n2. Therefore, with probability
at least 1 ? 1/n the maximum degree of G[M1 ? M2] is at most 12 log n. We now drop the
conditioning on the event that all vertices that are in V at the beginning of iteration i have
degree at most ?1/2i?1 and use Lemma 6 and the union bound to obtain the lemma. J
I Theorem 9. Algorithm RulingSetHG computes a 3ruling set of G. If G is a graph
with girth at least 6 then RulingSetHG terminates in exp(O(?log log n)) rounds with high
probability. If G is a tree then RulingSetHG terminates in O((log log n)2 ? log log log n)
rounds with high probability.
Proof. Consider a vertex v ? V that is added to M1 ? M2 ? W in some iteration i. Since
the algorithm computes an MIS on G[M1 ? M2] and since every vertex in W is at most 2
hops (via edges in G) from some vertex in M1 ? M2, it follows that v is at distance at most
3 from a vertex placed in I in iteration i. A vertex that is not added to M1 ? M2 ? W ends
up in the graph whose MIS is computed (in Line 13) and is therefore at most 1 hop away
from a vertex in I. Thus every vertex in V is at most 3 hops away from some vertex in I.
The total running time of the algorithm is i? times the worst case running time the call to
the MIS subroutine in Line 8 plus the running time of the call to the MIS subroutine in Line 13.
This implies that in the case of graphs of girth at least 6, Algorithm RulingSetHG runs in
exp(O(?log log n))?O(log log ?) = exp(O(?log log n)) rounds. In the case of trees, Algorithm
RulingSetHG runs in O(log log ? ? log log n ? log log log n) = O((log log n)2 ? log log log n)
rounds. J
4
Graphs with Bounded Arboricity
In the previous section, we used the fact that the absence of short cycles induces enough
independence so that in each iteration, with high probability the ?high degree? nodes join the
set M1 ?M2 ?W . This has allowed us to process nodes of degrees in the range (?1/2i , ?1/2i?1 ]
in iteration i. In this section, we show that a 3ruling set can be computed even in the presence
of short cycles provided the graph has an arboricity bounded by O(logk n) for a constant k.
The algorithm we use for this case is essentially similar to that of Algorithm RulingSetHG
from Section 3. Recall from Section 3 that i? refers to the smallest positive integer such that
?1/2i? ? 6 ? log n. We make the following changes to Algorithm RulingSetHG to adapt it
to graphs of arboricity a = a(G).
In iteration i, for 1 ? i ? i?, a node v that has a degree at least ?1/2i joins the set M1
with probability ?6?1a/l2oig?n1 . (See Line 6 of Algorithm RulingSetHG.)
In iteration i, for 1 ? i ? i?, a node v with degree less than ?1/2i joins M2 with
probability 6??a1l/o2gin . (See Line 7 of Algorithm RulingSetHG).
In the following, we show lemmas equivalent to Lemma 6 and 8 for a graph with
a ? O(logk n) for a constant k.
I Lemma 10. Consider any iteration i for 1 ? i ? i?. With probability at least 1 ? n12 , all
nodes still in V have degree at most ?1/2i at the end of iteration i.
Proof. For i = 0, we see that each vertex has degree at most ? with probability 1. Hence,
the lemma holds for i = 0. Let us assume inductively that the lemma holds through the first
i ? 1 iterations and let us consider the ith iteration.
Consider a node v still in V at the start of iteration i that has degree at least ?1/2i . We
distinguish between two cases. Recall that for a vertex v, N2(v) refers to the 2neighborhood
of v.
v has at least half its neighbors each with degree at least ?1/2i . In this case, we notice
that v has at least ?1/2i?1 /2a nodes at a distance of 2 from v. Otherwise, the graph
induced by the set N (v) ? N2(v) has an arboricity greater than a, which is a contradiction.
Each of the vertices u ? N2(v) joins M1 ? M2 with probability at least ?6?1a/l2oig?n1 . Therefore,
Pr(v ? M1 ? M2 ? W ) ? 1 ? (1 ? ?6?1a/l2oig?n1 )?1/2i?1 /2a ? 1 ? e6 log n/2 = 1 ? 1/n3.
v has at most half its neighbors each with degree at least ?1/2i . In this case, each such
neighbor of v joins M2 with probability c??a1l/o2gin . Therefore, we can compute the probability
that v ? M1 ? M2 ? W as follows. Pr(v ? M1 ? M2 ? W ) ? 1 ? (1 ? 6??a1l/o2gin )?1/2i /2a ?
1 ? e6 log n/2 = 1 ? 1/n3.
In either case we see that v joins M1 ? M2 ? W with a probability of 1/n3. Using the
union bound, as in the proof of Lemma 6, vertices still in V have degree at most ?1/2i with
probability at most 1 ? n12 . J
Lemma 8 also holds with the change that the graph H[Mj ] for j = 1, 2 as defined in
Lemma 8 has a degree at most 12 ? a log n. Since a ? O(logk n), the above degree is in
O(logk+1 n), with high probability. The following theorem can be shown along the lines of
Theorem 9.
I Theorem 11. Algorithm RulingSetHG computes a 3ruling set of a graph G of arboricity
a = O(1) in O((log log n)3) rounds.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Noga Alon , L?szl? Babai, and Alon Itai . A fast and simple randomized parallel algorithm for the maximal independent set problem . J. Algorithms , 7 ( 4 ): 567  583 , 1986 .
L. Barenboim and M. Elkin . Sublogarithmic distributed MIS algorithm for sparse graphs using nashwilliams decomposition . In Proc. ACM PODC , pages 25  34 , 2008 .
L. Barenboim and M. Elkin . Distributed (? + 1)coloring in linear (in ?) time . In Proc.
ACM STOC , pages 111  120 , 2009 .
L. Barenboim and M. Elkin . Deterministic distributed vertex coloring in polylogarithmic time . In Proc. ACM PODC , pages 410  419 , 2010 .
Leonid Barenboim , Michael Elkin, Seth Pettie, and Johannes Schneider . The locality of distributed symmetry breaking . In Proc. of IEEE FOCS , 2012 , (to appear).
Andrew Berns , James Hegeman, and Sriram V. Pemmaraju . Superfast distributed algorithms for metric facility location . In Proc. ICALP(2) , pages 428  439 , 2012 .
Beat Gfeller and Elias Vicari . A randomized distributed algorithm for the maximal independent set problem in growthbounded graphs . In Proc. ACM PODC , pages 53  60 , 2007 .
K. Kothapalli , C. Scheideler , M. Onus , and C. Schindelhauer . Distributed coloring in O(?log n) bit rounds . In Proc. IPDPS , 2006 .
F. Kuhn , T. Moscibroda , T. Nieberg , and R. Wattenhofer . Fast deterministic distributed maximal independent set computation in growthbounded graphs . In Proc. of Distribtued Computing , pages 273  287 , 2008 .
Fabian Kuhn , Thomas Moscibroda, and Roger Wattenhofer . Local computation: Lower and upper bounds . CoRR, abs/1011.5470 , 2010 .
Christoph Lenzen and Roger Wattenhofer . Mis on trees . In Proc. ACM PODC , pages 41  48 , 2011 .
M. Luby . A simple parallel algorithm for the maximal independent set . SIAM Journal on Computing , 15 : 1036  1053 , 1986 .
Y. M?tivier , J.M. Robson , N. SahebDjahromi, and A. Zemmari . An optimal bit complexity randomised distributed mis algorithm . In Proc. SIROCCO , pages 323  337 , 2009 .
C. NashWilliams . Decompositions of finite graphs into forests . J. London Math , 39 ( 12 ), 1964 .
Johannes Schneider and Roger Wattenhofer . A logstar distributed maximal independent set algorithm for growthbounded graphs . In Proc. ACM PODC , pages 35  44 , 2008 .