Can We Break Symmetry with Communication?
Abstract.
We study the communication cost (or message complexity) of fundamental distributed symmetry breaking problems, namely, coloring and MIS. While significant progress has been made in understanding and improving the running time of such problems, much less is known about the message complexity of these problems. In fact, all known algorithms need at least communication for these problems, where is the number of edges in the graph. We address the following question in this paper: can we solve problems such as coloring and MIS using sublinear, i.e., communication, and if so under what conditions?
In a classical result, Awerbuch, Goldreich, Peleg, and Vainish [JACM 1990] showed that fundamental global problems such as broadcast and spanning tree construction require at least messages in the KT- Congest model (i.e., Congest model in which nodes have initial knowledge of the neighbors’ ID’s) when algorithms are restricted to be comparison-based (i.e., algorithms in which node ID’s can only be compared). Thirty five years after this result, King, Kutten, and Thorup [PODC 2015] showed that one can solve the above problems using messages ( is the number of nodes in the graph) in rounds in the KT- Congest model if non-comparison-based algorithms are permitted. An important implication of this result is that one can use the synchronous nature of the KT- Congest model, using silence to convey information, and solve any graph problem using non-comparison-based algorithms with messages, but this takes an exponential number of rounds. In the asynchronous model, even this is not possible.
In contrast, much less is known about the message complexity of local symmetry breaking problems such as coloring and MIS. Our paper fills this gap by presenting the following results.
- Lower bounds::
-
In the KT- CONGEST model, we show that any comparison-based algorithm, even a randomized Monte-Carlo algorithm with constant success probability, requires messages in the worst case to solve either -coloring or MIS, regardless of the number of rounds. We also show that is a lower bound on the number of messages for any -coloring or MIS algorithm, even non-comparison-based, and even with nodes having initial knowledge of up to a constant radius.
- Upper bounds::
-
In the KT- CONGEST model, we present the following randomized non-comparison-based algorithms for coloring that, with high probability, use messages and run in polynomially many rounds.
- (a):
-
A -coloring algorithm that uses messages, while running in rounds, where is the graph diameter. Our result also implies an asynchronous algorithm for -coloring with the same message bound but running in rounds.
- (b):
-
For any constant , a -coloring algorithm that uses messages, while running in rounds.
If we increase our input knowledge slightly to radius 2, i.e., in the KT- CONGEST model, we obtain:
- (c):
-
A randomized comparison-based MIS algorithm that uses messages. while running in rounds.
While our lower bound results can be viewed as counterparts to the classical result of Awerbuch, Goldreich, Peleg, and Vainish [JACM 90], but for local problems, our algorithms are the first-known algorithms for coloring and MIS that take messages and run in polynomially many rounds.
1. Introduction
There has been significant interest over the last decade in obtaining communication-efficient algorithms for fundamental problems in distributed computing. In the Congest model, which is a message-passing model with small-sized messages (typically -sized, where is the number of nodes in the network), communication cost is usually measured by the number of messages. In the so-called clean network model, a.k.a. the KT- (Knowledge Till radius 0) model, where nodes have intial knowledge of only themselves and don’t even know the ID’s of neighbors, Kutten et al. (Kutten et al., 2015) showed that ( is the number of edges in the network) is a lower bound for the message complexity for fundamental global problems such as leader election, broadcast, spanning tree, and mimimum spanning tree (MST) construction. This lower bound applies even for randomized Monte Carlo algorithms. For all these problems, there exist algorithms that (essentially) match this message lower bound; in fact, these also have optimal time complexity (of , the network diameter) in the Congest model (see e.g., (Kutten et al., 2015; Pandurangan et al., 2017; Elkin, 2020)).
The clean network model does not capture many real world networks such as the Internet and peer-to-peer networks where nodes typically have knowledge of identities (i.e., IP addresses) of other nodes. Also, there has been a lot of recent interest in “all-to-all” communication models such as the congested clique (Lotker et al., 2005), Massively Parallel Computing (MPC) (Karloff et al., 2010), and -machine model (Klauck et al., 2015), where each machine is assumed to have knowledge of ID’s of all other machines. Motivated by these applications and models, there has been a lot of recent interest in studying message-efficient algorithms under the so-called KT- version of the Congest model, where nodes have initial knowledge of the IDs of their neighbors, but no other knowledge of their neighbors. An immediate question that arises is whether the message lower bound also holds in the KT- model; or whether sublinear, i.e., message complexity is possible.
The above question was partially answered in a seminal paper by Awerbuch et al. (Awerbuch et al., 1988) who initiated the study of trade-offs between the message complexity and initial knowledge of distributed algorithms that solve global problems, such as broadcast and spanning tree construction. For any integer , in the KT- version of the Congest model (in short, KT- Congest), each node is provided initial knowledge of (i) the IDs of all nodes at distance at most from and (ii) the neighborhood of every node at distance at most from . The bounds in this paper (Awerbuch et al., 1988) are for comparison-based algorithms, i.e., algorithms in which local computations on IDs are restricted to comparisons only. This means that operations on IDs such as those used in the Cole-Vishkin coloring algorithm (Cole and Vishkin, 1986) or applying random hash functions to IDs are disallowed. Comparison-based algorithms are quite natural and indeed, most distributed algorithms (with few notable exceptions such as Cole-Vishkin (Cole and Vishkin, 1986) and hash-functions based algorithms of King et al (King et al., 2015)) are comparison-based. For the KT- Congest model the authors show that messages are needed for any comparison-based algorithm (even randomized) that solves broadcast. Furthermore, in the KT- Congest model, messages are needed for any comparison-based algorithm that solves broadcast. The paper also shows matching upper bounds for comparison-based algorithms for broadcast. These lower bounds also hold for non-comparison based algorithms, where the size of the IDs is very large and grows independently with respect to message size, time, and randomness. This paper left open the possibility of circumventing the lower bound if one uses non-comparison based algorithms on more natural ID spaces typically used in distributed algorithms (as assumed in the current paper), where IDs are drawn from a polynomial-sized ID space.
Nearly 35 years later, the above question was settled by King et al. (King et al., 2015) who showed that the Awerbuch et al. lower bounds “break” if the assumption that the algorithms be comparison-based is dropped and one uses ID space that is of polynomial size.111This can be relaxed to allow even exponential-sized ID space: by using fingerprinting technique (Karp and Rabin, 1987; King et al., 2015), with high probability, one can map IDs in exponential ID space to distinct IDs in polynomial ID space. Specifically, it is shown in (King et al., 2015) that the Spanning Tree (and hence broadcast) and Minimum Spanning Tree (MST) problem can be solved using messages in KT- Congest model.222We use as short for and as short for . In followup papers, it is shown that these problems can be solved with messages, but with a higher message bound of , even in the asynchronous Congest KT- model (Mashreghi and King, 2018, 2019). Using the King et al. (King et al., 2015) result, it is possible to solve any graph problem (including symmetry breaking problems) using randomized non-comparison based algorithms in messages. However, this takes an exponential number of rounds. This is done by building a spanning tree using the algorithm of King et al. and then using time-encoding to convey the entire topology to the root of the spanning tree. The root then locally computes the result and disseminates it to the entire network, again using time-encoding (e.g., see (Robinson, 2021) for details). Time-encoding uses silence to convey information and takes at least exponential (in ) rounds. Note that this works only in synchronous setting and not in the asynchronous model. Hence, designing algorithms that use (or even ) messages for other graph problems, including local symmetry breaking problems, regardless of the number of rounds, in the asynchronous Congest KT- model is open.
Motivated by the above results, we initiate a similar study, but for fundamental local symmetry breaking problems, such as -coloring and Maximal Independent Set (MIS). These problems have been studied extensively for over four decades. Significant progress has been made in understanding and improving the running time (round complexity) of these problems (see e.g., (Barenboim and Elkin, 2013; Chang et al., 2018; Halldórsson et al., 2020; Rozhon and Ghaffari, 2020; Ghaffari, 2016, 2019; Barenboim et al., 2012) and the references therein); however, much less is known with respect to message complexity. For -coloring and MIS, to the best of our knowledge, all known distributed algorithms use at least messages. The overarching question we address in this paper is whether these problems can be solved using messages in the Congest model and if so, under what conditions.
Our paper presents both negative and positive answers for the above question and shows results in three general directions. First, we show that even though the round complexity of local symmetry breaking problems is provably much smaller than the round complexity of global problems, comparison-based algorithms for local symmetry breaking problems require as many messages as they do for global problems in the KT- Congest model. Second, we show that if we drop the requirement that our algorithms be comparison-based only, then it is possible to design algorithms for local symmetry breaking problems in the KT- Congest model that use far fewer messages. Third, as we increase , the radius of initial knowledge, to just two, i.e., in the KT- Congest model, it is possible to design algorithms for local symmetry breaking problems that use even fewer messages. The specific results that illustrate these three directions are presented in the next subsection.
1.1. Main Results
-coloring | MIS | |
---|---|---|
KT- | Lower Bound (C): | Lower Bound (C): |
Upper Bound (NC): | Upper Bound (C): | |
KT- | Lower Bound (NC): | Lower Bound (NC): |
Upper Bound (C): | ||
KT- | Lower Bound (NC): | Lower Bound (NC): |
We present new lower and upper bounds on the message complexity for two fundamental symmetry breaking problems, namely, coloring and MIS. See Figure 1 for a summary.
- Lower bounds::
-
In the KT- Congest model, we show that any comparison-based algorithm, even a randomized Monte Carlo algorithm with constant success probability, requires messages in the worst case to solve either -coloring or MIS, regardless of the number of rounds. Our result can be considered as a counterpart to the classical result of Awerbuch et al. (Awerbuch et al., 1988), but for local problems. We also show that in the KT- Congest model, for any constant , -coloring and MIS require messages even for non-comparison-based and Monte Carlo randomized algorithms with constant success probability.
- Upper bounds::
-
In the KT- Congest model, we present the following randomized non-comparison-based algorithms for coloring that with high probability333This refers to probability at least for constant . (w.h.p.) use messages and run in polynomially many rounds.
- (a):
-
A -coloring algorithm that uses messages, while running in rounds, where is the graph diameter. Our result also implies an asynchronous algorithm for -coloring with the same message bound but running in rounds.
- (b):
-
A -coloring algorithm that uses messages, while running in rounds.
If we increase our input knowledge slightly, i.e., we work in the KT- Congest model, where nodes have initial knowledge of their two hop-neighborhood, then we get the following additional and stronger result.
- (c):
-
A comparison-based algorithm for MIS that uses messages, while running in rounds.
Our algorithms for coloring and MIS are the first-known algorithms that take messages and running in polynomial number of rounds.
1.2. Other Related Work
Several recent papers (see e.g., (Gmyr and Pandurangan, 2018; Ghaffari and Kuhn, 2018; Mashreghi and King, 2018, 2019) have studied message-efficient algorithms for global problems, namely, construction of spanning tree, minimum spanning tree, broadcasting and leader election, in the KT- Congest model inspired by the work of King et al. (King et al., 2015). We note that all these are non-comparison-based algorithms. We use these prior algorithms for our non-comparison-based algorithms in the KT- and KT- models. In a recent paper, Robinson (Robinson, 2021) shows non-trivial lower bounds on the message complexity of constructing graph spanners in the Congest KT- model.
In contrast to global problems, much less is known about obtaining sublinear, i.e., algorithms for local problems, such as MIS and coloring. Pai et al. (Pai et al., 2017) showed that MIS has a fundamental lower bound of messages in the Congest KT- model (even for randomized algorithms). However, this result does not extend to the KT- model. In contrast, they also showed that the 2-ruling set problem (note that MIS is 1-ruling set) can be solved using messages in the KT- model in polynomial time. To the best of our knowledge, we are not aware of other results on the message complexity (in particular, lower bounds and sublinear upper bounds) on fundamental symmetry breaking problems, vis-a-vis the initial input knowledge.
1.3. Technical Contributions
-
•
Lower bounds: To obtain our KT- Congest lower bounds for comparison-based algorithms for -coloring and MIS, we start with the machinery introduced by Awerbuch et al. (Awerbuch et al., 1988) for proving their KT- Congest lower bounds for comparison-based algorithms for broadcast. At the core of their approach is an indistinguishability argument that uses edge crossings. Edge crossings have been used numerous times to prove a variety of distributed computing lower bounds (see (Korach et al., 1987; Kutten et al., 2015; Pai and Pemmaraju, 2020; Pai et al., 2017; Patt-Shamir and Perry, 2017) for some examples). However, in the KT- Congest model, indistinguishability arguments via edge crossing are more challenging because when an edge incident on a node is crossed, the node is exposed to a new ID due to KT-. For symmetry breaking problems, there is a further challenge due to the fact that multiple outputs are possible and the indistinguishability argument needs to work for all outputs. Finally, since we want to show our lower bounds even for Monte Carlo algorithms with constant success probability, we require our indistinguishability arguments to apply to a large fraction of edge crossings (so as to be able to apply Yao’s lemma (Yao, 1977; Motwani and Raghavan, 1995)). The lower bound graph family and ID assignment we design, overcomes all of these challenges. We use a unified construction that works for both -coloring and MIS and we expect this construction to work for other symmetry breaking problems such as maximal matching and edge coloring.
-
•
Upper bounds: Our upper bounds are largely obtained by exploiting the fact that shared (or public) randomness combined with KT- is a powerful way of eliminating the need to communicate over a large number of edges.444Note that we do not a priori assume shared randomness, but only private randomness (as is usual), but use the danner structure (Section 1.4.3) to share privately generated random bits throughput the graph. Specifically, we start with the recent coloring algorithm of Chang et al. (Chang et al., 2019) that works efficiently in the MPC model. Roughly speaking, this algorithm starts with a probabilistic step; by randomly partitioning the nodes and the color palette. Then, after this probabilistic step, a large number of edges become inactive for the rest of algorithm. This property is crucial to ensuring that the algorithm is efficient in the MPC model. After the probabilistic step, nodes exchange their state with neighbors in so that every node can determine which of its incident edges to render inactive. This state exchange is cheap in the MPC model, but is costly with respect to messages in the Congest model. We show how to simulate this coloring algorithm in the Congest model without the costly exchange of state. Instead we use shared randomness with limited dependence combined with KT-.
1.4. Preliminaries
1.4.1. KT- Congest model
We work in the synchronous, message-passing model of distributed computing, known as the Congest model. The input is a graph , , which also serves as the communication network. Nodes in the graph are processors with unique IDs from a space whose size is polynomial in . In each round, each node can send an -bit message to each of its neighbors. Since we are interested in message complexity, the initial knowledge of the nodes is important. For any integer , in the KT- Congest model each node is provided initial knowledge of (i) the IDs of all nodes at distance at most from and (ii) the neighborhood of every vertex at distance at most from .
1.4.2. Comparison-based Algorithms
Often, the outcome of a distributed algorithm does not depend on specific values of node IDs, but may depend on the relative ordering of IDs. For example, node IDs of endpoints may be used to break ties between edges of the same weight vying to join a minimum spanning tree. In this case, only the ordering of the IDs matters, not their specific values. Since this type of behavior is characteristic of many distributed algorithms, Awerbuch et al. (Awerbuch et al., 1988) formally define these as comparison-based algorithms. In comparison-based algorithms, the algorithm executed by each node contains two types of variables: ID-type variables and ordinary variables. In the KT- Congest model, the ID-type variables at a node will store the IDs of all nodes within hops of . Nodes can send ID-type variables in messages, but since messages in the Congest model are restricted to be bits long, each message can contain only a constant number of ID-type variables. The local computations at any node may involve operations of the following two forms only:
-
(1)
Comparing two ID-type variables and storing the result of the comparison in an ordinary variable.
-
(2)
Performing an arbitrary computation on ordinary variables and storing the result in another ordinary variable.
Note that if randomization is allowed, then nodes can choose to ignore the node IDs and choose a new set of (-length) IDs and do arbitrary computations with them. These are still comparison-based algorithms.555However, note that such randomly chosen node IDs are unknown to neighbors and if the algorithm uses only those IDs then this becomes effectively the KT0 model where bounds are already known (Pai et al., 2017; Awerbuch et al., 1988).
1.4.3. Efficient Broadcasting in the KT- Congest model
As explained earlier, shared randomness along with initial knowledge, plays a key role in making our algorithms message-efficient. We use a graph structure called a danner introduced by Gmyr and Pandurangan (Gmyr and Pandurangan, 2018) to share random bits among the nodes in the graph in a message-efficient fashion. Their specific result is stated in the following theorem.
Theorem 1.1 (Gmyr and Pandurangan (Gmyr and Pandurangan, 2018)).
Given an -vertex, -edge, diameter , graph and a parameter , there is a randomized algorithm in the KT-1 Congest model, that constructs a spanning subgraph (i.e., a danner) of such that has edges and diameter with high probability. This construction uses messages and runs in rounds with high probability.
We need the following corollary of this theorem.
Corollary 1.2.
Given an -vertex, -edge, diameter graph and a parameter , there exists a randomized algorithm to solve the leader election and broadcast problems in the synchronous KT-1 Congest model using messages and in rounds with high probability.
We use this corollary to share random bits in a message-efficient manner by first electing a leader and then having the leader locally generate the random bits and broadcasting them. The message and time complexities for this operation are given by the above corollary. We note that the above danner bounds hold in KT- Congest model, which is synchronous. In the asynchronous version of the KT- Congest model, we appeal to the following result.
Theorem 1.3 (Mashregi and King (Mashreghi and King, 2019, 2018)).
Given an -vertex, -edge graph , there exists a randomized algorithm to construct a minimum spanning tree and (hence) solve the leader election and broadcast problems in the asynchronous KT-1 Congest model using messages and in rounds, with high probability.
2. Message Complexity Lower Bounds
2.1. Technical Preliminaries
We now state key definitions and notation from Awerbuch et al. (Awerbuch et al., 1988) which we will use in our proofs of the message lower bounds for -coloring and MIS, for comparison-based algorithms, in the KT- Congest model.
Definition 2.1 (Executions).
We denote the execution of a Congest algorithm (or protocol) on a graph with an ID-assignment by . This execution contains (i) the messages sent and received by the nodes in each round and (ii) a snapshot of the local state of each node in each round. We denote the state of a node in the beginning of round of the execution by .
The decoded representation of an execution is obtained by replacing each occurrence of an ID value by in the execution. This decoded representation allows us to define a similarity of executions. We denote the decoded representations of all messages sent during round of an execution as .
Definition 2.2 (Similar executions).
Two executions of a Congest algorithm on graphs and with ID-assignments and are similar if they have the same decoded representation. Likewise, we say that two messages are similar if their decoded representations are the same.
A crucial element of our lower bound proof consists of taking two graphs and , where is obtained from by “crossing” a pair of edges in , and showing that the executions of any comparison-based algorithm, on and are similar. Showing similarity of executions requires that the “crossing” of edges remains, in a certain sense, hidden from the algorithm. Below, we define what it means for an algorithm to utilize an edge. Later on we will be able to show that if the edges being “crossed” are not utilized by the algorithm, then the edge “crossing” is hidden from the algorithm. One way an algorithm utilizes an edge is by sending a message across it. But, this notion of utilization does not suffice in the KT- model. We need the stronger notion, defined below.
Definition 2.3 (Utilized Edge).
An edge is utilized if any one of the following happens during the course of the algorithm: (i) a message is sent along , (ii) the node sends or receives ID , or (iii) the node sends or receives ID .
By definition, the number of utilized edges is an upper bound on the number of edges along which a message sent. Using a charging argument, Awerbuch et al. (Awerbuch et al., 1988) show that the number of utilized edges is also upper bounded by a constant times the number of edges along which a message sent. We restate their claim here.
Lemma 2.4 (Lemma 3.4 of (Awerbuch et al., 1988)).
Let denote the number of utilized edges in an execution . Then the message complexity of the execution is .
2.2. Lower Bound Graph Construction and ID Assignments
We now describe the construction of lower bound graphs that we use for our message complexity lower bounds. The same construction works for both the -coloring and MIS lower bounds. Recall that these bounds are for comparison-based algorithms in the KT-1 Congest model.
We start with a graph such that and the subgraphs of induced by and are both isomorphic to the complete bipartite graph . Thus, . We then add a copy of and consider the graph . We call this the base graph. Let and . For each , the corresponding copy in is named . Let . Thus . From the base graph , we obtain a crossed graph as follows. For a vertex , cross an edge in , where with the edge in where to obtain the graph . When we cross the edge with , the resulting crossed graph has vertex set and edge set . The base graph and the crossed graph for edges are illustrated in Figure 2.

We now define appropriate ID-assignments for the base graph and the crossed graph. Let be an arbitrary totally ordered set such that , and let be the sorted list of elements in in ascending order. We will assign distinct elements in as ID’s to the base graph and the crossed graph. We use a short-hand and say that the ID of a vertex is , when we mean that the ID of is . Note that since is sorted in ascending order, the relative ordering of the indices is the same as that of the corresponding ID’s in .
Let be an ID assignment such that is even for all and additionally if , if , and if . For a vertex and pair of incident edges and , we define a “shifted” ID assignment for the vertex set of . We motivate this “shifted” assignment and define it precisely further below. But for now, assuming is defined, we define the ID assignment as just the union of and , i.e., for all and for all . Our first goal in this subsection is to show that these two executions
on the base graph and the crossed graph are similar for any comparison-based algorithm .
For the executions and to be similar, it must be the case that the crossing of edges and is hidden from algorithm . To achieve this, the ID assignment of must be carefully chosen. For example, vertex has neighbor in , but has neighbor in (see Figure 2). In the KT-1 model, ’s initial local knowledge consists of vertex in and vertex in . Therefore, for to not distinguish between these two situations, it must be the case that the ID of is “adjacent” to the ID of . To achieve this, without disrupting other constraints on the relative order of ID’s, we start by assigning vertices in the ID’s of their corresponding vertices in and then “shift” these by . As a result, vertex ends up with ID . A similar “shift” is performed to obtain the ID’s of vertex set , though this time the “shift” is by the amount because we want vertex to be “adjacent” to vertex . The “shift” for vertex set just needs to be so that the ID assignment is disjoint, We now define the ID assignment as
(1) |
Note that the IDs of all vertices in each of the parts, , , and , are “shifted” by the same amount, though IDs in different parts may be “shifted” by different amounts.
The following observations about are easy to verify.
-
(i)
The ranges of and are disjoint.
-
(ii)
Moreover, if , if , and if .
-
(iii)
For any , , iff .
Item (iii) is simply saying that the ID ordering on induced by is the same as the ID ordering induced by with respect to the corresponding vertices in . This follows from the fact that the ID’s of vertices in are obtained by shifting the ID’s of vertices in by the same amount, thus preserving the relative ordering of ID’s in and . Similarly, for vertex sets and . Furthermore, even though the ID’s of different sets, , , and are obtained by “shifting” by different amounts, the “shifting” also ensures that ID’s in remain less than ID’s in , which in turn remain less than ID’s in .
To prove that and are similar, we need two intermediate ID assignments for the set . Recall that edge and edge .
-
(i)
Define to be the ID assignment except for interchanging the values of and (i.e. and ).
-
(ii)
Define analogously as except for interchanging the values of and (i.e. and ).
Using these ID assignments, we define two intermediate executions on the base graph .
The following lemma, which shows that , , and are similar, critically uses the fact that the ID assignment shifts the ID’s of vertices in so that the ID of becomes “adjacent” to the ID of and the ID of becomes “adjacent” to the ID of .
Lemma 2.5.
For any , , and edges and , the executions , and are similar.
Proof.
All three executions have the same input graph . The execution pair and have the same ID assignment except for the vertices and , which have their ID’s swapped. Note that by definition of and in (1), we have
Furthermore, . Therefore, when we swap the ID’s of and in to obtain , there is no change in the relative ordering of ID’s and therefore the executions and are similar.
A similar argument holds for the execution pair and . By the definition of and in (1), we have
and . Thus the relative ordering of ID’s in and is the same and therefore the executions and are similar.
The lemma follows because similarity of executions is transitive. ∎
We can derive the final tool we need by directly appealing to a lemma in Awerbuch et al. (Awerbuch et al., 1988). Informally, the lemma shows that if edges and are not utilized in the execution of algorithm , then executions and are similar. The main obstacle is that the initial knowledge vertices is different in and so a direct inductive proof like in Lemma 2.5 does not work. But we can use the intermediate executions of Lemma 2.5 to show the similarity for these four vertices. For all other vertices, we can do a direct inductive argument.
Lemma 2.6 (Restatement of Lemma 3.8 of (Awerbuch et al., 1988)).
Let , , and be arbitrary vertices and let and . Suppose that during the first rounds of the execution both and are not utilized. Then the following hold for every round of the executions , , and :
-
(1)
The states of the nodes in the beginning of the round, i.e. satisfy:
-
(a)
For every processor , .
-
(b)
For , .
-
(c)
For , .
-
(a)
-
(2)
The messages sent during the round are similar, i.e., .
-
(3)
In , no messages are sent during the round over the edges and .
Corollary 2.7.
Suppose that during the execution neither of the edges and are utilized, for some vertices , , and . Then the executions and are similar and furthermore in , no messages are sent through the edges and .
In the next subsections, we will show that this similarity leads to a contradiction with respect to correctness for problems such as -coloring and MIS. This in turn will imply a constraint on the behavior of algorithm : for every pair of edges and , at least one of the edges is utilized by . This in turn will lead to the message complexity lower bound we desire.
2.3. message lower bound for -Coloring in KT- Congest
Now that we have shown that and are similar if and are not utilized by algorithm , we will show that for some problems this leads to a contradiction. The intuition for this is simple. Let and be ID assignments for and respectively, that consistently order the vertices, i.e., iff for all . Since and are isomorphic, it is easy to show that and are similar. This is shown below in Lemma 2.8 below. Now consider the base graph and the ID assignment of . Lemma 2.8 implies that corresponding vertices and have the same local states after execution completes. Since and are similar, this also implies that vertices and have the same local states after execution . But, in the crossed graph , and are neighbors. For problems in which neighboring vertices ought not to have the same local state (e.g., neighboring vertices cannot have the same color in a solution to the vertex coloring problem), this is a contradiction.
Lemma 2.8.
Consider an arbitrary vertex and an arbitrary pair of edges , and , . For any comparison-based algorithm in the KT-1 Congest model, the executions and are similar.
Proof.
Since the input graphs and are copies of each other, the only thing that is different between the two executions is the ID assignments. However, Property (iii) of the ID assignment above implies that every ID comparison by on yields the same result as the corresponding ID comparison on . Therefore, by an inductive argument it can be shown that at the beginning of each round, the state of each vertex in is the same as the state of the corresponding vertex in and the messages received by these vertices are also be the same. This gives us that the executions and are similar. ∎
Lemma 2.9.
Let , , and be three vertices such that the edges and are not utilized in the execution . Then, algorithm computes an incorrect -coloring for the crossed graph .
Proof.
In the execution , since the input graph has two disconnected components and , Lemma 2.8 gives us that the color of a vertex in is the same as the color of the corresponding vertex in . Since the edges and are not utilized in , applying Corollary 2.7, will compute the same coloring in the graph as it will in . This implies a monochromatic edge in which contradicts the correctness of the algorithm. ∎
Theorem 2.10 (Deterministic Lower Bound).
Let be a deterministic comparison-based algorithm that computes a -coloring. Then the message complexity of is . This holds even if the vertices know the size of the network.
Proof.
Suppose that is a deterministic comparison-based algorithm that computes a -coloring and has message complexity . Then by Lemma 2.4, the number of edges utilized by is . This implies that there exists a and edges and such that and are not utilized when executes on . By Lemma 2.9 this implies that computes an incorrect -coloring for . ∎
We now extend this lower bound to Monte Carlo randomized algorithms, even with constant error probability. To do this we strengthen Lemma 2.9 so that it applies not just to a single crossed graph, but to the entire family of crossed graphs. Let denote the family of all crossed graphs, i.e., . Note that because there are choices for and for each choice of , there are choices for and .
Lemma 2.11.
Let be a deterministic comparison-based KT- Congest algorithm that computes a -coloring correctly on at least a constant fraction of graphs in the family . Then the message complexity of is . This holds even if the vertices know the size of the network.
Proof.
Assume for the sake of contradiction that the message complexity of is . By Lemma 2.4, we have that utilizes edges in any graph that it runs on. Specifically consider the execution of algorithm on input graph and ID assignment where denote a graph in the family .
Since utilizes edges, there can only be vertices in such that more than incident edges are utilized, for some constant to be determined later. Recall that . The rest of the vertices in have less than incident edges that are utilized. By Lemma 2.8 the same statement holds for the corresponding vertices in because in , the two graphs and that form the input graph are disconnected, which implies the executions of on and are similar.
So for each such vertex , there are at most edge pairs of the form such that are utilized. Therefore, by Lemma 2.9, the algorithm computes an incorrect -coloring on at least -fraction of the graphs in (since for each there are exactly graphs in ). Setting , the algorithm computes an incorrect -coloring on at least -fraction of the graphs in . This is a contradiction if or . Since is a constant, we get a contradiction. ∎
A simple application of Yao’s lemma (Yao, 1977; Motwani and Raghavan, 1995) with the uniform distribution on all the graphs in the family gives the following theorem.
Theorem 2.12 (Randomized Lower Bound).
Let be a randomized Monte-Carlo comparison based KT- Congest algorithm that computes a -coloring with probability of error less than a constant . Then the worst case message complexity of is . This holds even if the vertices know the size of the network.
2.4. message lower bound for MIS in KT- Congest
Lemma 2.13.
Let , , and be three vertices such that the edges and are not utilized in the execution . Then, algorithm computes an incorrect MIS on .
Proof.
Due to Lemma 2.8, we can only have two MIS’s in which are: or . Since the edges and are not utilized in , applying Corollary 2.7, will compute the same MIS in the graph as it will in . Both the MIS solutions mentioned above violate the independence requirement of MIS in . This contradicts the correctness of the algorithm. ∎
A similar proof as the coloring deterministic lower bound gives us the following theorem.
Theorem 2.14 (Deterministic Lower Bound).
Let be a deterministic comparison-based KT- Congest algorithm that solves the MIS problem. Then the message complexity of is . This holds even if the vertices know the size of the network.
The following lemma for MIS parallels Lemma 2.11 for -coloring. This has a very similar proof, which we skip.
Lemma 2.15.
Let be a deterministic comparison-based KT- Congest algorithm that computes an MIS correctly on at least a constant fraction of graphs in the family . Then the message complexity of is . This holds even if the vertices know the size of the network.
A simple application of Yao’s lemma (Yao, 1977; Motwani and Raghavan, 1995) with the uniform distribution on all the graphs in the family. gives the following theorem.
Theorem 2.16 (Randomized Lower Bound).
Let be a randomized Monte-Carlo comparison-based KT- Congest algorithm that computes an MIS with probability of error less than a constant . Then the worst case message complexity of is . This holds even if the vertices know the size of the network.
2.5. message lower bound in KT- Congest
The lower bounds we have proved apply to comparison-based algorithms in the KT- Congest model. We now prove a weaker message complexity bound for -coloring and MIS, but these apply more generally, to all algorithms (even non-comparison-based) and to the KT- Congest model, for any constant .
Theorem 2.17.
Any randomized Monte Carlo algorithm that computes an MIS or a -vertex coloring with probability at least , requires messages in expectation in the KT- Congest model, for any constant .
Proof.
Similarly to (Naor, 1991; Linial, 1992), we assume without loss of generality that algorithms follow the general framework that all nodes perform their coin flips initially and only exchange their current local state (including coin flips) without performing any other local computation until the very last round.
For the given constant , define the constant to be the smallest integer such that
Consider an -node graph consisting of the disjoint union of cycles each of nodes.666For simplicity, we assume that is an integer. For each cycle , we fix a set of IDs from some integer range of size such that all ID ranges assigned to the cycles are pairwise disjoint. We will equip the nodes of each cycle with unique IDs, as described below.
Consider any randomized algorithm that works on a cycle. We know from (Naor, 1991) that any randomized algorithm that succeeds in computing a -coloring on cycle with probability more than requires at least rounds in the worst case, under the KT- assumption. Now suppose that we execute on our lower bound graph for at most rounds under the KT- assumption. Even though is not guaranteed to work on , it nevertheless exhibits some well-defined behavior on each cycle that we will exploit. Observe that each node in is part of some cycle and hence the color output by is a function of the observed neighborhood and the random coin flips. We point out that, even though that also has knowledge of , it is easy to see that this does not have any impact on the output of the algorithm. As a straightforward consequence of (Naor, 1991), we know that, for each cycle , there exists some hard ID assignment , which is a permutation of the set , such that fails to yield a valid coloring on with some probability greater than (assuming KT-), where this probability is taken over the coin flips of the nodes in .
Returning to the KT- assumption, suppose towards a contradiction that there exists an algorithm that computes a -coloring on while sending messages in expectation. We provide additional power to the algorithm by revealing, to each node , the coin flips of the nodes in its -neighborhood.
We assign the IDs of the nodes in each cycle according to . Since there are cycles but the expected message complexity of is , it holds that, with probability at least , there exists a cycle such that the nodes in do not send any messages at all when executing ; call this event Mute. We now condition on Mute occurring: Consider any node and observe that the output of is a function of its initial knowledge, i.e., its random coin flips and the local state of its -neighborhood. Clearly, the behavior of follows the exact same probability distribution when executing under the KT- assumption as it does when executing algorithm under the KT- assumption. In particular, the result of (Naor, 1991) implies that some neighboring nodes in will output the same color with probability greater than . Since event Mute occurs with probability at least , it follows that algorithm fails with probability , yielding a contradiction. ∎
3. Upper bounds in KT-1 Congest
3.1. -Coloring using Messages in KT-1 Congest
In this section we present a -list-coloring algorithm in the KT-1 Congest model that uses messages. This algorithm is obtained by utilizing – with some modifications – the simple graph partitioning technique introduced recently by Chang et al. (Chang et al., 2019). This technique is central to the fast -coloring algorithms that Chang et al. (Chang et al., 2019) obtain in different models of computation, namely Congested Clique, MPC, and Centralized Local Computation.
The Chang et al. (Chang et al., 2019) graph partitioning scheme is as follows. Let denote the palette of vertex and let .
-
•
Vertex set partition: We partition into as follows. Include each in the set with probability . Then each remaining vertex joins one of uniformly at random.
-
•
Palette partition: Let be the set of all colors. We partition into sets where each color joins one of the sets uniformly at random.
Chang et al. (Chang et al., 2019) then show that whp, the output of the partitioning scheme satisfies the following 4 properties, assuming that . These properties allow us to color each set using palette , in parallel, and then recursively color the set until it becomes small enough to color trivially.
- (i) Size of Each Part::
-
, for each . Also, .
- (ii) Available Colors in ::
-
For each and , let the number of available colors in in the subgraph be . Then , where .
- (iii) Available Colors in ::
-
For each , define . It is required that for each , where . Note that represents a lower bound on the number of available colors in ’s palette after all of have been colored.
- (iv) Remaining Degrees::
-
The maximum degrees of and are and . For each vertex, we have that and also have .
We now present our algorithm, which takes as input an -vertex graph with maximum degree and diameter . The algorithm runs in the KT-1 Congest model and produces a -list-coloring of using messages and running in rounds.
The “full independence” version of the following lemma is proved in (Chang et al., 2019). We provide a brief sketch of the changes required in this proof to make a version with limited independence go through.
Lemma 3.1.
Properties (i)-(iv) mentioned above hold w.h.p., even when the partitioning of vertices and colors is done using -wise independence, as described in Line 2 of Algorithm 1.
Proof.
Chang et al. (Chang et al., 2019) show that this lemma holds when the vertex partitioning is done using full independence, while the color partitioning is done using -wise independence. A closer look at their proof reveals that all four properties are shown using Chernoff bounds, and these bounds can be safely replaced by limited dependence Chernoff bounds described in Lemma A.2. Therefore the four properties hold whp even when the partitioning of both vertices and colors is done using -wise independence. ∎
The following lemma is proved in (Chang et al., 2019) and given that Properties (i)-(iv) hold in the limited independence setting we use, it goes through without any changes.
Lemma 3.2.
The algorithm makes recursive calls w.h.p.
Theorem 3.3.
Given as input an -vertex graph with maximum degree and diameter , Algorithm 1 runs in the KT-1 Congest model and produces a -list-coloring of using messages and running in rounds.
Proof.
In Step 1, we create a danner with the parameter , building the danner takes rounds and messages, see Lemma 1.1. Also, because of danner property, the diameter of the danner is and hence electing a leader and broadcasting a -bit random string takes rounds and messages (Corollary 1.2). Step 2 is just local computation.
In step 3 we use Johansson’s randomized algorithm on each . This algorithm works in rounds and messages whp even when the palette of each vertex has been initialized to an arbitrary subset of colors chosen from (Öjvind Johansson, 1999). According to Property (ii), the palettes of vertices in each are large enough. And according to property (i), So this step runs in rounds and takes messages over all the ’s whp, since there are ’s.
3.1.1. Asynchronous KT-1 Congest algorithm
The -coloring in the Congest KT-1 mode described above (Algorithm 1) has a natural counterpart in the asynchronous version of the Congest KT-1 model. The broadcast of random bits in Step 1 can be done asynchronously using messages and in rounds by appealing to the result of Mashregi and King (Mashreghi and King, 2019, 2018) (see Theorem 1.3). Every node, on receiving the random bits that were broadcast, completes Step 2 via local computation. Due to shared randomness, each node , for each , knows which of its neighbors are in . The coloring algorithm in Step 3 therefore can be executed by nodes in by communicating just over the edges in the induced graph . The synchronous algorithm used in Step 3 in Algorithm 1 can be simulated by using an -synchronizer (Awerbuch, 1985) (see Theorem A.5) in an asynchronous setting. This takes messages since (i) according to Lemma 3.1, contains edges and (ii) Step 3 runs in rounds. Checking if has edges (Step 4) can be done via asynchronous upcast, using messages and in rounds. This is possible because each node , knows which of its neighbors are in and can therefore send the size of its -restricted neighborhood up the spanning tree. Like Step 3, Step 5 can also be executed using messages, in rounds. This description leads to the following theorem.
Theorem 3.4.
Given as input an -vertex graph with maximum degree , there is an algorithm that runs in the asynchronous KT-1 Congest model and produces a -list-coloring of using messages and running in rounds.
3.2. -Coloring using Messages in KT-1 Congest
In this section, we show that for any , there is an algorithm that can compute a -coloring in the KT-1 Congest model in rounds, using messages.
At the beginning of the algorithm, for a large enough constant , one node generates random bits and shares it with all other nodes using a danner (Gmyr and Pandurangan, 2018), using messages and rounds in the KT-1 Congest model (cf. Corollary 1.2). In the following algorithm, each node that has not already permanently colored itself, will use random bit string in Phase to first select a random hash function from a family of -wise independent hash functions . Node will then compute to pick a random color from the palette . Note that the length of is and by Lemma A.4, this number of random bits suffice to pick a -wise independent hash function with domain size and range size . In Corollary 3.6, it is shown that Algorithm 2 runs in phases and therefore random bit strings suffice.
In step 2, we will show that a node has to check only a small subset of its neighbors in any phase.
First, we will show that the probability of success in each phase is large.
Lemma 3.5.
In any phase, a node chooses a color that has not been chosen by any of its neighbors in this phase or in any previous phases with probability at least (for small ). Hence there will be no conflict with the chosen color and hence the node will successfully color itself. Thus, a node successfully colors itself in rounds whp.
Proof.
Fix a node and suppose that it has degree . Arbitrarily label the neighbors of , and let be the indicator variable that indicates if neighbor has picked same color as . Let . Then and . Then, by Markov’s inequality, . Therefore, , (for small ). Since represents the event that no neighbor of chooses the color picked, we get the first part of the lemma.
Thus after rounds for a large enough constant , will successfully color itself whp. ∎
Corollary 3.6.
Whp, all nodes successfully color themselves in rounds.
Proof.
By Lemma 3.5 and union bound over all nodes. ∎
Implementing step 2 with small message complexity:
Lemma 3.7.
In each phase, each node exchanges at most messages whp.
Proof.
In Step 2, a node will check to see if the color chosen by itself is not chosen by any of its neighbors. To check this, it will only check neighbors that could have chosen this color in this round or in any previous rounds. Fix a node and let be the color it samples in this round. Arbitrarily label the neighbors of , and let be the indicator variable that indicates if neighbor has picked same color as in this round. Let . Then and . Since the colors of vertices are chosen using an -wise independent family of hash functions, the variables are -wise independent. Then, by Lemma A.2, for a sufficiently large constant , . Therefore, whp there are at most neighbors of that could have picked color in this round.
This is true of color in previous rounds as well. Node has to check all these neighbors which have chosen in this round or prior rounds to be sure that there is no conflict in choosing . Since there are at most phases whp (by Lemma 3.5), color is chosen by only neighbors whp. ∎
Theorem 3.8.
There is a coloring algorithm that achieves coloring using messages whp in KT1 model (with shared randomness).
Proof.
By Lemma 3.5, all nodes can legally color themselves in rounds whp. By Lemma 2, each node exchanges messages in a phase and there are at most phases. Hence the overall message complexity (of all nodes) is whp. ∎
4. An MIS algorithm using messages in KT- Congest
We now give a high-level overview of Algorithm 3 that uses KT- knowledge to compute an MIS using only messages while taking rounds; the full details are explained in the proof of Theorem 4.1. We first sample a set of nodes and then add these nodes to the independent set according to the randomized greedy MIS algorithm. Since was chosen randomly, this has the same effect as performing iterations of the sequential randomized greedy algorithm, which is known to reduce the maximum degree in the remnant graph to (see (Konrad, 2018)). Then, each node that entered the independent set informs its 2-hop neighbors. It is crucial that node uses its KT- knowledge to convey this information, as otherwise the same 2-hop neighbor might receive ’s message from multiple 1-hop neighbors of , which may result in messages being sent on behalf of . Finally, we compute an MIS on the (sparsified) remnant graph using Luby’s algorithm.
Theorem 4.1.
Algorithm 3 computes a correct MIS. It uses messages and runs in rounds with high probability.
Proof.
In the first two steps, we aim to simulate iterations of the sequential randomized greedy algorithm, see Algorithm 2 in (Blelloch et al., 2012). In the randomized greedy MIS algorithm, each node chooses a random rank at the start of the algorithm and we process the nodes by rank to compute an MIS using the greedy algorithm. Simulating iterations of this algorithm is probabilistically equivalent to sampling vertices uniformly at random and generating random ranks at just tho sampled vertices. Note that since we sample vertices uniformly at random with probability , we get whp.
We instead run the parallel randomized greedy MIS algorithm which computes the same MIS as the sequential version (see (Blelloch et al., 2012)), and in (Fischer and Noever, 2018), they show that the parallel randomized greedy MIS algorithm finishes in rounds whp, and so the message complexity of steps will just be whp.
Using KT-2 information, each vertex in that joins the MIS locally creates a depth BFS tree on its -hop neighborhood and sends the message through this tree. This BFS tree is constructed by having all -hop neighbors of at depth and assigning a node that is exactly -hops away as a child to the -hop neighbor with lowest ID. The local view of this BFS tree can be created at all -hop neighbors of using their own KT-2 information since the common -hop neighbors of and are all -hops away.
To send the message to -hop neighbors, can just broadcast. The one hop neighbors will just inform their neighbors in the BFS tree that has joined the MIS. In case a node gets multiple messages of -hop neighbors in joining the MIS and their BFS trees lead to the same -hop vertex , then will just send all these messages one by one to . The congestion on such an edge can be at most in the worst case. This allows each such node to prune the inactive edges and learn the edges of the remnant graph that are incident on it without sending or receiving any additional messages.
Since whp, and each vertex in that joins the MIS can relay this information to it’s 2-hop neighbors using constant messages per neighbor, this process generates at most messages whp. But due to congestion, this process will take whp in the worst case.
After the simulation, we know from Lemma 1 in (Konrad, 2018) that the remnant graph has maximum degree . And since the nodes know the remnant graph, running Luby’s algorithm (Luby, 1985) will require an additional rounds and messages whp.
Therefore, Algorithm 3 runs in rounds and uses messages throughout its execution whp. The theorem follows. ∎
5. Conclusion
In this paper, we initiate the study of the message complexity of two fundamental symmetry breaking problems, MIS and -coloring. We show that while it is impossible to obtain message complexity in the KT- Congest model using comparison-based algorithms, one can do so by either using non-comparison based algorithms or by slightly increasing the input knowledge, i.e., in the KT- Congest model.
Several key open questions arise from our work. The first is whether one can obtain an -message, non-comparison-based algorithm for MIS in the KT- Congest model, running in polynomial time. We have shown that this is possible for -coloring. The second is whether one can obtain (nearly optimal) -message (non-comparison-based) algorithms for MIS and -coloring in the KT- Congest model, running in polynomial time. The question is open for MIS even in the KT- Congest model. Another important issue is reducing the running time of our algorithms. In particular, can we make them run in rounds, for the same message bounds?
References
- (1)
- Awerbuch (1985) Baruch Awerbuch. 1985. Complexity of Network Synchronization. J. ACM 32, 4 (Oct. 1985), 804–823. https://doi.org/10.1145/4221.4227
- Awerbuch et al. (1988) Baruch Awerbuch, Oded Goldreich, David Peleg, and Ronen Vainish. 1988. A Tradeoff between Information and Communication in Broadcast Protocols. 319 LNCS, 2 (1988), 369–379. https://doi.org/10.1007/BFb0040404
- Barenboim and Elkin (2013) Leonid Barenboim and Michael Elkin. 2013. Distributed Graph Coloring: Fundamentals and Recent Developments. Morgan & Claypool Publishers.
- Barenboim et al. (2012) Leonid Barenboim, Michael Elkin, Seth Pettie, and Johannes Schneider. 2012. The Locality of Distributed Symmetry Breaking. In Proceedings of the 2012 IEEE 53rd Annual Symposium on Foundations of Computer Science (FOCS ’12). IEEE Computer Society, USA, 321–330. https://doi.org/10.1109/FOCS.2012.60
- Blelloch et al. (2012) Guy E. Blelloch, Jeremy T. Fineman, and Julian Shun. 2012. Greedy sequential maximal independent set and matching are parallel on average. In 24th ACM Symposium on Parallelism in Algorithms and Architectures, SPAA ’12, Pittsburgh, PA, USA, June 25-27, 2012. 308–317. https://doi.org/10.1145/2312005.2312058
- Chang et al. (2018) Yi-Jun Chang, Wenzheng Li, and Seth Pettie. 2018. An optimal distributed (+1)-coloring algorithm?. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2018, Los Angeles, CA, USA, June 25-29, 2018. 445–456.
- Chang et al. (2019) Yi-Jun Chang, Manuela Fischer, Mohsen Ghaffari, Jara Uitto, and Yufan Zheng. 2019. The Complexity of Coloring in Congested Clique, Massively Parallel Computation, and Centralized Local Computation. In Proceedings of the 2019 ACM Symposium on Principles of Distributed Computing (PODC ’19). Association for Computing Machinery, New York, NY, USA, 471–480. https://doi.org/10.1145/3293611.3331607
- Cole and Vishkin (1986) R Cole and U Vishkin. 1986. Deterministic Coin Tossing and Accelerating Cascades: Micro and Macro Techniques for Designing Parallel Algorithms. In Proceedings of the Eighteenth Annual ACM Symposium on Theory of Computing (STOC ’86). Association for Computing Machinery, New York, NY, USA, 206–219. https://doi.org/10.1145/12130.12151
- Czumaj et al. (2020) Artur Czumaj, Peter Davies, and Merav Parter. 2020. Simple, Deterministic, Constant-Round Coloring in the Congested Clique. Proceedings of the 39th Symposium on Principles of Distributed Computing (Jul 2020). https://doi.org/10.1145/3382734.3405751
- Elkin (2020) Michael Elkin. 2020. A Simple Deterministic Distributed MST Algorithm with Near-Optimal Time and Message Complexities. J. ACM 67, 2 (2020), 13:1–13:15.
- Fischer and Noever (2018) Manuela Fischer and Andreas Noever. 2018. Tight Analysis of Parallel Randomized Greedy MIS. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2018, New Orleans, LA, USA, January 7-10, 2018. 2152–2160. https://doi.org/10.1137/1.9781611975031.140
- Ghaffari (2016) Mohsen Ghaffari. 2016. An Improved Distributed Algorithm for Maximal Independent Set. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12, 2016. 270–277.
- Ghaffari (2019) Mohsen Ghaffari. 2019. Distributed Maximal Independent Set Using Small Messages. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA ’19). Society for Industrial and Applied Mathematics, USA, 805–820.
- Ghaffari and Kuhn (2018) Mohsen Ghaffari and Fabian Kuhn. 2018. Distributed MST and Broadcast with Fewer Messages, and Faster Gossiping. In 32nd International Symposium on Distributed Computing, DISC 2018, New Orleans, LA, USA, October 15-19, 2018 (LIPIcs), Ulrich Schmid and Josef Widder (Eds.), Vol. 121. 30:1–30:12.
- Gmyr and Pandurangan (2018) Robert Gmyr and Gopal Pandurangan. 2018. Time-Message Trade-Offs in Distributed Algorithms. In 32nd International Symposium on Distributed Computing, DISC 2018, New Orleans, LA, USA, October 15-19, 2018 (LIPIcs), Ulrich Schmid and Josef Widder (Eds.), Vol. 121. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 32:1–32:18. https://doi.org/10.4230/LIPIcs.DISC.2018.32
- Halldórsson et al. (2020) Magnús M. Halldórsson, Fabian Kuhn, Yannic Maus, and Tigran Tonoyan. 2020. Efficient Randomized Distributed Coloring in CONGEST. CoRR abs/2012.14169 (2020). https://arxiv.org/abs/2012.14169
- Karloff et al. (2010) Howard Karloff, Siddharth Suri, and Sergei Vassilvitskii. 2010. A model of computation for mapreduce. In Proceedings of the twenty-first annual ACM-SIAM symposium on Discrete Algorithms. SIAM, 938–948.
- Karp and Rabin (1987) Richard M. Karp and Michael O. Rabin. 1987. Efficient Randomized Pattern-Matching Algorithms. IBM J. Res. Dev. 31, 2 (1987), 249–260.
- King et al. (2015) Valerie King, Shay Kutten, and Mikkel Thorup. 2015. Construction and Impromptu Repair of an MST in a Distributed Network with o(m) Communication. In Proceedings of the 2015 ACM Symposium on Principles of Distributed Computing, PODC 2015, Donostia-San Sebastián, Spain, July 21 - 23, 2015, Chryssis Georgiou and Paul G. Spirakis (Eds.). ACM, 71–80. https://doi.org/10.1145/2767386.2767405
- Klauck et al. (2015) Hartmut Klauck, Danupon Nanongkai, Gopal Pandurangan, and Peter Robinson. 2015. Distributed Computation of Large-Scale Graph Problems. In Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA ’15). Society for Industrial and Applied Mathematics, USA, 391–410.
- Konrad (2018) Christian Konrad. 2018. MIS in the Congested Clique Model in O(log log ) Rounds. CoRR abs/1802.07647 (2018). arXiv:1802.07647 http://arxiv.org/abs/1802.07647
- Korach et al. (1987) E. Korach, S. Moran, and S. Zaks. 1987. The Optimality of Distributive Constructions of Minimum Weight and Degree Restricted Spanning Trees in a Complete Network of Processors. SIAM J. Comput. 16, 2 (April 1987), 231–236. https://doi.org/10.1137/0216019
- Kutten et al. (2015) Shay Kutten, Gopal Pandurangan, David Peleg, Peter Robinson, and Amitabh Trehan. 2015. On the Complexity of Universal Leader Election. J. ACM 62, 1 (2015), 7:1–7:27.
- Linial (1992) Nathan Linial. 1992. Locality in Distributed Graph Algorithms. SIAM J. Comput. 21, 1 (1992), 193–201. https://doi.org/10.1137/0221015
- Lotker et al. (2005) Zvi Lotker, Boaz Patt-Shamir, Elan Pavlov, and David Peleg. 2005. Minimum-Weight Spanning Tree Construction in O(Log Log n) Communication Rounds. SIAM J. Comput. 35, 1 (July 2005), 120–131. https://doi.org/10.1137/S0097539704441848
- Luby (1985) M Luby. 1985. A Simple Parallel Algorithm for the Maximal Independent Set Problem. In Proceedings of the Seventeenth Annual ACM Symposium on Theory of Computing (STOC ’85). Association for Computing Machinery, New York, NY, USA, 1–10. https://doi.org/10.1145/22145.22146
- Mashreghi and King (2018) Ali Mashreghi and Valerie King. 2018. Broadcast and Minimum Spanning Tree with o(m) Messages in the Asynchronous CONGEST Model. In 32nd International Symposium on Distributed Computing, DISC 2018, New Orleans, LA, USA, October 15-19, 2018 (LIPIcs), Vol. 121. 37:1–37:17.
- Mashreghi and King (2019) Ali Mashreghi and Valerie King. 2019. Brief Announcement: Faster Asynchronous MST and Low Diameter Tree Construction with Sublinear Communication. In 33rd International Symposium on Distributed Computing, DISC 2019, October 14-18, 2019, Budapest, Hungary (LIPIcs), Jukka Suomela (Ed.), Vol. 146. 49:1–49:3.
- Motwani and Raghavan (1995) Rajeev Motwani and Prabhakar Raghavan. 1995. Randomized Algorithms. Cambridge University Press, USA.
- Naor (1991) Moni Naor. 1991. A Lower Bound on Probabilistic Algorithms for Distributive Ring Coloring. SIAM J. Discret. Math. 4, 3 (1991), 409–412. https://doi.org/10.1137/0404036
- Pai et al. (2017) Shreyas Pai, Gopal Pandurangan, Sriram V. Pemmaraju, Talal Riaz, and Peter Robinson. 2017. Symmetry Breaking in the Congest Model: Time- and Message-Efficient Algorithms for Ruling Sets. In 31st International Symposium on Distributed Computing, DISC 2017, October 16-20, 2017, Vienna, Austria (LIPIcs), Vol. 91. 38:1–38:16.
- Pai and Pemmaraju (2020) Shreyas Pai and Sriram V. Pemmaraju. 2020. Connectivity Lower Bounds in Broadcast Congested Clique. In 40th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2020) (Leibniz International Proceedings in Informatics (LIPIcs)), Nitin Saxena and Sunil Simon (Eds.), Vol. 182. Schloss Dagstuhl–Leibniz-Zentrum für Informatik, Dagstuhl, Germany, 32:1–32:17. https://doi.org/10.4230/LIPIcs.FSTTCS.2020.32
- Pandurangan et al. (2017) Gopal Pandurangan, Peter Robinson, and Michele Scquizzato. 2017. A time- and message-optimal distributed algorithm for minimum spanning trees. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017. ACM, 743–756.
- Patt-Shamir and Perry (2017) Boaz Patt-Shamir and Mor Perry. 2017. Proof-Labeling Schemes: Broadcast, Unicast and in Between. In Stabilization, Safety, and Security of Distributed Systems - 19th International Symposium, SSS 2017, Boston, MA, USA, November 5-8, 2017, Proceedings (Lecture Notes in Computer Science), Paul G. Spirakis and Philippas Tsigas (Eds.), Vol. 10616. Springer, 1–17. https://doi.org/10.1007/978-3-319-69084-1_1
- Robinson (2021) Peter Robinson. 2021. Being Fast Means Being Chatty: The Local Information Cost of Graph Spanners. In ACM-SIAM Symposium on Discrete Algorithms (SODA).
- Rozhon and Ghaffari (2020) Václav Rozhon and Mohsen Ghaffari. 2020. Polylogarithmic-time deterministic network decomposition and distributed derandomization. In Proccedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2020, Chicago, IL, USA, June 22-26, 2020. 350–363.
- Schmidt et al. (1993) Jeanette P. Schmidt, Alan Siegel, and Aravind Srinivasan. 1993. Chernoff-Hoeffding Bounds for Applications with Limited Independence. Society for Industrial and Applied Mathematics, USA, 331–340.
- Vadhan (2012) Salil P. Vadhan. 2012. Pseudorandomness. Foundations and Trends in Theoretical Computer Science 7, 1–3 (2012), 1–336. https://doi.org/10.1561/0400000010
- Yao (1977) Andrew Chi-Chin Yao. 1977. Probabilistic Computations: Toward a Unified Measure of Complexity. In Proceedings of the 18th Annual Symposium on Foundations of Computer Science (SFCS ’77). IEEE Computer Society, USA, 222–227. https://doi.org/10.1109/SFCS.1977.24
- Öjvind Johansson (1999) Öjvind Johansson. 1999. Simple Distributed -Coloring of Graphs. Information Processing Letters 70 70 (1999), 229–232.
Appendix A Appendix
A.1. Tail inequalities and hash functions with limited independence
To obtain message-efficient algorithms in the KT- model, we make use of hash functions with limited independence. These hash functions use -wise independence and hence we use the following tail inequalities and properties of such hash functions.
The following tail inequalities are from (Schmidt et al., 1993).
Lemma A.1.
Let be an even integer. Suppose are -wise independent random variables taking values in . Let and , and let . Then,
Lemma A.2.
Suppose that is the summation of , -wise independent 0-1 random variables, each with mean . Let satisfy . Then,
The following is Definition 7 in (Czumaj et al., 2020).
Definition A.3.
For , , , such that , a family of functions is -wise independent if for all distinct , the random variables are independent and uniformly distributed in when is chosen uniformly at random from .
The following lemma appears as Corollary 3.34 in (Vadhan, 2012).
Lemma A.4.
For every , there is a family of -wise independent hash functions such that choosing a random function from takes random bits, and evaluating a function from takes computation.
A.2. Simulating synchronous algorithms in an asynchronous model
Theorem A.5 (Awerbuch’s -synchronizer (Awerbuch, 1985)).
Given a synchronous Algorithm running in rounds on a graph with edges in the KT- Congest model for any , it is possible to simulate in the asynchronous KT- Congest model in rounds. The number of additional messages sent in the asynchronous execution compared to an execution of is at most .