Symmetry Breaking in the Congest Model: Time- and Message-Efficient Algorithms for Ruling Sets

TL;DR

This paper introduces faster algorithms for ruling sets in the CONGEST model, breaking traditional time and message complexity barriers for symmetry breaking problems like MIS, with new algorithms for 2- and 3-ruling sets.

Contribution

The paper presents the first sub-logarithmic time algorithms for 2- and 3-ruling sets in the CONGEST model and introduces a nearly linear message complexity algorithm for 2-ruling sets.

Findings

3-ruling sets computed in $O(rac{ ext{log} n}{ ext{log} ext{log} n})$ rounds

2-ruling sets computed in $O( ext{log} ext{Delta} imes ( ext{log} n)^{1/2 + ext{epsilon}} + rac{ ext{log} n}{ ext{log} ext{log} n})$ rounds

Message complexity for 2-ruling sets is $O(n ext{log}^2 n)$, nearly linear in $n$

Abstract

We study local symmetry breaking problems in the CONGEST model, focusing on ruling set problems, which generalize the fundamental Maximal Independent Set (MIS) problem. A $\beta$-ruling set is an independent set such that every node in the graph is at most $\beta$ hops from a node in the independent set. Our work is motivated by the following central question: can we break the $\Theta(\log n)$ time complexity barrier and the $\Theta(m)$ message complexity barrier in the CONGEST model for MIS or closely-related symmetry breaking problems? We present the following results: - Time Complexity: We show that we can break the $O(\log n)$ "barrier" for 2- and 3-ruling sets. We compute 3-ruling sets in $O\left(\frac{\log n}{\log \log n}\right)$ rounds with high probability (whp). More generally we show that 2-ruling sets can be computed in $O\left(\log \Delta \cdot (\log n)^{1/2 + \varepsilon} + \frac{\log n}{\log\log n}\right)$ rounds for any $\varepsilon > 0$, which is $o(\log n)$ for a wide range of $\Delta$ values (e.g., $\Delta = 2^{(\log n)^{1/2-\varepsilon}}$). These are the first 2- and 3-ruling set algorithms to improve over the $O(\log n)$-round complexity of Luby's algorithm in the CONGEST model. - Message Complexity: We show an $\Omega(n^2)$ lower bound on the message complexity of computing an MIS (i.e., 1-ruling set) which holds also for randomized algorithms and present a contrast to this by showing a randomized algorithm for 2-ruling sets that, whp, uses only $O(n \log^2 n)$ messages and runs in $O(\Delta \log n)$ rounds. This is the first message-efficient algorithm known for ruling sets, which has message complexity nearly linear in $n$ (which is optimal up to a polylogarithmic factor).

Figures

Equations

$$\Pr(\exists\text{ a simple path with $2p-1$ nodes that joins }M_{i,t})\leqslant n\cdot\frac{1}{\mathopen{}\mathclose{{}\left(2^{\log\log n}}\right)^{\varepsilon\frac{4\log n}{\varepsilon\log\log n}}}=n\cdot\frac{1}{n^{4}}=\frac{1}{n^{3}}.$$

$$\Pr(P\text{ is in }B_{t})\leqslant\prod_{v\in P}{\Pr\mathopen{}\mathclose{{}\left(v\text{ and at least $\Delta_{t}/2$ neighbors do not mark themselves in scale }t}\right)}.$$

$$\Pr(\text{All nodes in }P\text{ remain undecided after Step (2)})\leqslant\mathopen{}\mathclose{{}\left(\frac{1}{2^{c^{\prime}\sqrt{\log n}}}}\right)^{cp}.$$

$$\Pr(\exists\text{ a length-$p$ witness path $P$ in $G[S]$:}\,E_{P})\leqslant n\mathopen{}\mathclose{{}\left(2^{c^{\prime}\sqrt{\log n}}}\right)^{5p}\cdot\mathopen{}\mathclose{{}\left(\frac{1}{2^{c^{\prime}\sqrt{\log n}}}}\right)^{cp}\leqslant n\mathopen{}\mathclose{{}\left(2^{\sqrt{\log n}}}\right)^{pc^{\prime}(5-c)}.$$

$$\sum _{u\in N(v):d(u)⩾d(v)}\frac{1}{2d(u)}⩽\sum _{u\in N(v):d(u)⩾d(v)}\frac{1}{2d(v)}⩽\sum _{u\in N(v)}\frac{1}{2d(v)}⩽\frac{d(v)}{2d(v)}=\frac{1}{2}.$$

$$\displaystyle\text{Var}\mathopen{}\mathclose{{}\left[X_{v}}\right]$$

$$\displaystyle\text{Var}\mathopen{}\mathclose{{}\left[X}\right]$$

$$\mathrm{Pr}(X⩾k+4|Z(U)|\log n)$$

$$\displaystyle\leqslant\exp\mathopen{}\mathclose{{}\left(-\frac{16|Z(U)|^{2}\log^{2}n}{(|Z(U)|^{2})/2+(8/3)|Z(U)|^{2}\log n}}\right),$$

$$\sum _{v\in U}d(v)⩽\sum _{v\in U}|N^{\prime }(v)|+\sum _{v\in U}|N_2(v)|.$$

$$\sum _{v\in U}|N_2(v)|⩽\sum _{v\in U}d(v)/2⩽k|Z^{\prime }(U)|⩽|Z^{\prime }(U){|}^2.$$

$$\sum _{v\in U}d(v)⩽|Z^{\prime }(U){|}^2/2+|Z^{\prime }(U){|}^2⩽(3/2)|Z^{\prime }(U){|}^2.$$

$$\Pr(Y\geqslant E[Y]+4n\log^{2}n)\leqslant\exp\mathopen{}\mathclose{{}\left(-\frac{16n^{2}\log^{4}n}{8n\log^{2}n+(2/3)2n\log n(4n\log^{2}n)}}\right)\leqslant O(1/n^{2}).$$

$$\displaystyle\text{Pr}\mathopen{}\mathclose{{}\left[\text{$\mathcal{A}$ succ.}}\right]=\!\!\!\sum_{W\in\{LR^{\prime},RL^{\prime}\}}\!\!\!\!\text{Pr}\mathopen{}\mathclose{{}\left[W\mid\text{$G\not\leftrightarrow G^{\prime}$ }}\right]\cdot\text{Pr}\mathopen{}\mathclose{{}\left[\text{$G\not\leftrightarrow G^{\prime}$}}\right]+\text{Pr}\mathopen{}\mathclose{{}\left[\text{$\mathcal{A}$ succ.}\mid\text{$G\leftrightarrow G^{\prime}$}}\right]\cdot\text{Pr}\mathopen{}\mathclose{{}\left[\text{$G\leftrightarrow G^{\prime}$}}\right]\geqslant 1-\epsilon.$$

$$\displaystyle\sum_{W\in\{LR^{\prime},RL^{\prime}\}}\!\text{Pr}\mathopen{}\mathclose{{}\left[W\mid\text{$G\not\leftrightarrow G^{\prime}$ }}\right]\geqslant 1-\epsilon-o(1).$$

$$\displaystyle\sum_{W\in\{LR^{\prime},RL^{\prime}\}}\!\text{Pr}\mathopen{}\mathclose{{}\left[W\mid\text{on $D$}}\right]\geqslant 1-\epsilon-o(1).$$

$$\text{Pr}\mathopen{}\mathclose{{}\left[LR^{\prime}\mid\text{on $D$}}\right]+\text{Pr}\mathopen{}\mathclose{{}\left[RL^{\prime}\mid\text{on $D$}}\right]\leqslant\tfrac{1}{2},$$

$$Pr(X<(1-\varepsilon)E[X])\leqslant\exp\mathopen{}\mathclose{{}\left(-\frac{\varepsilon^{2}}{2}E[X]}\right).$$

$$Pr(X>E[X]+t)\leqslant\exp\mathopen{}\mathclose{{}\left(\frac{t^{2}}{2\sigma^{2}(1+bt/3\sigma^{2})}}\right).$$

Full text

This paper presents progress towards this question for the distributed ruling set problem in the Congest model. A $\beta$-ruling set is an independent set such that every node in the graph is at most $\beta$ hops from a node in the independent set. We present the following results:

• •

Time Complexity: We show that we can break the $O(\log n)$ “barrier” for 2- and 3-ruling sets. We compute 3-ruling sets in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\log\log n}}\right) rounds with high probability (whp). More generally we show that 2-ruling sets can be computed in O\mathopen{}\mathclose{{}\left(\log\Delta\cdot(\log n)^{1/2+\varepsilon}+\frac{\log n}{\log\log n}}\right) rounds for any $\varepsilon>0$, which is $o(\log n)$ for a wide range of $\Delta$ values (e.g., $\Delta=2^{(\log n)^{1/2-\varepsilon}}$). These are the first 2- and 3-ruling set algorithms to improve over the $O(\log n)$-round complexity of Luby’s algorithm in the Congest model.

• •

Message Complexity: We show an $\Omega(n^{2})$ lower bound on the message complexity of computing an MIS (i.e., 1-ruling set) which holds also for randomized algorithms and present a contrast to this by showing a randomized algorithm for 2-ruling sets that, whp, uses only $O(n\log^{2}n)$ messages and runs in $O(\Delta\log n)$ rounds. This is the first message-efficient algorithm known for ruling sets, which has message complexity nearly linear in $n$ (which is optimal up to a polylogarithmic factor).

Our results are a step toward understanding the time and message complexity of symmetry breaking problems in the Congest model.

1. Introduction

The maximal independent set (MIS) problem is one of the fundamental problems in distributed computing because it is a simple and elegant abstraction of “local symmetry breaking,” an issue that arises repeatedly in many distributed computing problems. About 30 years ago Alon, Babai, and Itai [1] and Luby [28] presented a randomized algorithm for MIS, running on $n$-node graphs in $O(\log n)$ rounds with high probability (whp)111Throughout, we use “with high probability (whp)” to mean with probability at least $1-1/n^{c}$, for some $c\geqslant 1$.. Since then the MIS problem has been studied extensively and recently, there has been some exciting progress in designing faster MIS algorithms. For $n$-node graphs with maximum degree $\Delta$, Ghaffari [16] presented an MIS algorithm running in $O(\log\Delta)+2^{O(\sqrt{\log\log n})}$ rounds, improving over the algorithm of Barenboim et al. [6] that runs in $O(\log^{2}\Delta)+2^{O(\sqrt{\log\log n})}$ rounds. Ghaffari’s MIS algorithm is the first MIS algorithm to improve over the round complexity of Luby’s algorithm when $\Delta=2^{o(\log n)}$ and $\Delta$ is bounded below by $\Omega(\log n)$.222For $\Delta=o(\log n)$, the deterministic MIS algorithm of Barenboim, Elkin, and Kuhn [4] that runs $O(\Delta+\log^{*}n)$ rounds is faster than Luby’s algorithm.

While the results of Ghaffari and Barenboim et al. constitute a significant improvement in our understanding of the round complexity of the MIS problem, it should be noted that both of these results are in the Local model. The Local model [34] is a synchronous, message-passing model of distributed computing in which messages can be arbitrarily large. Luby’s algorithm, on the other hand, is in the Congest model [34] and uses small messages, i.e., messages that are $O(\log n)$ bits or $O(1)$ words in size. In fact, to date, Luby’s algorithm is the fastest known MIS algorithm in the Congest model; this is the case even when $\Delta$ is between $\Omega(\log n)$ and $2^{o(\log n)}$. For example, for the class of graphs with $\Delta=2^{O(\sqrt{\log n})}$, Ghaffari’s MIS algorithm runs in $O(\sqrt{\log n})$ rounds whp in the Local model, but we don’t know how to compute an MIS for this class of graphs in $o(\log n)$ rounds in the Congest model. It should be further noted that the MIS algorithms of Ghaffari and Barenboim et al. use messages of size $O(\text{poly}(\Delta)\log n)$ (see Theorem 3.5 in [6]), which can be much larger than the $O(\log n)$-sized messages allowed in the Congest model; in fact these algorithms do not run within the claimed number of rounds even if messages of size $O(\operatorname{poly}(\log n))$ were allowed. Furthermore, large messages arise in these algorithms from a topology-gathering step in which cluster-leaders gather the entire topology of their clusters in order to compute an MIS of their cluster – this step seems fundamental to these algorithms and there does not seem to be an efficient way to simulate this step in the Congest model.

Ruling sets are a natural generalization of MIS and have also been well-studied in the Local model. An $(\alpha,\beta)$-ruling set [17] is a node-subset $T$ such that (i) any two distinct nodes in $T$ are at least $\alpha$ hops apart in $G$ and (ii) every node in the graph is at most $\beta$ hops from some node in $T$. A $(2,\beta)$-ruling set is an independent set and since such ruling sets are the main focus of this paper, we use the shorthand $\beta$-ruling sets to refer to $(2,\beta)$-ruling sets. (Using this terminology an MIS is just a 1-ruling set.) The above mentioned MIS results due to Barenboim et al. and Ghaffari have also led to the sublogarithmic-round algorithms for $\beta$-ruling sets for $\beta\geqslant 2$. The earliest instance of such a result was the algorithm of Kothapalli and Pemmaraju [22] that computed a 2-ruling set in $O(\sqrt{\log\Delta}\cdot(\log n)^{1/4})$ rounds by using an earlier version of the Barenboim et al. [5] MIS algorithm. There have been several further improvements in the running time of ruling set algorithms culminating in the $O(\beta\log^{1/\beta}\Delta)+2^{O(\sqrt{\log\log n})}$ round $\beta$-ruling set algorithm of Ghaffari [16]. This result is based on a recursive sparsification procedure of Bisht et al. [8] that reduces the $\beta$-ruling set problem on graphs with maximum degree $\Delta$ to an MIS problem on graphs with degree much smaller. Ghaffari’s $\beta$-ruling set result is also interesting because it identifies a separation between 2-ruling sets and MIS (1-ruling sets). This follows from the lower bound of \Omega\mathopen{}\mathclose{{}\left(\min\mathopen{}\mathclose{{}\left\{\sqrt{\frac{\log n}{\log\log n}},\frac{\log\Delta}{\log\log\Delta}}\right\}}\right) for MIS due to Kuhn et al. [23]. Again, we emphasize here that all of these improvements for ruling set algorithms are only in the Local model because these ruling set algorithms rely on Local-model MIS algorithms to “finish off” the processing of small degree subgraphs. As far as we know, prior to the current work there has been no $o(\log n)$-round, $\beta$-ruling set algorithm in the Congest model for any $\beta=O(1)$.

The focus of all the above results has been on the time (round) complexity. Message complexity, on the other hand, has been largely ignored in the context of local symmetry breaking problems such as MIS and ruling sets. For a graph with $m$ edges, Luby’s algorithm uses $O(m)$ messages in the Congest model and until now there has been no MIS or ruling set algorithm that uses $o(m)$ messages. We note that the ruling set algorithm of Goldberg et al. [17] which can be implemented in the Congest model [19] also takes at least $\Omega(m)$ messages.

The focus of this paper is symmetry breaking problems in the Congest model and the specific question that motivates our work is whether we can go beyond Luby’s algorithm in the Congest model for MIS or any closely-related symmetry breaking problems such as ruling sets. In particular, can we break the $\Theta(\log n)$ time complexity barrier and the $\Theta(m)$ message complexity barrier, in the Congest model for MIS and ruling sets? In many applications, especially in resource-constrained communication networks and in distributed processing of large-scale data it is important to design distributed algorithms that have low time complexity as well as message complexity. In particular, optimizing messages as well as time has direct applications to the performance of distributed algorithms in other models such as the $k$-machine model [21].

We present two sets of results, one set focusing on time (round) complexity and the other on message complexity.

1. Time complexity: (cf. Section 2) We first show that 2-ruling sets can be computed in the Congest model in O\mathopen{}\mathclose{{}\left(\log\Delta\cdot(\log n)^{1/2+\varepsilon}+\frac{\log n}{\log\log n}}\right) rounds whp for $n$-node graphs with maximum degree $\Delta$ and for any $\varepsilon>0$. This is the first algorithm to improve over Luby’s algorithm, by running in $o(\log n)$ rounds in the Congest model, for a wide range of values of $\Delta$. Specifically our algorithm runs in $o(\log n)$ rounds for $\Delta$ bounded above by $2^{(\log n)^{1/2-\varepsilon}}$ for any value of $\varepsilon>0$. Using this 2-ruling set algorithm as a subroutine, we show how to compute 3-ruling sets (for any graph) in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\log\log n}}\right) rounds whp in the Congest model. We also present a simple 5-ruling set algorithm based on Ghaffari’s MIS algorithm that runs in $O(\sqrt{\log n})$ rounds in the Congest model.

2. Message complexity: (cf. Sections 3 and 4) We show that $\Omega(n^{2})$ is a fundamental lower bound for computing an MIS (i.e., 1-ruling set) by showing that there exists graphs (with $m=\Theta(n^{2})$ edges) where any distributed MIS algorithm needs $\Omega(n^{2})$ messages. In contrast, we show that 2-ruling sets can be computed using significantly smaller message complexity. In particular, we present a randomized 2-ruling set algorithm that, whp, uses $O(n\log^{2}n)$ messages and runs in $O(\Delta\log n)$ rounds. This is the first $o(m)$-message algorithm known for ruling sets, which takes near-linear (in $n$) message complexity. This message bound is tight up to a polylogarithmic factor, since we show that any $O(1)$-ruling set (randomized) algorithm that succeeds with probability $1-o(1)$ requires $\Omega(n)$ messages in the worst case. We also present a simple 2-ruling set algorithm that uses $O(n^{1.5}\log n)$ messages, but runs faster — in $O(\log n)$ rounds.

Our results make progress towards understanding the complexity of symmetry breaking, in particular with respect to ruling sets, in the Congest model. With regards to time complexity, our results, for the first time, show that one can obtain $o(\log n)$ round algorithms for ruling sets in the Congest model. With regards to message complexity, our results are (essentially) tight: while MIS needs quadratic (in $n$) messages in the worst case, 2-ruling sets can be computed using near-linear (in $n$) messages. We discuss key problems left open by our work in Section 5.

1.1. Distributed Computing Model

We consider the standard synchronous Congest model [34] described as follows.

We are given a distributed network of $n$ nodes, modeled as an undirected graph $G$. Each node hosts a processor with limited initial knowledge. We assume that nodes have unique IDs (this is not essential, but simplifies presentation), and at the beginning of the computation each node is provided its ID as input. Thus, a node has only local knowledge333Our near-linear message-efficient algorithm (Section 3) does not require knowledge of $n$ or $\Delta$, whereas our time-efficient algorithms (Section 2) assume knowledge of $n$ and $\Delta$ (otherwise it will work up to a given $\Delta$).. Specifically we assume that each node has ports (each port having a unique port number); each incident edge is connected to one distinct port. This model is referred to as the clean network model in [34] and is also sometimes referred to as the $KT_{0}$ model, i.e., the initial (K)nowledge of all nodes is restricted (T)ill radius 0 (i.e., just the local knowledge) [3].

Nodes are allowed to communicate through the edges of the graph $G$ and it is assumed that communication is synchronous and occurs in discrete rounds (time steps). In each round, each node can perform some local computation including accessing a private source of randomness, and can exchange (possibly distinct) $O(\log n)$-bit messages with each of its neighboring nodes. This model of distributed computation is called the $\textsc{Congest}(\log n)$ model or simply the Congest model [34].

1.2. Related Work

As one would expect, Congest model symmetry breaking algorithms are easier for sparse graphs. There is a deterministic $(\Delta+1)$-coloring algorithm due to Barenboim, Elkin, and Kuhn [4] that runs in the Congest model in $O(\Delta)+\frac{1}{2}\log^{*}n$ rounds. This can be used to obtain an $o(\log n)$-round Congest model MIS algorithm, when $\Delta=o(\log n)$. For trees, Lenzen and Wattenhofer [27] presented an MIS algorithm that runs in $O(\sqrt{\log n}\log\log n)$ rounds whp in the Congest model. More generally, for graphs with arboricity bounded above by $\alpha$, Pemmaraju and Riaz [35] present an MIS algorithm that runs in $O(\mbox{poly}(\alpha)\cdot\sqrt{\log n\log\log n})$ rounds in the Congest model. Other research that is relevant to ruling sets, but is only in the Local model, includes the multi-trials technique of Schneider and Wattenhofer [37] and the deterministic ruling set algorithms of Schneider et al. [36].

As mentioned earlier, in the context of local symmetry breaking problems such as MIS or ruling sets, message complexity has not received much attention. However, in the context of global problems (i.e., problems where one needs to traverse the entire network and, hence, take at least $\Omega(D)$ time) such as leader election (which can be thought as a “global" symmetry breaking) and minimum spanning tree (MST), message complexity has been very well studied. Kutten et al. [24] showed that $\Omega(m)$ is a message lower bound for leader election and this applies to randomized Monte-Carlo algorithms as well. This lower bound also applies to the Broadcast and MST problems. In a similar spirit, in this paper, we show that in general, $\Omega(m)$ is a message lower bound for the MIS problem as well. In contrast, we show that this lower bound does not hold for ruling sets which admit a near-linear (in $n$) message complexity.

It is important to point out that the current paper as well as most prior work on leader election and MST  [2, 9, 14, 15, 26, 13, 12, 33, 24]) assume the $KT_{0}$ model. However, one can also consider a stronger model where nodes have initial knowledge of the identity of their neighbors. This model is called the $KT_{1}$* model*. Awerbuch et al. [3] show that $\Omega(m)$ is a message lower bound for MST for the $KT_{1}$ model, if one allows only comparison-based algorithms (i.e., algorithms that can operate on IDs only by comparing them); this lower bound for comparison-based algorithms applies to randomized algorithms as well. Awerbuch et al. [3] also show that the $\Omega(m)$ message lower bound applies even to non-comparison based (in particular, algorithms that can perform arbitrary local computations) deterministic algorithms in the Congest model that terminate in a time bound that depends only on the graph topology (e.g., a function of $n$). On the other hand, for randomized non-comparison-based algorithms, it turns out that the message lower bound of $\Omega(m)$ does not apply in the $KT_{1}$ model. King et al. [20] showed a surprising and elegant result (also see [29]): in the $KT_{1}$ model one can give a randomized Monte Carlo algorithm to construct a MST or a spanning tree in $\tilde{O}(n)$ messages ($\Omega(n)$ is a message lower bound) and in $\tilde{O}(n)$ time (this algorithm uses randomness and is not comparison-based). While this algorithm shows that one can get $o(m)$ message complexity (when $m=\omega(n\operatorname{polylog}n)$), it is not time-optimal (it can take up to $\tilde{O}(n)$ rounds).

One can also use the King et al. algorithm to build a spanning tree using $\tilde{O}(n)$ messages and then use time encoding (see e.g., [18, 32]) to collect the entire graph topology at the root of the spanning tree. Hence, using this approach any problem (including, MST, MIS, ruling sets, etc.) can be solved using $\tilde{O}(n)$ messages in the $KT_{1}$ model. However, this is highly time inefficient as it takes exponential (in $n$) rounds.

1.3. Technical Overview

1.3.1. Time Bounds

The MIS algorithms of Barenboim et al. [6] and Ghaffari [16] use a 2-phase strategy, attributed to Beck [7], who used it in his algorithmic version of the Lovász Local Lemma. In the first phase, some number of iterations of a Luby-type “base algorithm” are run (in the Congest model). During this phase, some nodes join the MIS and these nodes and their neighbors become inactive. The first phase is run until the graph is “shattered”, i.e., the nodes that remain active induce a number of “small” connected components. Once the graph is “shattered”, the algorithm switches to the second, deterministic phase to “finish off” the problem in the remaining small components. It is this second phase that relies critically on the use of the Local model in order to run fast.

In general, in the Congest model it is not clear how to take advantage of low degree or low diameter or small size of a connected component to solve symmetry-breaking problems (MIS or ruling sets) faster than the $O(\log n)$-round bound provided by Luby’s algorithm. In both Barenboim et al. [6] and Ghaffari [16], a key ingredient of the second “finish-off” phase is the deterministic network decomposition algorithm of Panconesi and Srinivasan [31] that can be used to compute an MIS in $O(2^{\sqrt{\log s}})$ rounds on a graph with $s$ nodes in the Local model. If one can get connected components of size $O(\mbox{poly}(\log n))$ then it is possible to finish the rest of the algorithm in $2^{O(\sqrt{\log\log n})}$ rounds and this is indeed the source of the “$2^{O(\sqrt{\log\log n})}$” term in the round complexity of these MIS algorithms. In fact, the Panconesi-Srinivasan network decomposition algorithm itself runs in the Congest model, but once the network has been decomposed into small diameter clusters then algorithms simply resort to gathering the entire topology of a cluster at a cluster-leader and this requires large messages. Currently, there seem to be no techniques for symmetry breaking problems in the Congest model that are able to take advantage of the diameter of a network being small. As far as we know, there is no $o(\log n)$-round $O(1)$-ruling set algorithm in the Congest model even for constant-diameter graphs, for any constant larger than 1. To obtain our sublogarithmic $\beta$-ruling set algorithms (for $\beta=2,3,5$), we use simple greedy MIS and 2-ruling set algorithms to process “small” subgraphs in the final stages of algorithm. These greedy algorithms just exchange $O(\log n)$-bit IDs with neighbors and run in the Congest model, but they can take $\Theta(s)$ rounds in the worst case, where $s$ is the length of the longest path in the subgraph. So our main technical contribution is to show that it is possible to do a randomized shattering of the graph so that none of the fragments have any long paths.

1.3.2. Message Bounds

As mentioned earlier, our message complexity lower bound for MIS and the contrasting the upper bound for 2-ruling set show a clear separation between these two problems. At a high-level, our lower bound argument exploits the idea of “bridge crossing" (similar to [24]) whose intuition is as follows. We consider two types of related graphs: (1) a complete bipartite graph and (2) a random bridge graph which consists of a two (almost-)complete bipartite graphs connected by two “bridge" edges chosen randomly (see Figure 1 and Section 4 for a detailed description of the construction). Note that the MIS in a complete bipartite graph is exactly the set of all nodes belonging to one part of the partition. The crucial observation is that if no messages are sent over bridge edges, then the bipartite graphs on either side of the bridge edges behave identically which can result in choosing adjacent nodes in MIS, a violation. In particular, we show that if an algorithm sends $o(n^{2})$ messages, then with probability at least $1-o(1)$ that there will be no message sent over the bridge edges and by symmetry, with probability at least $1/2$, two nodes that are connected by the bridge edge will be chosen to be in the MIS.

Our 2-ruling set algorithm with low-message-complexity crucially uses the fact that, unlike in an MIS, in a 2-ruling set there are 3 categories of nodes: category-1 (nodes that are in the independent set), category-2 (nodes that are neighbors of category-1) and category-3 nodes (nodes that are neighbors of category-2, but not neighbors of category-1). Our algorithm, inspired by Luby’s MIS algorithm, uses three main ideas. First, category-2 and category-3 nodes don’t initiate messages; only undecided nodes (i.e., nodes whose category are not yet decided) initiate messages. Second, an undecided node does “checking sampling" (cf. Algorithm 4) first before it does local broadcast, i.e., it samples a few of its neighbors to see if they are any category-2 nodes; if so it becomes a category-3 node immediately. Third, an undecided node tries to enter the ruling set with probability that is always inversely proportional to its original degree, i.e., $\Theta(1/d(v))$, where $d(v)$ is the degree of $v$. This is unlike in Luby’s algorithm, where the marking probability is inversely proportional to its current degree. These ideas along with an amortized charging argument [10] yield our result: an algorithm using $O(n\log^{2}n)$ messages and running in $O(\Delta\log n)$ rounds.

2. Time-Efficient Ruling Set Algorithms in the Congest model

The main result of this section is a 2-ruling set algorithm in the Congest model that runs in O\mathopen{}\mathclose{{}\left(\log\Delta\cdot(\log n)^{1/2+\varepsilon}+\frac{\log n}{\log\log n}}\right) rounds whp, for any constant $\varepsilon>0$, on $n$-node graphs with maximum degree $\Delta$. An implication of this result is that for graphs with $\Delta=2^{O((\log n)^{1/2-\varepsilon})}$ for any $\varepsilon>0$, we can compute a 2-ruling set in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\log\log n}}\right) rounds in the Congest model. A second implication is that using this 2-ruling set algorithm as a subroutine, we can compute a 3-ruling set for any graph in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\log\log n}}\right) rounds whp in the Congest model. These are the first sublogarithmic-round Congest model algorithms for 2-ruling sets (for a wide range of $\Delta$) and 3-ruling sets. Combining some of the techniques used in these algorithms with the first phase of Ghaffari’s MIS algorithm [16], we also show that a 5-ruling set can be computed in $O(\sqrt{\log n})$ rounds whp in the Congest model.

2.1. The 2-ruling Set Algorithm

Our 2-ruling set algorithm (described in pseudocode below) takes as input an $n$-node graph with maximum degree $\Delta\leqslant 2^{\sqrt{\log n}}$, along with a parameter $\varepsilon>0$. For $\Delta>2^{\sqrt{\log n}}$, we simply execute Luby’s MIS algorithm to solve the problem. The algorithm consists of $\lceil\log\Delta\rceil$ scales and in scale $t$, $1\leqslant t\leqslant\lceil\log\Delta\rceil$, nodes with degrees at most $\Delta_{t}:=\Delta/2^{t-1}$ are processed. Each scale consists of $\Theta(\log^{1/2+\varepsilon}n)$ iterations. In an iteration $i$, in scale $t$, each undecided node independently joins a set $M_{i,t}$ with probability $1/(\Delta_{t}\cdot\log^{\varepsilon}n)$ (Line 1). Neighbors of nodes in $M_{i,t}$, that are themselves not in $M_{i,t}$, are set aside and placed in a set $W_{i,t}$ (Lines 1-1). The nodes in $M_{i,t}\cup W_{i,t}$ have decided their fate and we continue to process the undecided nodes. At the end of all the iterations in a scale $t$, any undecided node that still has $\Delta_{t}/2$ or more undecided neighbors is placed in a “bad” set $B_{t}$ for that scale (Line 1), thus effectively deciding the fate of all nodes with degree at least $\Delta_{t}/2$. We now process the set of scale-$t$ “bad” nodes, $B_{t}$, by simply running a greedy 2-ruling set algorithm on $B_{t}$ (Line 1). We also need to process the sets $M_{i,t}$ (Line 1) and for that we rely on a greedy 1-ruling set algorithm (i.e., a greedy MIS algorithm). Note that the $M_{i,t}$’s are all disconnected from each other since the $W_{i,t}$’s act as “buffers” around the $M_{i,t}$’s. Thus after all the scales are completed, we can compute an MIS on all of the $M_{i,t}$’s in parallel. Since each node in $W_{i,t}$ has a neighbor in $M_{i,t}$, this will guarantee that every node in $W_{i,t}$ has an independent set node at most 2 hops away. In the following algorithm we use $deg_{S}(v)$ to denote the degree of a vertex $v$ in the $G[S]$, the graph induced by $S$.

The overall round complexity of this algorithm critically depends on the greedy 2-ruling set algorithm terminating quickly on each $B_{t}$ (Line 1) and the greedy 1-ruling set algorithm terminating quickly on each $M_{i,t}$ (Line 1). To be concrete, we present below a specific $\beta$-ruling set algorithm that greedily picks nodes by their IDs from a given node subset $R$.

To show that the calls to this greedy ruling set algorithm terminate quickly, we introduce the notion of witness paths. If $\textsc{GreedyRulingSet}(G,R,\beta)$ runs for $p$ iterations (of the while-loop), then $R$ must contain a sequence of nodes $(v_{1},v_{2},\ldots,v_{p})$ such that $v_{i}$, $1\leqslant i\leqslant p$, joins the independent set $I$ in iteration $i$ and node $v_{i}$, $1<i\leqslant p$, must contain an undecided node with higher ID in its $1$-neighborhood in $G$, which was removed when $v_{i-1}$ and its $\beta$-neighborhood in $G$ were removed in iteration $i-1$. We call such a sequence a witness path for the execution of GreedyRulingSet. Three simple properties of witness paths are needed in our analysis: (i) any two nodes $v_{i}$ and $v_{j}$ in the witness path are at least $\beta+1$ hops away in $G$, (ii) any two consecutive nodes $v_{i}$ and $v_{i+1}$ in the witness path are at most $\beta+1$ hops away in $G$, and (iii) $G[R]$ contains a simple path with $(p-1)(\beta+1)+1$ nodes, starting at node $v_{1}$, passing through nodes $v_{2},v_{3},\ldots,v_{p-1}$ and ending at node $v_{p}$.

To show that each $M_{i,t}$ can be processed quickly by the greedy 1-ruling set algorithm we show (in Lemma 2.1) that whp every witness path for the execution of the greedy 1-ruling set algorithm is short. Similarly, to show that each $B_{t}$ can be processed quickly by the greedy 2-ruling set algorithm we prove (in Lemma 2.3) that whp a “bad” set $B_{t}$ cannot contain a witness path of length $\sqrt{\log n}$ or longer to the execution of the greedy 2-ruling set algorithm. At the start of our analysis we observe that the set $S_{t}$, which is the set of undecided nodes at the start of scale $t$, induces a subgraph with maximum degree $\Delta_{t}=\Delta/2^{t-1}$.

Lemma 2.1**.**

For all scales $t$ and iterations $i$, $\textsc{GreedyRulingSet}(G[S_{t}],M_{i,t},1)$ runs in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\varepsilon\log\log n}}\right) rounds, whp.

Proof 2.2**.**

Consider an arbitrary scale $t$ and iteration $i$. By Property (iii) of witness paths, there is a simple path $P$ with $(2p-1)$ nodes in $G[S_{t}]$, all of whose nodes have joined $M_{i,t}$. Due to independence of the marking step (Line 1) the probability that all nodes in $P$ join $M_{i,t}$ is at most $(1/\Delta_{t}\cdot\log^{\varepsilon}n)^{2p-1}$. Since $\Delta(G[S_{t}])\leqslant\Delta_{t}$, the number of simple paths with $2p-1$ nodes in $G[S_{t}]$ are at most $n\cdot\Delta_{t}^{2p-1}$. Using a union bound over all candidate simple paths with $2p-1$ nodes in $G[S_{t}]$, we see that the probability that there exists a simple path in $G[M_{i,t}]$ of length $2p-1$ is at most: n\cdot\Delta_{t}^{2p-1}\cdot\mathopen{}\mathclose{{}\left(\frac{1}{\Delta_{t}\log^{\varepsilon}n}}\right)^{2p-1}=n\cdot\frac{1}{(\log n)^{\varepsilon(2p-1)}}. Picking $p$ to be the smallest integer such that $2p-1\geqslant\frac{4\log n}{\varepsilon\log\log n}$, we get

[TABLE]

We have $O(\log\Delta\cdot(\log n)^{1/2+\varepsilon})$ different $M_{i,t}$’s. Using a union bound over these $M_{i,t}$’s, we see that the probability that there exists an $M_{i,t}$ containing a simple path with $2p-1$ nodes is at most $n^{-2}$. Thus with probability at least $1-1/n^{2}$, all of the calls to $\textsc{GreedyRulingSet}(G[S_{t}],M_{i,t},1))$ (in Line 1) complete in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\log\log n}}\right) rounds.

Lemma 2.3**.**

For all scales $t$, the call to $\textsc{GreedyRulingSet}(G[S_{t}],B_{t},2)$ takes $O(\sqrt{\log n})$ rounds whp.

Proof 2.4**.**

Consider a length-$p$ witness path $P$ for the execution of $\textsc{GreedyRulingSet}(G[S_{t}],B_{t},2)$ (Line 1). By Property (i) of witness paths, all pairs of nodes in $P$ are at distance at least 3 from each other. Fix a scale $t$. We now calculate the probability that all nodes in $P$ belong to $B_{t}$. Consider some node $v\in P$. For $v$ to belong to $B_{t}$, it must have not marked itself in all iterations of scale $t$ and moreover at least $\Delta_{t}/2$ neighbors of $v$ in $S_{t}$ must not have marked themselves in any iteration of scale $t$. Since the neighborhoods of any two nodes in $P$ are disjoint, the event that $v$ joins $B_{t}$ is independent of any other node in $P$ joining $B_{t}$. Therefore,

[TABLE]

This can be bounded above by \prod_{v\in P}{\mathopen{}\mathclose{{}\left(1-\frac{1}{\Delta_{t}(\log n)^{\varepsilon}}}\right)^{\frac{\Delta_{t}}{2}\cdot c(\log n)^{1/2+\varepsilon}}}\leqslant\exp\mathopen{}\mathclose{{}\left(-\frac{c}{2}\cdot(\log n)^{1/2}\cdot p}\right). Plugging in $p=\sqrt{\log n}$ we see that this probability is bounded above by $n^{-c/2}$. By Property (ii) of witness paths and the fact that $\Delta(G[S_{t}])\leqslant\Delta_{t}$, we know that there are at most $n\cdot(\Delta_{t})^{3p}$ length-$p$ candidate witness paths. Using a union bound over all of these, we get that the probability that there exists a a witness path that joins $B_{t}$ is at most $n\Delta^{3p}\cdot n^{-c/2}$. Plugging in $\Delta\leqslant 2^{\sqrt{\log n}}$ and $p=\sqrt{\log n}$ we get that this probability is at most $n\cdot n^{3}\cdot n^{-c/2}=n^{-c/2+4}.$ Picking a large enough constant $c$ guarantees that this probability is at most $1/n^{2}$ and taking a final union bound over all $\lceil\log\Delta\rceil$ scales gives us the result that all calls to $\textsc{GreedyRulingSet}(G[S_{t}],B_{t},2)$ take $O(\sqrt{\log n})$ rounds whp.

Theorem 2.5**.**

Algorithm 2-RulingSet computes a 2-ruling set in the Congest model in O\mathopen{}\mathclose{{}\left(\log\Delta\cdot(\log n)^{1/2+\varepsilon}+\frac{\log n}{\varepsilon\log\log n}}\right) rounds, whp.

Proof 2.6**.**

Note that there are $O(\log\Delta)$ scales and each scale contains (i) $(\log n)^{1/2+\varepsilon}$ iterations, each of which takes $O(1)$ rounds and (ii) one call to GreedyRulingSet which requires $O(\sqrt{\log n})$ rounds whp by lemma 2.3. Thus Lines 1-1 take $O(\log\Delta\cdot(\log n)^{1/2+\varepsilon})$ rounds. From Lemma 2.1, the call to the greedy MIS algorithm in Line 1, takes $O(\frac{\log n}{\log\log n})$ rounds to compute an MIS of each of the $G[M_{i,t}]$’s in parallel. This yields the claimed running time.

Since all nodes in $W_{i,t}$ are at distance 1 from some node in $M_{i,t}$ and we find an MIS of the graph $G[M_{i,t}]$, nodes in $\cup_{i}\cup_{t}(M_{i,t}\cup W_{i,t})$ are all at distance at most $2$ from some node in $I$. Nodes that are not in any $M_{i,t}\cup W_{i,t}$ are in $B_{t}$ for some scale $t$. We compute 2-ruling sets for nodes in $B_{t}$ and therefore every node is at most 2 hops from some node in $I$.

2.2. The 3-ruling Set Algorithm

This 2-ruling set algorithm can be used to obtain a 3-ruling set algorithm running in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\log\log n}}\right) rounds for any graph in the Congest model. The 3-ruling set algorithm starts by using the simple, randomized subroutine called Sparsify [8, 22] to construct in, say $O((\log n)^{2/3})$ rounds, a set $S$ such that (i) $\Delta(G[S])=2^{O((\log n)^{1/3})}$ whp and (ii) every node is in $S$ or has a neighbor in $S$.

The properties of Sparsify are more precisely described in the following lemma.

Lemma 2.7**.**

(Theorem 1 in [8]) Let $G$ be an $n$-node graph with maximum degree $\Delta$. Algorithm Sparsify with input $G$ and $f$ runs in $O(\log_{f}\Delta)$ rounds in the Congest model and produces a set $S\subseteq V(G)$ such that $\Delta(G[S])=O(f\cdot\log n)$ whp, and every vertex in $V$ is either in $S$ or has a neighbor in $S$.

Using Algorithm 2-Ruling Set on $G[S]$ yields the following corollary.

Corollary 2.8**.**

It is possible to compute a 3-ruling set in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\log\log n}}\right) rounds whp in the Congest model.

Proof 2.9**.**

First call Sparsify with input graph $G$ and parameter $f=2^{(\log n)^{1/3}}$. Sparsify runs in $O((\log n)^{2/3})$ rounds and returns a set $S$ such that $\Delta(G[S])=2^{O((\log n)^{1/3})}$. We then run 2-RulingSet on $G[S]$ with $\varepsilon<1/6$, which completes in O\mathopen{}\mathclose{{}\left(\frac{\log n}{\log\log n}}\right) rounds, returning a $3$-ruling set of $G$.

2.3. 5-ruling sets in $O(\sqrt{\log n})$ rounds

It turns out that for slightly larger but constant $\beta$, it is possible to compute $\beta$-ruling sets in the Congest model in $O(\sqrt{\log n})$ rounds. We show this in this section for $\beta=5$. The 5-ruling set algorithm (described in pseudocode below) starts by calling the Sparsify [8, 22] subroutine.

We use $f=2^{\sqrt{\log n}}$ in our call to Sparsify, which implies that Sparsify runs in $O(\sqrt{\log n})$ rounds. We then run $O(\log\Delta(G[S]))$ iterations of the first phase of Ghaffari’s MIS algorithm on $G[S]$ and this returns an independent set $I$ [16]. Since $\Delta(G[S])=2^{O(\sqrt{\log n})}$, this is equivalent to running $O(\sqrt{logn})$ iterations of the first phase of Ghaffari’s MIS algorithm. Recall that the first phase of Ghaffari’s algorithm is a “Luby-like” algorithm that runs in the Congest model. Finally, we consider the set of nodes that are still undecided, i.e., nodes in $S$ that are not in $I\cup N(I)$ and we call Algorithm GreedyRulingSet algorithm with $\beta=4$ in order to compute a 4-ruling set of the as-yet-undecided nodes. The fact that we compute a 4-ruling set in this step, rather than a $\beta$-ruling set for some $\beta<4$, is because of independence properties of Ghaffari’s MIS algorithm. Steps (1)-(3) of 5-RulingSet run in $O(\sqrt{\log n})$ rounds either by design or due to properties of Sparsify. The fact that the greedy 4-ruling set algorithm (Step (4)) also terminates in $O(\sqrt{\log n})$ rounds remains to be shown and this partly depends on the following property of the first phase of Ghaffari’s MIS algorithm.

Lemma 2.10**.**

(Lemma 4.1 in [16]) For any constant $c>0$, for any set $S$ of nodes that are at pairwise distance at least 5 from each other, the probability that all nodes in $S$ remain undecided after $\Theta(c\log\Delta)$ rounds of the first phase of the MIS algorithm is at most $\Delta^{-c|S|}$.

The sparsification step performed by the call to Sparsify in Step (1) along with Lemma 2.10 and Properties (i) and (ii) of witness paths are used in the following theorem to prove that Step (4) of 5-RulingSet also completes in $O(\sqrt{\log n})$ rounds whp. The fact that we are greedily computing a 4-ruling set in Step (4) and any two nodes selected to be in the ruling set are at least 5 hops away from each other provides the independence that is needed to apply Lemma 2.10.

Theorem 2.11**.**

Algorithm 5-RulingSet computes a 5-ruling set of $G$ in $O(\sqrt{\log n})$ rounds whp.

Proof 2.12**.**

Sparsify* with paramter $2^{\sqrt{\log n}}$ takes $O(\log_{2^{\sqrt{\log n}}}n)=O(\sqrt{\log n})$ time. Also, whp the maximum degree of the graph $G[S]$, $\Delta(G[S])=O(2^{\sqrt{\log n}}\cdot\log n)$ and this is bounded above by $2^{c^{\prime}\sqrt{\log n}}$ for some constant $c^{\prime}$. Next, we run the GhaffariMISPhase1 algorithm for $\Theta(c\log\Delta(G[S]))=O(\sqrt{\log n})$ rounds. We now argue that Step (4) also runs in $O(\sqrt{\log n})$ rounds whp.*

Suppose that the call to $\textsc{GreedyRulingSet}(G[S],R,4)$ takes $p$ iterations, Then, there is a witness path $P=(v_{1},v_{2},\ldots,v_{p})$ in $G[S]$ to the execution of this algorithm. Then, by Lemma 2.10 and Property (i) of witness paths:

[TABLE]

Now we use Property (ii) of witness paths to upper bound the total number of possible length-$p$ witness paths in $G[S]$ by $|S|\cdot\Delta(G[S])^{5p}$. Let $E_{P}$ denote the event that all nodes of a possibe length-$p$ witness path $P$ in $G[S]$ have remained undecided after Step (2). Taking a union bound over all possible length-$p$ witness paths in $G[S]$ we see that

[TABLE]

Plugging in $p=\sqrt{\log n}$ and choosing $c\geqslant 5+2/c^{\prime}$ we get an upper bound of $1/n$ on the probability that a length-$p$ witness path exists after Step (2). This implies that whp Step (4) takes $O(\sqrt{\log n})$ rounds.

Step (4) computes a 4-ruling set of $G[R]$ and this along with the set $I$ form a 4-ruling set of $G[S]$. Since every node is at most 1 hop away from some node in $S$, we have computed a 5-ruling set of $G$.

3. A Message-Efficient Algorithm for 2-Ruling Set

In this section, we present a randomized distributed algorithm for computing a 2-ruling set in the Congest model that takes $O(n\log^{2}n)$ messages and $O(\Delta\log n)$ rounds whp, where $n$ is the number of nodes and $\Delta$ is the maximum node degree. The algorithm does not require any global knowledge, including knowledge of $n$ or $\Delta$. We show in Theorem 4.1 that the algorithm is essentially message-optimal (up to a $\operatorname{polylog}(n)$ factor). This is the first message-efficient algorithm known for 2-ruling set, i.e., it takes $o(m)$ messages, where $m$ is the number of edges in the graph.

In contrast, we show in Theorem 4.3 that computing a MIS requires $\Omega(n^{2})$ messages (regardless of the number of rounds). Thus there is a fundamental separation of message complexity between 1-ruling set (MIS) and 2-ruling set computation.

3.1. The Algorithm

Algorithm 4 is inspired by Luby’s algorithm for MIS [28]; however, there are crucial differences. (Note that Luby’s algorithm sends $\Theta(m)$ messages.) Given a ruling set $R$, we classify nodes in $V$ into three categories:

• •

category-1: nodes that belong to the ruling set $R$;

• •

category-2: nodes that have a neighbor in $R$; and

• •

category-3: the rest of the nodes, i.e., nodes that have a neighbor in category-2.

At the beginning of the algorithm, each node is undecided, i.e., its category is not set and upon termination, each node knows its category.

Let us describe one iteration of the algorithm (Steps 4-4) from the perspective of an arbitrary node $v$. Each undecided node $v$ marks itself with probably $1/2d(v)$. If $v$ is marked it samples a set of $\Theta(\log(d(v))$ random neighbours and checks whether any of them belong to category-2 — we call this the checking sampling step. If so, then $v$ becomes a category-3 node and is done (i.e., it will never broadcast again, but will continue to answer checking sampling queries, if any, from its neighbors). Otherwise, $v$ performs the broadcast step, i.e., it communicates with all its neighbors and checks if there is a marked neighbor that is of equal or higher degree, and if so, it unmarks itself; else it enters the ruling set and becomes a category-1 node.444Alternately, if $v$ finds any category-2 neighbor (that was missed by checking sampling) during broadcast step it becomes a category-3 node and is done. However, this does not give an asymptotic improvement in the message complexity analysis compared to the stated algorithm. Then node $v$ informs all its neighbors about its category-1 status causing them to become category-2 nodes (if they are not already) and they are done.

A node that does not hear from any of its neighbors knows that it is not a neighbor of any category-1 node. Note that category-2 and category-3 nodes do not initiate messages, which is important for keeping the message complexity low. Another main idea in reducing messages is the random sampling check of a few neighbors to see whether any of them are category-2. Although some nodes might send $O(d(v)$) messages, we show in Section 3.2 that most nodes send (and receive) only $O(\log n)$ messages in an amortized sense. Nodes that remain undecided at the end of one iteration continue to the next iteration. It is easy to implement each iteration in a constant number of rounds.

3.2. Analysis of Algorithm 2-rulingset-msg

One phase of the algorithm consists of Steps 4-4, which can be implemented in a constant number of rounds. We say that a node is decided if it is in category-1, category-2, or category-3. The first lemma, which is easy to establish, shows that if a node is marked, it has a good chance to get decided.

Lemma 3.1**.**

A node that marks itself in any phase gets decided with probability at least $1/2$ in that phase. Furthermore, the probability that a node remains undecided after $2\log n$ marked phases is at most $1/n^{2}$.

Proof 3.2**.**

Consider a marked node $v$. We only consider the probability that $v$ becomes a category-1 node, i.e., part of the independent set. (It can also become decided and become a category-3 or category-2 node .) A marked node becomes unmarked if an equal or higher degree neighbor is marked. The probability of this “bad" event happening is at most

[TABLE]

The probability that a node remains undecided after $2\log n$ marked phases is at most $\frac{1}{2^{2\log n}}\leqslant 1/n^{2}$.

The next lemma bounds the round complexity of the algorithm and establishes its correctness. The round complexity bound is essentially a consequence of the previous lemma and the correctness of the algorithm is easy to check.

Lemma 3.3**.**

The algorithm 2-rulingset-msg runs in $O(\Delta\log n)$ rounds whp. In particular, with probability at least $1-2/n^{2}$, a node $v$ becomes decided after $O(d(v)\log n)$ rounds. When the algorithm terminates, i.e., when all nodes are decided, the category-1-nodes form a $2$-ruling set of the graph. Moreover, each node is correctly classified according to its category.

Proof 3.4**.**

Consider a node $v$ with degree $d(v)$. In $16d(v)\log n$ phases, it marks itself $8\log n$ times in expectation, assuming that it is still undecided. Using a Chernoff bound — lower tail – (cf. Section A), it follows that the node is marked at least $2\log n$ times with probability at least $1-1/n^{2}$. By Lemma 3.1, the probability that $v$ is still undecided if it gets marked $2\log n$ times is at most $1/n^{2}$. Hence, unconditionally, the probability that a node is still undecided after $16d(v)\log n$ phases is at most $2/n^{2}$. Applying a union bound over all nodes, the probability that any node is undecided after $16\Delta\log n$ phases is at most $2/n$. Hence the algorithm finishes in $O(\Delta\log n)$ rounds with high probability.

From the description of the algorithm it is clear that when the algorithm ends, every node has entered into either category-1, category-2, or category-3. By the symmetry breaking step (Step 4), category-1 nodes form an independent set. They also form a ruling set because, category-2 nodes are neighbors of category-1 nodes (Step 4) and a node becomes category-3 if it is not a neighbor of a category-1, but is a neighbor of a category-2 node (and hence is at distance 2 from a category-1 node).

We now show a technical lemma that is crucially used in proving the message complexity bounds of the algorithm in Lemma 3.7. It gives a high probability bound on the total number of messages sent by all nodes during the Broadcast step in any particular phase (i.e., Step 4) of the algorithm in terms of a quantity that depends on the number of undecided nodes and their neighbors. While bounding the expectation is easy, showing concentration is more involved. (We note that we really use only part (b) of the Lemma for our subsequent analysis, but showing part (a) first, helps understand the proof of part (b)).

We call a node’s checking sampling step a “success”, if it results in finding a category-2 node (in this case the node will get decided in Step 4), otherwise, it is called a “failure”.

Lemma 3.5**.**

*Let $U\subseteq V$ be a (sub-)set of undecided nodes at the beginning of a phase. Let $N(v)$ be the set of neighbors of $v$. Then the following statements hold:

(a) Let $Z(U)=U\cup(\cup_{v\in U}N(v))$. The total number of messages sent by all nodes in $U$ during the Broadcast step in this phase (i.e., Step 4) of the algorithm is $O(|Z(U)|\log n)$ with probability at least $1-1/n^{3}$.*

(b)* Let $N^{\prime}(v)$ be the set of undecided and category 3 neighbors of $v$ and suppose $|N^{\prime}(v)|\geqslant d(v)/2$ (where $d(v)$ is the degree of $v$), for each $v\in U$. Let $Z^{\prime}(U)=U\cup(\cup_{v\in U}N^{\prime}(v))$. The total number of messages sent by all nodes in $U$ during the Broadcast step in this phase (i.e., Step 4) of the algorithm is $O(|Z^{\prime}(U)|\log n)$ with probability at least $1-1/n^{3}$. *

Proof 3.6**.**

A node $v$ enters the broadcast step only if it marks itself and if it does not find any category-2 neighbor in its checking sampling step. The marking probability is $1/2d(v)$. Hence (even) ignoring the checking sampling step, the probability that a node broadcasts is at most $1/2d(v)$ (note that in the very first phase, checking sampling will result in failure for all nodes). Let random variable (r.v.) $X_{v}$ denote the number of messages broadcast by node $v$ in this phase. Hence, $E[X_{v}]=\frac{1}{2d(v)}d(v)=1/2$. Let random variable $X$ denote the total number of messages broadcast in this phase: $X=\sum_{v\in U}X_{v}$. By linearity of expectation, the expected number of messages broadcast in one phase is $E[X]=\sum_{v\in U}E[X_{v}]=k/2$, where $k=|U|$. We next show concentration of $X$. We note that $X_{v}$s are all independent and, for the variance of $X_{v}$, we get

[TABLE]

We have $\sum_{v\in U}d(v)\leqslant(|Z(U)|^{2})/2$, since the latter counts all possible edges in the subgraph induced by $U$ and its neighbors. Furthermore, $X_{v}-E[X_{v}]\leqslant d(v)\leqslant|Z(U)|$. Thus, we can apply Bernstein’s inequality (cf. Section A) to obtain

[TABLE]

which is at most $1/n^{2}$, completing part (a).

To show part (b), let $N_{2}(v)$ be the set of category-2 neighbors of a node $v\in U$. Then $N_{2}(v)=N(v)-N^{\prime}(v)$ and

[TABLE]

We will now bound from above the two sums on the right-hand side. Note that $\sum_{v\in U}|N^{\prime}(v)|\leqslant|Z^{\prime}(U)|^{2}/2$ since the latter counts all possible edges in the subgraph induced by $U$ and its category-3 and undecided neighbors. By assumption, $|N_{2}(v)|\leqslant d(v)/2$, which means that

[TABLE]

Hence \text{Var}\mathopen{}\mathclose{{}\left[X}\right]\leqslant(3/4)|Z^{\prime}(U)|^{2}. Let $X_{v}$ and $X$ be defined as above. We have, $X_{v}-E[X_{v}]\leqslant d(v)\leqslant 2|Z^{\prime}(U)|$. Now, applying Bernstein’s inequality shows a similar concentration bound for $X$ as in part (a).

Lemma 3.7**.**

The algorithm 2-rulingset-msg uses $O(n\log^{2}n)$ messages whp.

Proof 3.8**.**

We will argue separately about two kinds of messages that any node can initiate. Consider any node $v$. 1. type 1 messages: In the checking sampling step in some phase, $v$ samples $4\log d(v)$ random neighbours which costs $O(\log d(v))$ messages in that phase.

2.* type 2 messages: In the broadcast step in some phase, $v$ sends to all its neighbors which costs $d(v)$ messages. This happens when all the sampled neighbors in set $A_{v}$ (found in Step 4) are not category-2 nodes.*

Note that $v$ initiates any message at all, i.e., both type 1 and 2 messages happen, only when $v$ marks itself, which happens with probability $1/2d(v)$.

We first bound the type 1 messages sent overall by all nodes. By the above statement, a node does checking sampling when it marks itself which happens with probability $1/2d(v)$. By Lemma 3.1, with probability at least $1-1/n^{2}$, a node is marked (before it gets decided) at most $2\log n$ times. Hence, with probability at least $1-1/n^{2}$, the number of type 1 messages sent by node $v$ is at most $O(\log d(v)\log n)$; this implies, by union bound, that with probability at least $1-1/n$ every node $v$ sends at most $O(\log d(v)\log n)$ type 1 messages. Thus, whp, the total number of type 1 messages sent is $\sum_{v\in V}O(\log d(v)\log n)=O(n\log^{2}n)$.

We next bound the type 2 messages, i.e., messages sent during the broadcast step. There are two cases to consider in any phase.

Case 1

In this case we focus (only) on the broadcast messages of the set $U$ of undecided nodes $v$ that (each) have at least $d(v)/2$ neighbors that are in category-3 or undecided (in that phase). We show by a charging argument that any node receives amortized $O(\log n)$ messages (whp) in this case. When a node $u$ (in this case) broadcasts, its $d(u)$ messages are charged equally to itself and its category-3 and undecided neighbors (which number at least $d(u)/2$).

We first show that any category-3 or undecided node $v$ is charged by amortized $O(\log n)$ messages in any phase. Consider the set $U(v)$ which is the set of undecided nodes (each of which satisfy Case 1 property of having at least half of its neighbors that are in category-3 or undecided in this phase) in the closed neighborhood of $v$ (i.e., $\{v\}\cup N(v)$). As in Lemma 3.5.(b), we define $Z^{\prime}(U(v))=U(v)\cup(\cup_{w\in U(v)}N^{\prime}(w))$, where $N^{\prime}(w)$ is the set of all undecided or category-3 neighbors of $w$. Since, by assumption of Case 1, every undecided node $u\in U(v)$ has at least $d(u)/2$ neighbors that are in category-3 or undecided in the current phase, applying Lemma 3.5 (part (b)) to the set $Z^{\prime}(U(v))$ tells us that, with probability at least $1-1/n^{2}$, the total number of messages broadcast by undecided nodes in $U(v)$ is $O(|Z^{\prime}(U(v))|\log n)$. Hence, amortizing over the total number of (undecided and category-3) nodes in $Z^{\prime}(U(v))$, we have shown each node in $Z^{\prime}(U(v))$, in particular $v$, is charged (amortized) $O(\log n)$ in a phase. Taking a union bound, gives a high probability result for all nodes $v$.

To show that the same node $v$ is not charged too many times across phases, we use the fact that category-2 nodes are never charged (and they do not broadcast). We note that if a node enters the ruling set (i.e., becomes category-1) in some phase, then all its neighbors become category-2 nodes and will never be charged again (in any subsequent phase). Furthermore, since a marked node enters the ruling set with probability at least $1/2$, a neighbor of $v$ (or $v$ itself) gets charged at most $O(\log n)$ times whp. Hence overall a node is charged at most $O(\log^{2}n)$ times whp and by union bound, every node gets charged at most $O(\log^{2}n)$ times whp.

Case 2

In this case, we focus on the messages broadcast by those undecided nodes $v$ that have at most $d(v)/2-1$ neighbors that are in category-3 or undecided, i.e., at least $d(v)/2+1$ neighbors are in category-2. By the description of our algorithm, a node enters the broadcast step, only if checking sampling step (Step 4) fails to find a category-2 node. The probability of this “bad” event happening is at most $\frac{1}{d(v)^{4}}$, which is the probability that a category-2 neighbor (of which there are at least $d(v)/2$ many) is not among any of the $4\log(d(v))$ randomly sampled neighbors. We next bound the total number of broadcast messages generated by all undecided nodes in Case 2 during the entire course of the algorithm. By Lemma 3.1, for any node $v$, Case 2 can potentially happen only $2\log n$ times with probability at least $1-1/n^{2}$, since that is the number of times $v$ can get marked. Let r.v. $Y_{v}$ denote the number of Case 2 broadcast messages sent by $v$ during the course of the algorithm. Conditional on the fact that it gets marked at most $2\log n$ times, we have $E[Y_{v}]=2\log n\frac{1}{d(v)^{4}}d(v)=2\log n\frac{1}{d(v)^{3}}$.

Let $Y=\sum_{v\in V}Y_{v}$. Hence, conditional on the fact that each node gets marked at most $2\log n$ times (which happens with probability $\geqslant 1-1/n$) the total expected number of Case 2 broadcast messages sent by all nodes is $E[Y]=\sum_{v\in V}E[Y_{v}]=\sum_{v\in V}2\log n\frac{1}{d(v)^{3}}=O(n\log n).$

We next show concentration of $Y$ (conditionally as mentioned above). We know that \text{Var}\mathopen{}\mathclose{{}\left[Y_{v}}\right]=4\log^{2}n(\frac{1}{d(v)^{2}}-\frac{1}{d(v)^{6}})\leqslant 4\log^{2}n. Since the random variables $Y_{v}$ are independent, we have \text{Var}\mathopen{}\mathclose{{}\left[Y}\right]=\sum_{v\in V}Var(Y_{v})=4n\log^{2}n. Noting that $Y_{v}-E[Y_{v}]\leqslant 2n\log n$, we apply Bernstein’s inequality to obtain

[TABLE]

Since the conditioning with respect to the fact that all nodes get marked at most $2\log n$ times happens with probability at least $1-1/n$, unconditionally, $\Pr(Y\geqslant\Theta(n\log^{2}n))\leqslant O(1/n^{2})+1/n$. Hence, the overall broadcast messages sent by nodes in Case 2 is bounded by $O(n\log^{2}n)$ whp.

*Combining type 1 and type 2 messages, the overall number of messages is bounded by $O(n\log^{2}n)$ whp. *

Thus we obtain the following theorem.

Theorem 3.9**.**

The algorithm 2-rulingset-msg computes a 2-ruling set using $O(n\log^{2}n)$ messages and terminates in $O(\Delta\log n)$ rounds with high probability.

A tight example

We show that the above analysis of the Algorithm 2-rulingset-msg is tight up to a polylogarithmic factor. The tightness of the message complexity follows from Theorem 4.1 which shows that any $O(1)$-ruling set algorithm needs $\Omega(n)$ messages.

For the time complexity, we show that the analysis is essentially tight by giving a $n$-node graph where the algorithm takes $\Omega(n^{1-\epsilon})$ rounds in a graph where $\Delta=O(n)$, for any fixed constant $\epsilon>0$. The graph is constructed as follows. The graph consists of a distinguished node $s$ and three sets of nodes — sets $A,B,$ and $C$. $A$ has $n^{1-\epsilon}$ nodes, $B$ has $n^{1-\epsilon^{\prime}}$ nodes, where $\epsilon>\epsilon^{\prime}>0$ and $C$ has $n-1-n^{1-\epsilon}-n^{1-\epsilon^{\prime}}$ nodes. There is a complete bipartite graph between sets $A$ and $B$ and between sets $B$ and $C$ and $s$ is connected to all nodes in $A$. Hence $s$ has degree $n^{1-\epsilon}$, every node in $A$ has degree $\Theta(n^{1-\epsilon^{\prime}})$, every node in $B$ has degree $\Theta(n)$ and every node in $C$ has degree $\Theta(n^{1-\epsilon^{\prime}})$. If we run the algorithm 2-rulingset-msg on this graph, then with high probability at least one node in $C$ will enter the ruling set in the first phase itself; further, with probability at least $1-o(1)$, neither $s$ nor any node in sets $A$ and $B$ mark themselves in the first phase. Once a node from $C$ enters the ruling set, all nodes in $B$ become category-2 nodes. On the other hand, nodes in sets $A$ and $C$ (conditioned on not entering the ruling set in the current phase) will become category-3 nodes in the next phase by executing the checking sampling step (which will succeed with high probability). However, since all of the neighbors of $s$ are in category-3, node $s$ is bound to execute $\Theta(n^{1-\epsilon})$ phases until it marks itself and enter the ruling set in expectation. Hence the expected round complexity is $\Omega(n^{1-\epsilon})$. Note that even though this graph has $\Theta(n^{2-\epsilon^{\prime}})$ edges, the algorithm sends only $O(n\log^{2}n)$ messages (whp).

3.3. An $O(\log n)$-round, $O(n^{1.5}\log n)$ message complexity 2-ruling set algorithm

We show that when $m$ is large, one can design a simple algorithm with $o(m)$ message complexity algorithm that runs in time $O(\log n)$. This algorithm requires knowledge of $n$. The algorithm is as follows.

1. (1)

Initially all nodes are inactive. 2. (2)

Every node with degree less than $\sqrt{n}$ becomes active and nodes with degree higher than $\sqrt{n}$ become active independently with probability $2\log n/\sqrt{n}$. Let $S$ denote the set of active nodes. 3. (3)

Nodes in $S$ broadcast their status to all nodes (thus each active node knows its active neighbors, if any). 4. (4)

Compute, using Luby’s algorithm, an MIS of $S$ and return it.

Theorem 3.10**.**

The above algorithm computes a 2-ruling set using $O(n^{1.5}\log n)$ messages and $O(\log n)$ rounds.

Proof 3.11**.**

We show that the set returned, i.e., the MIS of $S$, is a 2-ruling set. Every node in $S$ (the active set) is either in the MIS or a neighbor of a node in the MIS. We next show that every node in $v\in V-S$ has a neighbor in $S$. If $v$ has a neighbor $u$ of degree less than $\sqrt{n}$, then $u$ belongs to $S$. Otherwise, since $v$’s degree is at least $\sqrt{n}$, the probability that at least one of its neighbors (all of which must have a degree at least $\sqrt{n}$) belonging to $S$ is at least $1-(1-2\log n/\sqrt{n})^{\sqrt{n}}\geqslant 1-e^{-2\log n}=1-1/n^{2}$. Hence, by a union bound, every node in $V-S$ has a neighbor in $S$ whp. It follows that an MIS of $S$ is a 2-ruling set of the graph.

We next analyze the time and message complexity. The time complexity follows immediately from the run time of Luby’s algorithm. We can show that, whp, the number of messages in Step (3) is $O(n^{1.5}\log n)$ as follows. Nodes with degree less than $\sqrt{n}$ contribute $O(n^{1.5})$ messages. For nodes that have a degree higher than $\sqrt{n}$, the expected number of neighbors in $S$ is $O(\sqrt{n}\log n)$ and this holds whp (by applying a standard Chernoff bound). Hence the number of messages is $O(n^{1.5}\log n)$ whp. From the above, it follows that the sum of the degrees of the nodes in $S$ is bounded by $O(n^{1.5}\log n)$. Hence, we observe that Step (4) — Luby’s algorithm on $S$ — requires $O(n^{1.5})$ messages. Hence, overall the total message complexity is $O(n^{1.5}\log n)$.

4. Message Complexity Lower Bounds

We first point out that the bound of Theorem 3.9 is tight up to logarithmic factors.

Theorem 4.1**.**

Any $O(1)$-ruling set algorithm that succeeds with probability $1-o(1)$ sends $\Omega(n)$ messages in the worst case. This is true even if nodes have prior knowledge of the network size $n$.

Proof 4.2**.**

Consider a cycle $G$ of $n$ nodes and, for any $t=O(1)$, suppose that $\mathcal{A}$ is a $t$-ruling set algorithm that has a message complexity of $o(n)$.

We first condition on the assumption that nodes do not have IDs and subsequently remove this restriction. By assumption, there are $\geqslant(1-\frac{1}{2t+1})n$ nodes in any run of $\mathcal{A}$ that are quiescent, i.e., neither send nor receive any messages. We define a segment to be a sequence of consecutive nodes in the cycle. Let $E_{u}$ be the indicator random variable that is $1$ if and only if node $u$ enters the ruling set. It follows that there exists a segment $S$ of $2t+1$ quiescent nodes and we can observe that the random variables in the set $\{E_{v}\mid v\in S\}$ are independent.

Consider a sub-segment of $3$ nodes in $S$. Since the network is anonymous, we know that \text{Pr}\mathopen{}\mathclose{{}\left[E_{u}\!=\!1}\right]=\text{Pr}\mathopen{}\mathclose{{}\left[E_{v}\!=\!1}\right]=p, for any $u,v\in S$. Recalling that $\mathcal{A}$ succeeds with probability $1-o(1)$ tells us that the event where two neighbors join the ruling set happens with probability at most $2p^{2}(1-p)=o(1)$ and hence it must be that $p=o(1)$. On the other hand, since $S$ has length $2t+1$, at least $1$ node must enter the ruling set with probability $\geqslant 1-o(1)$ and conversely $(1-p)^{2t+1}=o(1)$, which contradicts $t=O(1)$ and $p=o(1)$.

Finally, suppose that an algorithm $\mathcal{B}$ computes a $t$-ruling set correctly with probability $1-o(1)$ requiring $o(n)$ messages in networks where nodes have unique IDs. Similarly to [25], we construct an algorithm $\mathcal{A}$ that works in anonymous networks by instructing every node to first uniformly at random choose a unique ID from $[1,n^{c}]$, where $c\geqslant 4$ is any constant, and then run algorithm $\mathcal{B}$ with the random ID as input. With high probability, all randomly chosen IDs are unique and hence $\mathcal{A}$ also succeeds with probability $1-o(1)$, contradicting the lower bound above.

Next, we show a clear separation between the message complexity of computing an $t$-ruling set ($t>1$) and a maximal independent set (i.e., 1-ruling set) by proving an unconditional $\Omega(n^{2})$ lower bound for the latter.

Theorem 4.3**.**

Any maximal independent set algorithm that succeeds with probability $1-\epsilon$ on connected networks, where $0\leqslant\epsilon<\tfrac{1}{2}$ is a constant, must send $\Omega(n^{2})$ messages in the worst case. This is true even if nodes have prior knowledge of the network size $n$.

Proof of Theorem 4.3. For the sake of a contradiction, assume that there is an algorithm $\mathcal{A}$ that sends at most $\mu=o(n^{2})$ messages in the worst case and succeeds with probability $\geqslant 1-\epsilon$, for some $\epsilon<\tfrac{1}{2}$.

Consider two copies $G$ and $G^{\prime}$ of the complete bipartite graph on $n/2$ nodes.555To simplify our analysis, we assume that $n/2$ and $n/4$ are integers. For now, we consider the anonymous case where nodes do not have access to unique IDs; we will later show how to remove this restriction. Recall that in our model (cf. Section 1.1), we assume that nodes do no have any prior knowledge of their neighbors in the graph. Instead, each node $u$ has a list ports $1,\dots,deg_{u}$, whose destination are wired in advance by an adversary.

We consider two concrete instances of our lower bound network depending on the wiring of the edges. First, let $D=(G,G^{\prime})$ be the disconnected graph consisting of $G$ and $G^{\prime}$ and their induced edge sets. It is easy to see that there are exactly $4$ possible choices for an MIS on $D$, as any valid MIS must contain the entire left (resp. right) half of the nodes in $G$ and $G^{\prime}$ and no other nodes. We denote the events of obtaining one of the four possible MISs by $LL^{\prime}$, $LR^{\prime}$, $RL^{\prime}$, $RR^{\prime}$, where, e.g., $RL^{\prime}$ is the event that the right half of $G$ (i.e. nodes in $R$) and the left half of $G^{\prime}$ (i.e. nodes in $L^{\prime}$) are chosen. Let “on $D$” be the event that $\mathcal{A}$ is executed on graph $D$. Of course, we cannot assume that algorithm $\mathcal{A}$ does anything useful on this graph as we require $\mathcal{A}$ only to succeed on connected networks. However, we will make use of the symmetry of the components of $D$ later on in the proof.

Observation 1**.**

\text{Pr}\mathopen{}\mathclose{{}\left[LL^{\prime}\mid\text{on D}}\right]=\text{Pr}\mathopen{}\mathclose{{}\left[LR^{\prime}\mid\text{on D}}\right]=\text{Pr}\mathopen{}\mathclose{{}\left[RL^{\prime}\mid\text{on D}}\right]=\text{Pr}\mathopen{}\mathclose{{}\left[RR^{\prime}\mid\text{on D}}\right].

We now define the second instance of our lower bound graph. Consider any pair of edges $e=(u,v)\in G=(L,R)$ and $e^{\prime}=(u^{\prime},v^{\prime})\in G^{\prime}=(L^{\prime},R^{\prime})$. We define the bridge graph by removing $e$ and $e^{\prime}$ from $G$ respectively $G^{\prime}$ and, instead, adding the bridge edges $b=(u,u^{\prime})$ and $b^{\prime}=(v,v^{\prime})$ by connecting the same ports that were used for $e$ and $e^{\prime}$; see Figure 1. We use $B$ to denote a graph that is chosen uniformly at random from all possible bridge graphs, i.e., the edges replaced by bridge edges are chosen uniformly at random according to the above construction. Let “$G\leftrightarrow G^{\prime}$” be the event that $\mathcal{A}$ sends at least $1$ message over a bridge edge and, similarly, we use “$G\not\leftrightarrow G^{\prime}$” to denote the event that this does not happen.

Lemma 4.4**.**

Consider an execution of algorithm $\mathcal{A}$ on a uniformly at random chosen bridge graph $B$. The probability that a message is sent across a bridge is $o(1)$, i.e., \text{Pr}\mathopen{}\mathclose{{}\left[\text{G\not\leftrightarrow G^{\prime}}}\right]=1-o(1).

Proof 4.5**.**

We start out by observing that nodes do not have any prior knowledge regarding the choice of the bridge edges when $\mathcal{A}$ is executed on graph $B$. Moreover, as long as no message was sent across a bridge edge, every unused port (i.e., over which the algorithm has not sent a message yet) has the same probability of being connected to a bridge edge. It follows that discovering a bridge edge corresponds to sampling without replacement, which we can model using the hypergeometric distribution, where we have exactly $4$ bridge ports among the edge set of $B$ and one draw per message sent by the algorithm. Observe that the total number of ports is 2|E(B)|=4\mathopen{}\mathclose{{}\left(\tfrac{n}{4}}\right)^{2}=\tfrac{n^{2}}{4}. Hence, by the properties of the hypergeometric distribution, the expected number of bridge edges discovered when the algorithm sends at most $\mu$ messages is $\Theta(\frac{\mu}{n^{2}})$. Using Markov’s Inequality and the fact that $\mu=o(n^{2})$, it follows that the probability of discovering at least $1$ bridge edge is $o(1)$.

A crucial property of our construction is that, as long as no bridge edge is discovered, the algorithm behaves the same on $B$ as it does on $D$. The following lemma can be shown by induction over the number of rounds.

Lemma 4.6**.**

Let $Y$ be any event that is a function of the communication and computation performed by algorithm $\mathcal{A}$. Then, \text{Pr}\mathopen{}\mathclose{{}\left[Y\mid\text{G\not\leftrightarrow G^{\prime}}}\right]=\text{Pr}\mathopen{}\mathclose{{}\left[Y\mid\text{on D}}\right].

We are now ready to prove Theorem 4.3. Consider a run of algorithm $\mathcal{A}$ on a uniformly at random chosen bridge graph $B$. Let “$\mathcal{A}$ succ.” denote the event that $\mathcal{A}$ correctly outputs an MIS. Observe that $\mathcal{A}$ succeeds when executed on $B$ if and only if we arrive at an output configuration corresponding $LR^{\prime}$ or $RL^{\prime}$. It follows that

[TABLE]

Lemma 4.4 tells us that \text{Pr}\mathopen{}\mathclose{{}\left[\text{G\leftrightarrow G^{\prime}}}\right]=o(1) and, using \text{Pr}\mathopen{}\mathclose{{}\left[\text{G\not\leftrightarrow G^{\prime}}}\right]\leqslant 1, allows us to rewrite the above inequality as

[TABLE]

Applying Lemma 4.6 to the terms in the sum, we get

[TABLE]

By Observation 1, we know that

[TABLE]

which we can plug into (2) to obtain $\epsilon\geqslant\tfrac{1}{2}-o(1)$, yielding a contradiction.

Finally, we can remove the restriction of not having unique IDs by arguing that the algorithm can generate unique IDs with high probability, since we assume that nodes know $n$; see the proof of Theorem 4.1 for a similar argument. This completes the proof of Theorem 4.3.

5. Conclusion

We studied symmetry breaking problems in the Congest model and presented time- and message-efficient algorithms for ruling sets. Several key open questions remain. First, can the MIS lower bounds in the Local model shown by Kuhn et al. [23] be extended to 2-ruling sets? In an orthogonal direction, can we derive time lower bounds for MIS in the Congest model, that are stronger than their Local-model counterparts? And on the algorithms side, can we build on the techniques presented here to improve the time bounds in the Congest model? For example, can we solve the 2-ruling set problem in $O(\log^{\alpha}n)$ rounds for some constant $\alpha<1$.

Second, although we have presented near-tight message bounds for 2-ruling sets, we don’t have a good understanding of the message-time tradeoffs. In particular, a key question is whether we can design a 2-ruling set algorithm that uses $O(n\operatorname{polylog}n)$ messages, while running in $O(\operatorname{polylog}n)$ rounds? Such an algorithm will also lead to better algorithms for other distributed computing models such as the $k$-machine model [21]. More generally, can we obtain tradeoff relationships that characterizes the dependence of one measure on the other or obtain lower bounds on the complexity of one measure while fixing the other measure.

Appendix A Concentration Bounds

Theorem A.1** (Chernoff Bound [30]).**

Let the random variables $X_{1},X_{2},\ldots,X_{n}$ be independently distributed in $[0,1]$ and let $X=\sum_{i}X_{i}$. Then, for $0<\varepsilon<1$,

[TABLE]

Theorem A.2** (Bernstein’s Inequality [11]).**

Let the random variables $X_{1},X_{2},\ldots,X_{n}$ be independent with $X_{i}-E[X_{i}]\leqslant b$ for each $i$, $1\leqslant i\leqslant n$. Let $X:=\sum_{i}X_{i}$ and let $\sigma^{2}:=\sum_{i}\sigma_{i}^{2}$ be the variance of $X$. Then for any $t>0$,

[TABLE]