This paper was converted on www.awesomepapers.org from LaTeX by an anonymous user.
Want to know more? Visit the Converter page.

Can We Break Symmetry with o(m)o(m) Communication?

Shreyas Pai [email protected] The University of IowaIowa CityIAUSA Gopal Pandurangan [email protected] University of HoustonHoustonTXUSA Sriram V. Pemmaraju [email protected] The University of IowaIowa CityIAUSA  and  Peter Robinson [email protected] City University of Hong KongHong Kong SAR, China
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 Ω(m)\Omega(m) communication for these problems, where mm 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., o(m)o(m) 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 Ω(m)\Omega(m) messages in the KT-11 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 O~(n)\tilde{O}(n) messages (nn is the number of nodes in the graph) in O~(n)\tilde{O}(n) rounds in the KT-11 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-11 Congest model, using silence to convey information, and solve any graph problem using non-comparison-based algorithms with O~(n)\tilde{O}(n) 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-11 CONGEST model, we show that any comparison-based algorithm, even a randomized Monte-Carlo algorithm with constant success probability, requires Ω(n2)\Omega(n^{2}) messages in the worst case to solve either (Δ+1)(\Delta+1)-coloring or MIS, regardless of the number of rounds. We also show that Ω(n)\Omega(n) is a lower bound on the number of messages for any (Δ+1)(\Delta+1)-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-11 CONGEST model, we present the following randomized non-comparison-based algorithms for coloring that, with high probability, use o(m)o(m) messages and run in polynomially many rounds.

(a):

A (Δ+1)(\Delta+1)-coloring algorithm that uses O~(n1.5)\tilde{O}(n^{1.5}) messages, while running in O~(D+n)\tilde{O}(D+\sqrt{n}) rounds, where DD is the graph diameter. Our result also implies an asynchronous algorithm for (Δ+1)(\Delta+1)-coloring with the same message bound but running in O~(n)\tilde{O}(n) rounds.

(b):

For any constant ε>0\varepsilon>0, a (1+ε)Δ(1+\varepsilon)\Delta-coloring algorithm that uses O~(n/ε2)\tilde{O}(n/\varepsilon^{2}) messages, while running in O~(n)\tilde{O}(n) rounds.

If we increase our input knowledge slightly to radius 2, i.e., in the KT-22 CONGEST model, we obtain:

(c):

A randomized comparison-based MIS algorithm that uses O~(n1.5)\tilde{O}(n^{1.5}) messages. while running in O~(n)\tilde{O}(\sqrt{n}) 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 o(m)o(m) messages and run in polynomially many rounds.

copyright: none

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 O(logn)O(\log n)-sized, where nn 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-0 (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 Ω(m)\Omega(m) (mm 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 DD, 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 kk-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-11 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 Ω(m)\Omega(m) message lower bound also holds in the KT-11 model; or whether sublinear, i.e., o(m)o(m) 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 ρ>0\rho>0, in the KT-ρ\rho  version of the Congest model (in short, KT-ρ\rho Congest), each node vv is provided initial knowledge of (i) the IDs of all nodes at distance at most ρ\rho from vv and (ii) the neighborhood of every node at distance at most ρ1\rho-1 from vv. 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-11 Congest model the authors show that Ω(m)\Omega(m) messages are needed for any comparison-based algorithm (even randomized) that solves broadcast. Furthermore, in the KT-ρ\rho Congest model, Ω(min{m,n1+Θ(1)ρ})\Omega\left(\min\left\{m,n^{\frac{1+\Theta(1)}{\rho}}\right\}\right) 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 nn 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 O~(n)\tilde{O}(n) messages in KT-11 Congest model.222We use O~(f(n))\tilde{O}(f(n)) as short for O(f(n)polylogn)O(f(n)\cdot\operatorname{\text{{\rm poly}}}\log n) and Ω~(g(n))\tilde{\Omega}(g(n)) as short for Ω(g(n)/(polylogn))\Omega(g(n)/(\operatorname{\text{{\rm poly}}}\log n)). In followup papers, it is shown that these problems can be solved with o(m)o(m) messages, but with a higher message bound of O~(n1.5)\tilde{O}(n^{1.5}), even in the asynchronous Congest KT-11 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 O~(n)\tilde{O}(n) 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 mm) rounds. Note that this works only in synchronous setting and not in the asynchronous model. Hence, designing algorithms that use O~(n)\tilde{O}(n) (or even o(m)o(m)) messages for other graph problems, including local symmetry breaking problems, regardless of the number of rounds, in the asynchronous Congest KT-11 model is open.

Motivated by the above results, we initiate a similar study, but for fundamental local symmetry breaking problems, such as (Δ+1)(\Delta+1)-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 (Δ+1)(\Delta+1)-coloring and MIS, to the best of our knowledge, all known distributed algorithms use at least Ω(m)\Omega(m) messages. The overarching question we address in this paper is whether these problems can be solved using o(m)o(m) 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-11 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-11 Congest model that use far fewer messages. Third, as we increase ρ\rho, the radius of initial knowledge, to just two, i.e., in the KT-22 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

(Δ+1)(\Delta+1)-coloring MIS
KT-11 Lower Bound (C): Ω(m)\Omega(m) Lower Bound (C): Ω(m)\Omega(m)
Upper Bound (NC): O~(n1.5)\tilde{O}(n^{1.5}) Upper Bound (C): O~(m)\tilde{O}(m)
KT-22 Lower Bound (NC): Ω(n)\Omega(n) Lower Bound (NC): Ω(n)\Omega(n)
Upper Bound (C): O~(n1.5)\tilde{O}(n^{1.5})
KT-ρ\rho Lower Bound (NC): Ω(n)\Omega(n) Lower Bound (NC): Ω(n)\Omega(n)
Figure 1. A summary of lower and upper bounds results in this paper. The notation “(C)” and “(NC)” in each cell stand for comparison-based and non-comparison-based respectively. The KT-11 upper bound of O~(m)\tilde{O}(m) for MIS is not from this paper; it is immediately implied by a number of well-known MIS algorithms (e.g., (Luby, 1985; Ghaffari, 2016)). The KT-ρ\rho lower bounds hold for any constant ρ1\rho\geq 1 and hold even for non-comparison-based algorithms.

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-11 Congest model, we show that any comparison-based algorithm, even a randomized Monte Carlo algorithm with constant success probability, requires Ω(n2)\Omega(n^{2}) messages in the worst case to solve either (Δ+1)(\Delta+1)-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-ρ\rho Congest model, for any constant ρ1\rho\geq 1, (Δ+1)(\Delta+1)-coloring and MIS require Ω(n)\Omega(n) messages even for non-comparison-based and Monte Carlo randomized algorithms with constant success probability.

Upper bounds::

In the KT-11 Congest model, we present the following randomized non-comparison-based algorithms for coloring that with high probability333This refers to probability at least 1nc1-n^{-c} for constant c1c\geq 1. (w.h.p.) use o(m)o(m) messages and run in polynomially many rounds.

(a):

A (Δ+1)(\Delta+1)-coloring algorithm that uses O~(n1.5)\tilde{O}(n^{1.5}) messages, while running in O~(D+n)\tilde{O}(D+\sqrt{n}) rounds, where DD is the graph diameter. Our result also implies an asynchronous algorithm for (Δ+1)(\Delta+1)-coloring with the same message bound but running in O~(n)\tilde{O}(n) rounds.

(b):

A (1+ε)Δ(1+\varepsilon)\Delta-coloring algorithm that uses O~(n/ε2)\tilde{O}(n/\varepsilon^{2}) messages, while running in O~(n)\tilde{O}(n) rounds.

If we increase our input knowledge slightly, i.e., we work in the KT-22 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 O~(n1.5)\tilde{O}(n^{1.5}) messages, while running in O~(n)\tilde{O}(\sqrt{n}) rounds.

Our algorithms for coloring and MIS are the first-known algorithms that take o(m)o(m) 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-11 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-11 and KT-22 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-11 model.

In contrast to global problems, much less is known about obtaining sublinear, i.e., o(m)o(m) 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 Ω(n2)\Omega(n^{2}) messages in the Congest KT-0 model (even for randomized algorithms). However, this result does not extend to the KT-11 model. In contrast, they also showed that the 2-ruling set problem (note that MIS is 1-ruling set) can be solved using O~(n)\tilde{O}(n) messages in the KT-0 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-11 Congest lower bounds for comparison-based algorithms for (Δ+1)(\Delta+1)-coloring and MIS, we start with the machinery introduced by Awerbuch et al. (Awerbuch et al., 1988) for proving their KT-11 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-11 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-11. 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 (Δ+1)(\Delta+1)-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-11 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-11.

1.4. Preliminaries

1.4.1. KT-ρ\rho Congest model

We work in the synchronous, message-passing model of distributed computing, known as the Congest model. The input is a graph G=(V,E)G=(V,E), n=|V|n=|V|, which also serves as the communication network. Nodes in the graph are processors with unique IDs from a space whose size is polynomial in nn. In each round, each node can send an O(logn)O(\log n)-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 ρ>0\rho>0, in the KT-ρ\rho  Congest model each node vv is provided initial knowledge of (i) the IDs of all nodes at distance at most ρ\rho from vv and (ii) the neighborhood of every vertex at distance at most ρ1\rho-1 from vv.

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-ρ\rho Congest model, the ID-type variables at a node vv will store the IDs of all nodes within ρ\rho hops of vv. Nodes can send ID-type variables in messages, but since messages in the Congest model are restricted to be O(logn)O(\log n) 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. (1)

    Comparing two ID-type variables Ii,IjI_{i},I_{j} and storing the result of the comparison in an ordinary variable.

  2. (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 (O(logn)O(\log n)-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-11 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 nn-vertex, mm-edge, diameter DD, graph G=(V,E)G=(V,E) and a parameter δ[0,1]\delta\in[0,1], there is a randomized algorithm in the KT-1 Congest model, that constructs a spanning subgraph (i.e., a danner) HH of GG such that HH has O~(min{m,n1+δ})\tilde{O}(\min\{m,n^{1+\delta}\}) edges and diameter O~(D+n1δ)\tilde{O}(D+n^{1-\delta}) with high probability. This construction uses O~(min{m,n1+δ})\tilde{O}(\min\{m,n^{1+\delta}\}) messages and runs in O~(n1δ)\tilde{O}(n^{1-\delta}) rounds with high probability.

We need the following corollary of this theorem.

Corollary 1.2.

Given an nn-vertex, mm-edge, diameter DD graph G=(V,E)G=(V,E) and a parameter δ[0,1]\delta\in[0,1], there exists a randomized algorithm to solve the leader election and broadcast problems in the synchronous KT-1 Congest model using O~(min{m,n1+δ})\tilde{O}(\min\{m,n^{1+\delta}\}) messages and in O~(D+n1δ)\tilde{O}(D+n^{1-\delta}) rounds with high probability.

We use this corollary to share O(polylogn)O(\operatorname{\text{{\rm poly}}}\log n) 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-11 Congest model, which is synchronous. In the asynchronous version of the KT-11 Congest model, we appeal to the following result.

Theorem 1.3 (Mashregi and King (Mashreghi and King, 2019, 2018)).

Given an nn-vertex, mm-edge graph G=(V,E)G=(V,E), 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 O~(min{m,n1.5})\tilde{O}(\min\{m,n^{1.5}\}) messages and in O(n)O(n) 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 Ω(m)\Omega(m) message lower bounds for (Δ+1)(\Delta+1)-coloring and MIS, for comparison-based algorithms, in the KT-11 Congest model.

Definition 2.1 (Executions).

We denote the execution of a Congest algorithm (or protocol) 𝒜\mathcal{A} on a graph G(V,E)G(V,E) with an ID-assignment ϕ\phi by EX(𝒜,G,ϕ)EX(\mathcal{A},G,\phi). 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 vv in the beginning of round ii of the execution EX(𝒜,G,ϕ)EX(\mathcal{A},G,\phi) by Li(EX,v)L_{i}(EX,v).

The decoded representation of an execution is obtained by replacing each occurrence of an ID value ϕ(v)\phi(v) by vv 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 ii of an execution EX(𝒜,G,ϕ)EX(\mathcal{A},G,\phi) as hi(EX(𝒜,G,ϕ))h_{i}(EX(\mathcal{A},G,\phi)).

Definition 2.2 (Similar executions).

Two executions of a Congest algorithm 𝒜\mathcal{A} on graphs G(V,E)G(V,E) and G(V,E)G^{\prime}(V,E^{\prime}) with ID-assignments ϕ\phi and ϕ\phi^{\prime} 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 G(V,E)G(V,E) and G(V,E)G^{\prime}(V^{\prime},E^{\prime}), where GG^{\prime} is obtained from GG by “crossing” a pair of edges in GG, and showing that the executions of any comparison-based algorithm, on GG and GG^{\prime} 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-11 model. We need the stronger notion, defined below.

Definition 2.3 (Utilized Edge).

An edge e={u,v}e=\{u,v\} is utilized if any one of the following happens during the course of the algorithm: (i) a message is sent along ee, (ii) the node uu sends or receives ID ϕ(v)\phi(v), or (iii) the node vv sends or receives ID ϕ(u)\phi(u).

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 mum_{u} denote the number of utilized edges in an execution EX(𝒜,G,ϕ)EX(\mathcal{A},G,\phi). Then the message complexity of the execution is Ω(mu)\Omega(m_{u}).

2.2. Lower Bound Graph Construction and ID Assignments

We now describe the construction of lower bound graphs that we use for our Ω(n2)\Omega(n^{2}) message complexity lower bounds. The same construction works for both the (Δ+1)(\Delta+1)-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 G(X,Y,Z,E)G(X,Y,Z,E) such that |X|=|Y|=|Z|=t|X|=|Y|=|Z|=t and the subgraphs of GG induced by XYX\cup Y and YZY\cup Z are both isomorphic to the complete bipartite graph Kt,tK_{t,t}. Thus, |E|=2t2|E|=2t^{2}. We then add a copy G(X,Y,Z,E)G^{\prime}(X^{\prime},Y^{\prime},Z^{\prime},E^{\prime}) of GG and consider the graph GGG\cup G^{\prime}. We call this the base graph. Let V=XYZV=X\cup Y\cup Z and V=XYZV^{\prime}=X^{\prime}\cup Y^{\prime}\cup Z^{\prime}. For each vVv\in V, the corresponding copy in VV^{\prime} is named vv^{\prime}. Let n=|VV|n=|V\cup V^{\prime}|. Thus t=n/6t=n/6. From the base graph GGG\cup G^{\prime}, we obtain a crossed graph as follows. For a vertex yYy\in Y, cross an edge e={y,z}e=\{y,z\} in GG, where zZz\in Z with the edge e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\} in GG^{\prime} where xXx^{\prime}\in X^{\prime} to obtain the graph Ge,eG_{e,e^{\prime}}. When we cross the edge e={y,z}Ee=\{y,z\}\in E with e={x,y}Ee^{\prime}=\{x^{\prime},y^{\prime}\}\in E^{\prime}, the resulting crossed graph Ge,eG_{e,e^{\prime}} has vertex set VVV\cup V^{\prime} and edge set (EE{e,e}){{y,y},{x,z}}(E\cup E^{\prime}\setminus\{e,e^{\prime}\})\cup\{\{y,y^{\prime}\},\{x^{\prime},z\}\}. The base graph GGG\cup G^{\prime} and the crossed graph Ge,eG_{e,e^{\prime}} for edges eE,eEe\in E,e^{\prime}\in E^{\prime} are illustrated in Figure 2.

Refer to caption
Figure 2. This figure shows the base graph GGG\cup G^{\prime} and the crossed graph Ge,eG_{e,e^{\prime}}, described in Section 2.2

We now define appropriate ID-assignments for the base graph and the crossed graph. Let SS be an arbitrary totally ordered set such that |S|=40t|S|=40t, and let S¯\overline{S} be the sorted list of elements in SS in ascending order. We will assign distinct elements in SS as ID’s to the base graph and the crossed graph. We use a short-hand and say that the ID of a vertex vv is i[0,40t)i\in[0,40t), when we mean that the ID of vv is S¯[i]\overline{S}[i]. Note that since S¯\overline{S} is sorted in ascending order, the relative ordering of the indices is the same as that of the corresponding ID’s in S¯\overline{S}.

Let ϕ:V[0,40t)\phi:V\to[0,40t) be an ID assignment such that ϕ(v)\phi(v) is even for all vVv\in V and additionally ϕ(v)[0,2t)\phi(v)\in[0,2t) if vXv\in X, ϕ(v)[10t,12t)\phi(v)\in[10t,12t) if vYv\in Y, and ϕ(v)[20t,22t)\phi(v)\in[20t,22t) if vZv\in Z. For a vertex yYy\in Y and pair of incident edges e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\}, we define a “shifted” ID assignment ϕe,e\phi^{\prime}_{e,e^{\prime}} for the vertex set VV^{\prime} of GG^{\prime}. We motivate this “shifted” assignment and define it precisely further below. But for now, assuming ϕe,e\phi^{\prime}_{e,e^{\prime}} is defined, we define the ID assignment ψe,e:VV[0,40t)\psi_{e,e^{\prime}}:V\cup V^{\prime}\to[0,40t) as just the union of ϕ\phi and ϕe,e\phi^{\prime}_{e,e^{\prime}}, i.e., ψe,e(v)=ϕ(v)\psi_{e,e^{\prime}}(v)=\phi(v) for all vVv\in V and ψe,e(v)=ϕe,e(v)\psi_{e,e^{\prime}}(v^{\prime})=\phi^{\prime}_{e,e^{\prime}}(v^{\prime}) for all vVv^{\prime}\in V^{\prime}. Our first goal in this subsection is to show that these two executions

EX=EX(𝒜,GG,ψe,e)EXe,e=EX(𝒜,Ge,e,ψe,e)EX=EX(\mathcal{A},G\cup G^{\prime},\psi_{e,e^{\prime}})\qquad\qquad EX_{e,e^{\prime}}=EX(\mathcal{A},G_{e,e^{\prime}},\psi_{e,e^{\prime}})

on the base graph GGG\cup G^{\prime} and the crossed graph Ge,eG_{e,e^{\prime}} are similar for any comparison-based algorithm 𝒜\mathcal{A}.

For the executions EXEX and EXe,eEX_{e,e^{\prime}} to be similar, it must be the case that the crossing of edges ee and ee^{\prime} is hidden from algorithm 𝒜\mathcal{A}. To achieve this, the ID assignment ϕe,e\phi^{\prime}_{e,e^{\prime}} of VV^{\prime} must be carefully chosen. For example, vertex zz has neighbor yy in GGG\cup G^{\prime}, but has neighbor xx^{\prime} in Ge,eG_{e,e^{\prime}} (see Figure 2). In the KT-1 model, zz’s initial local knowledge consists of vertex yy in GGG\cup G^{\prime} and vertex xx^{\prime} in Ge,eG_{e,e^{\prime}}. Therefore, for 𝒜\mathcal{A} to not distinguish between these two situations, it must be the case that the ID of xx^{\prime} is “adjacent” to the ID of yy. To achieve this, without disrupting other constraints on the relative order of ID’s, we start by assigning vertices in XX^{\prime} the ID’s of their corresponding vertices in XX and then “shift” these by (ϕ(y)ϕ(x))+1(\phi(y)-\phi(x))+1. As a result, vertex xx^{\prime} ends up with ID ϕ(y)+1\phi(y)+1. A similar “shift” is performed to obtain the ID’s of vertex set YY^{\prime}, though this time the “shift” is by the amount (ϕ(z)ϕ(y))+1(\phi(z)-\phi(y))+1 because we want vertex yy^{\prime} to be “adjacent” to vertex zz. The “shift” for vertex set ZZ^{\prime} just needs to be so that the ID assignment is disjoint, We now define the ID assignment ϕe,e:V[0,40t)\phi^{\prime}_{e,e^{\prime}}:V^{\prime}\to[0,40t) as

(1) ϕe,e(v)={ϕ(v)+(ϕ(y)ϕ(x))+1, if vXϕ(v)+(ϕ(z)ϕ(y))+1, if vYϕ(v)+10t+1, if vZ\phi^{\prime}_{e,e^{\prime}}(v^{\prime})=\begin{cases}\phi(v)+(\phi(y)-\phi(x))+1,\mbox{ if }v^{\prime}\in X^{\prime}\\ \phi(v)+(\phi(z)-\phi(y))+1,\mbox{ if }v^{\prime}\in Y^{\prime}\\ \phi(v)+10t+1,\mbox{ if }v^{\prime}\in Z^{\prime}\end{cases}

Note that the IDs of all vertices in each of the parts, XX^{\prime}, YY^{\prime}, and ZZ^{\prime}, are “shifted” by the same amount, though IDs in different parts may be “shifted” by different amounts.

The following observations about ϕe,e\phi^{\prime}_{e,e^{\prime}} are easy to verify.

  • (i)

    The ranges of ϕ\phi and ϕe,e\phi^{\prime}_{e,e^{\prime}} are disjoint.

  • (ii)

    Moreover, ϕe,e(v)[8t+1,14t+1]\phi^{\prime}_{e,e^{\prime}}(v)\in[8t+1,14t+1] if vXv\in X^{\prime}, ϕe,e(v)[18t+1,24t+1]\phi^{\prime}_{e,e^{\prime}}(v)\in[18t+1,24t+1] if vYv\in Y^{\prime}, and ϕe,e(v)[30t+1,32t+1]\phi^{\prime}_{e,e^{\prime}}(v)\in[30t+1,32t+1] if vZv\in Z^{\prime}.

  • (iii)

    For any u,vVu,v\in V, uvu\not=v, ϕ(u)<ϕ(v)\phi(u)<\phi(v) iff ϕe,e(u)<ϕe,e(v)\phi^{\prime}_{e,e^{\prime}}(u^{\prime})<\phi^{\prime}_{e,e^{\prime}}(v^{\prime}).

Item (iii) is simply saying that the ID ordering on VV^{\prime} induced by ϕe,e\phi^{\prime}_{e,e^{\prime}} is the same as the ID ordering induced by ϕ\phi with respect to the corresponding vertices in VV. This follows from the fact that the ID’s of vertices in XX^{\prime} are obtained by shifting the ID’s of vertices in XX by the same amount, thus preserving the relative ordering of ID’s in XX and XX^{\prime}. Similarly, for vertex sets YY^{\prime} and ZZ^{\prime}. Furthermore, even though the ID’s of different sets, XX^{\prime}, YY^{\prime}, and ZZ^{\prime} are obtained by “shifting” by different amounts, the “shifting” also ensures that ID’s in XX^{\prime} remain less than ID’s in YY^{\prime}, which in turn remain less than ID’s in ZZ^{\prime}.

To prove that EXEX and EXe,eEX_{e,e^{\prime}} are similar, we need two intermediate ID assignments for the set VVV\cup V^{\prime}. Recall that edge e={y,z}e=\{y,z\} and edge e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\}.

  • (i)

    Define ψe,e,x\psi_{e,e^{\prime},x} to be the ID assignment ψe,e\psi_{e,e^{\prime}} except for interchanging the values of xx^{\prime} and yy (i.e. ψe,e,x(y)=ϕe,e(x)\psi_{e,e^{\prime},x}(y)=\phi^{\prime}_{e,e^{\prime}}(x^{\prime}) and ψe,e,x(x)=ϕ(y)\psi_{e,e^{\prime},x}(x^{\prime})=\phi(y)).

  • (ii)

    Define ψe,e,z\psi_{e,e^{\prime},z} analogously as ψe,e\psi_{e,e^{\prime}} except for interchanging the values of yy^{\prime} and zz (i.e. ψe,e,z(z)=ϕe,e(y)\psi_{e,e^{\prime},z}(z)=\phi^{\prime}_{e,e^{\prime}}(y^{\prime}) and ψe,e,z(y)=ϕ(z)\psi_{e,e^{\prime},z}(y^{\prime})=\phi(z)).

Using these ID assignments, we define two intermediate executions on the base graph GGG\cup G^{\prime}.

EXe,e,x=EX(𝒜,GG,ψe,e,x);EXe,e,z=EX(𝒜,GG,ψe,e,z)EX_{e,e^{\prime},x}=EX(\mathcal{A},G\cup G^{\prime},\psi_{e,e^{\prime},x});\quad EX_{e,e^{\prime},z}=EX(\mathcal{A},G\cup G^{\prime},\psi_{e,e^{\prime},z})

The following lemma, which shows that EXEX, EXe,e,xEX_{e,e^{\prime},x}, and EXe,e,yEX_{e,e^{\prime},y} are similar, critically uses the fact that the ID assignment ψe,e\psi_{e,e^{\prime}} shifts the ID’s of vertices in XYZX^{\prime}\cup Y^{\prime}\cup Z^{\prime} so that the ID of xx^{\prime} becomes “adjacent” to the ID of yy and the ID of yy^{\prime} becomes “adjacent” to the ID of zz.

Lemma 2.5.

For any xXx\in X, yYy\in Y, zZz\in Z and edges e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\}, the executions EXEX, EXe,e,xEX_{e,e^{\prime},x} and EXe,e,zEX_{e,e^{\prime},z} are similar.

Proof.

All three executions have the same input graph GGG\cup G^{\prime}. The execution pair EXEX and EXe,e,xEX_{e,e^{\prime},x} have the same ID assignment except for the vertices xx^{\prime} and yy, which have their ID’s swapped. Note that by definition of ψe,e\psi^{\prime}_{e,e^{\prime}} and ϕe,e\phi^{\prime}_{e,e^{\prime}} in (1), we have

ψe,e(x)=ϕe,e(x)=ϕ(x)+(ϕ(y)ϕ(x))+1=ϕ(y)+1.\psi_{e,e^{\prime}}(x^{\prime})=\phi^{\prime}_{e,e^{\prime}}(x^{\prime})=\phi(x)+(\phi(y)-\phi(x))+1=\phi(y)+1.

Furthermore, ψe,e(y)=ϕ(y)\psi_{e,e^{\prime}}(y)=\phi(y). Therefore, when we swap the ID’s of xx^{\prime} and yy in ψe,e\psi_{e,e^{\prime}} to obtain ψe,e,x\psi_{e,e^{\prime},x}, there is no change in the relative ordering of ID’s and therefore the executions EXEX and EXe,e,xEX_{e,e^{\prime},x} are similar.

A similar argument holds for the execution pair EXEX and EXe,e,zEX_{e,e^{\prime},z}. By the definition of ψe,e\psi^{\prime}_{e,e^{\prime}} and ϕe,e\phi^{\prime}_{e,e^{\prime}} in (1), we have

ψe,e(y)=ϕe,e(y)=ϕ(y)+(ϕ(z)ϕ(y))+1=ϕ(z)+1\psi_{e,e^{\prime}}(y^{\prime})=\phi^{\prime}_{e,e^{\prime}}(y^{\prime})=\phi(y)+(\phi(z)-\phi(y))+1=\phi(z)+1

and ψe,e(z)=ϕ(z)\psi_{e,e^{\prime}}(z)=\phi(z). Thus the relative ordering of ID’s in ψe,e\psi_{e,e^{\prime}} and ψe,e,z\psi_{e,e^{\prime},z} is the same and therefore the executions EXEX and EXe,e,xEX_{e,e^{\prime},x} 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 e={y,z}e=\{y,z\} and {x,y}\{x^{\prime},y^{\prime}\} are not utilized in the execution EXEX of algorithm 𝒜\mathcal{A}, then executions EXEX and EXe,eEX_{e,e^{\prime}} are similar. The main obstacle is that the initial knowledge vertices x,y,y,zx^{\prime},y,y^{\prime},z is different in EXEX and EXe,eEX_{e,e^{\prime}} 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 xXx\in X, yYy\in Y, and zZz\in Z be arbitrary vertices and let e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\}. Suppose that during the first rr rounds of the execution EXEX both ee and ee^{\prime} are not utilized. Then the following hold for every round 1ir1\leq i\leq r of the executions EXEX, EXe,e,xEX_{e,e^{\prime},x} , EXe,e,zEX_{e,e^{\prime},z} and EXe,eEX_{e,e^{\prime}}:

  1. (1)

    The states of the nodes in the beginning of the round, i.e. Li(,)L_{i}(\cdot,\cdot) satisfy:

    1. (a)

      For every processor wV{y,z,y,x}w\in V\setminus\{y,z,y^{\prime},x^{\prime}\}, Li(EXe,e,w)=Li(EX,w)L_{i}(EX_{e,e^{\prime}},w)=L_{i}(EX,w).

    2. (b)

      For u{x,z}u\in\{x^{\prime},z\}, Li(EXe,e,u)=Li(EXe,e,x,u)L_{i}(EX_{e,e^{\prime}},u)=L_{i}(EX_{e,e^{\prime},x},u).

    3. (c)

      For v{y,y}v\in\{y,y^{\prime}\}, Li(EXe,e,v)=Li(EXe,e,z,v)L_{i}(EX_{e,e^{\prime}},v)=L_{i}(EX_{e,e^{\prime},z},v).

  2. (2)

    The messages sent during the round are similar, i.e., hi(EX)=hi(EXe,e,x)=hi(EXe,e,z)=hi(EXe,e)h_{i}(EX)=h_{i}(EX_{e,e^{\prime},x})=h_{i}(EX_{e,e^{\prime},z})=h_{i}(EX_{e,e^{\prime}}).

  3. (3)

    In EXe,eEX_{e,e^{\prime}}, no messages are sent during the round over the edges {x,z}\{x^{\prime},z\} and {y,y}\{y,y^{\prime}\}.

Corollary 2.7.

Suppose that during the execution EXEX neither of the edges e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\} are utilized, for some vertices xXx\in X, yYy\in Y, and zZz\in Z. Then the executions EXEX and EXe,eEX_{e,e^{\prime}} are similar and furthermore in EXe,eEX_{e,e^{\prime}}, no messages are sent through the edges {y,y}\{y,y^{\prime}\} and {x,z}\{x^{\prime},z\}.

In the next subsections, we will show that this similarity leads to a contradiction with respect to correctness for problems such as (Δ+1)(\Delta+1)-coloring and MIS. This in turn will imply a constraint on the behavior of algorithm 𝒜\mathcal{A}: for every pair of edges e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\}, at least one of the edges is utilized by 𝒜\mathcal{A}. This in turn will lead to the message complexity lower bound we desire.

2.3. Ω(m)\Omega(m) message lower bound for (Δ+1)(\Delta+1)-Coloring in KT-11 Congest

Now that we have shown that EXEX and EXe,eEX_{e,e^{\prime}} are similar if ee and ee^{\prime} are not utilized by algorithm 𝒜\mathcal{A}, we will show that for some problems this leads to a contradiction. The intuition for this is simple. Let ϕ\phi and ϕ\phi^{\prime} be ID assignments for VV and VV^{\prime} respectively, that consistently order the vertices, i.e., ϕ(u)<ϕ(v)\phi(u)<\phi(v) iff ϕ(u)<ϕ(v)\phi^{\prime}(u^{\prime})<\phi^{\prime}(v^{\prime}) for all u,vVu,v\in V. Since GG and GG^{\prime} are isomorphic, it is easy to show that EXG=EX(𝒜,G,ϕ)EX_{G}=EX(\mathcal{A},G,\phi) and EXG=EX(𝒜,G,ϕ)EX_{G^{\prime}}=EX(\mathcal{A},G^{\prime},\phi^{\prime}) are similar. This is shown below in Lemma 2.8 below. Now consider the base graph GGG\cup G^{\prime} and the ID assignment ψe,e\psi_{e,e^{\prime}} of VVV\cup V^{\prime}. Lemma 2.8 implies that corresponding vertices vv and vv^{\prime} have the same local states after execution EX=EX(𝒜,GG,ψe,e)EX=EX(\mathcal{A},G\cup G^{\prime},\psi_{e,e^{\prime}}) completes. Since EXEX and EXe,e=EX(𝒜,Ge,e,ψe,e)EX_{e,e^{\prime}}=EX(\mathcal{A},G_{e,e^{\prime}},\psi_{e,e^{\prime}}) are similar, this also implies that vertices vv and vv^{\prime} have the same local states after execution EXe,eEX_{e,e^{\prime}}. But, in the crossed graph Ge,eG_{e,e^{\prime}}, yy and yy^{\prime} 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 yYy\in Y and an arbitrary pair of edges e={y,z}e=\{y,z\}, zZz\in Z and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\}, xXx^{\prime}\in X^{\prime}. For any comparison-based algorithm 𝒜\mathcal{A} in the KT-1 Congest model, the executions EXG=EX(𝒜,G,ϕ)EX_{G}=EX(\mathcal{A},G,\phi) and EXG=EX(𝒜,G,ϕe,e)EX_{G^{\prime}}=EX(\mathcal{A},G^{\prime},\phi^{\prime}_{e,e^{\prime}}) are similar.

Proof.

Since the input graphs GG and GG^{\prime} 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 ϕe,e\phi^{\prime}_{e,e^{\prime}} above implies that every ID comparison by 𝒜\mathcal{A} on GG yields the same result as the corresponding ID comparison on GG^{\prime}. Therefore, by an inductive argument it can be shown that at the beginning of each round, the state of each vertex vv in GG is the same as the state of the corresponding vertex vv^{\prime} in GG^{\prime} and the messages received by these vertices are also be the same. This gives us that the executions EXGEX_{G} and EXGEX_{G^{\prime}} are similar. ∎

Lemma 2.9.

Let xXx\in X, yYy\in Y, and zZz\in Z be three vertices such that the edges e={y,z)}e=\{y,z)\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\} are not utilized in the execution EXEX. Then, algorithm 𝒜\mathcal{A} computes an incorrect (Δ+1)(\Delta+1)-coloring for the crossed graph Ge,eG_{e,e^{\prime}}.

Proof.

In the execution EXEX, since the input graph has two disconnected components GG and GG^{\prime}, Lemma 2.8 gives us that the color of a vertex vv in GG is the same as the color of the corresponding vertex vv^{\prime} in GG^{\prime}. Since the edges e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\} are not utilized in GGG\cup G^{\prime}, applying Corollary 2.7, 𝒜\mathcal{A} will compute the same coloring in the graph Ge,eG_{e,e^{\prime}} as it will in GGG\cup G^{\prime}. This implies a monochromatic edge {y,y}\{y,y^{\prime}\} in Ge,eG_{e,e^{\prime}} which contradicts the correctness of the algorithm. ∎

Theorem 2.10 (Deterministic Lower Bound).

Let 𝒜\mathcal{A} be a deterministic comparison-based algorithm that computes a (Δ+1)(\Delta+1)-coloring. Then the message complexity of 𝒜\mathcal{A} is Ω(n2)\Omega(n^{2}). This holds even if the vertices know the size of the network.

Proof.

Suppose that 𝒜\mathcal{A} is a deterministic comparison-based algorithm that computes a (Δ+1)(\Delta+1)-coloring and has message complexity o(n2)o(n^{2}). Then by Lemma 2.4, the number of edges utilized by 𝒜\mathcal{A} is o(n2)o(n^{2}). This implies that there exists a yYy\in Y and edges e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\} such that ee and ee^{\prime} are not utilized when 𝒜\mathcal{A} executes on GGG\cup G^{\prime}. By Lemma 2.9 this implies that 𝒜\mathcal{A} computes an incorrect (Δ+1)(\Delta+1)-coloring for Ge,eG_{e,e^{\prime}}. ∎

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 \mathcal{F} denote the family of all crossed graphs, i.e., ={Ge,ee={y,z},e={x,y},x,y,z,V}\mathcal{F}=\{G_{e,e^{\prime}}\mid e=\{y,z\},e^{\prime}=\{x^{\prime},y^{\prime}\},x,y,z,\in V\}. Note that ||=t3|\mathcal{F}|=t^{3} because there are tt choices for yy and for each choice of yy, there are t2t^{2} choices for ee and ee^{\prime}.

Lemma 2.11.

Let 𝒜\mathcal{A} be a deterministic comparison-based KT-11 Congest algorithm that computes a (Δ+1)(\Delta+1)-coloring correctly on at least a constant δ\delta fraction of graphs in the family \mathcal{F}. Then the message complexity of 𝒜\mathcal{A} is Ω(δn2)\Omega(\delta n^{2}). This holds even if the vertices know the size of the network.

Proof.

Assume for the sake of contradiction that the message complexity of 𝒜\mathcal{A} is o(δn2)o(\delta n^{2}). By Lemma 2.4, we have that 𝒜\mathcal{A} utilizes o(δn2)o(\delta n^{2}) edges in any graph that it runs on. Specifically consider the execution EXEX of algorithm 𝒜\mathcal{A} on input graph GGG\cup G^{\prime} and ID assignment ψe,e\psi_{e,e^{\prime}} where e,ee,e^{\prime} denote a graph Ge,eG_{e,e^{\prime}} in the family \mathcal{F}.

Since 𝒜\mathcal{A} utilizes o(δn2)o(\delta n^{2}) edges, there can only be o(n)=o(t)o(n)=o(t) vertices in YY such that more than cn/6=ctcn/6=ct incident edges are utilized, for some constant cc to be determined later. Recall that t=n/6t=n/6. The rest of the to(t)t-o(t) vertices in YY have less than ctct incident edges that are utilized. By Lemma 2.8 the same statement holds for the corresponding vertices in YY^{\prime} because in EXEX, the two graphs GG and GG^{\prime} that form the input graph are disconnected, which implies the executions of 𝒜\mathcal{A} on GG and GG^{\prime} are similar.

So for each such vertex yYy\in Y, there are at most (c2/4)t2(c^{2}/4)t^{2} edge pairs of the form e={y,z},e={x,y}e=\{y,z\},e^{\prime}=\{x^{\prime},y^{\prime}\} such that e,ee,e^{\prime} are utilized. Therefore, by Lemma 2.9, the algorithm computes an incorrect (Δ+1)(\Delta+1)-coloring on at least (1o(1))(1(c2/4))=1(c2/4)o(1)(1-o(1))(1-(c^{2}/4))=1-(c^{2}/4)-o(1)-fraction of the graphs in \mathcal{F} (since for each yYy\in Y there are exactly t2t^{2} graphs in \mathcal{F}). Setting c=2δc=\sqrt{2\delta}, the algorithm computes an incorrect (Δ+1)(\Delta+1)-coloring on at least 1δ/2o(1)1-\delta/2-o(1)-fraction of the graphs in \mathcal{F}. This is a contradiction if 1δ<1δ/2o(1)1-\delta<1-\delta/2-o(1) or δ>o(1)\delta>o(1). Since δ\delta 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 \mathcal{F} gives the following theorem.

Theorem 2.12 (Randomized Lower Bound).

Let 𝒜\mathcal{A} be a randomized Monte-Carlo comparison based KT-11 Congest algorithm that computes a (Δ+1)(\Delta+1)-coloring with probability of error less than a constant ϵ[0,1)\epsilon\in[0,1). Then the worst case message complexity of 𝒜\mathcal{A} is Ω((1ϵ)n2)\Omega((1-\epsilon)n^{2}). This holds even if the vertices know the size of the network.

2.4. Ω(m)\Omega(m) message lower bound for MIS in KT-11 Congest

Lemma 2.13.

Let xXx\in X, yYy\in Y, and zZz\in Z be three vertices such that the edges e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\} are not utilized in the execution EXEX. Then, algorithm 𝒜\mathcal{A} computes an incorrect MIS on Ge,eG_{e,e^{\prime}}.

Proof.

Due to Lemma 2.8, we can only have two MIS’s in GGG\cup G^{\prime} which are: Y,YY,Y^{\prime} or X,X,Z,ZX,X^{\prime},Z,Z^{\prime}. Since the edges e={y,z}e=\{y,z\} and e={x,y}e^{\prime}=\{x^{\prime},y^{\prime}\} are not utilized in GGG\cup G^{\prime}, applying Corollary 2.7, 𝒜\mathcal{A} will compute the same MIS in the graph Ge,eG_{e,e^{\prime}} as it will in GGG\cup G^{\prime}. Both the MIS solutions mentioned above violate the independence requirement of MIS in Ge,eG_{e,e^{\prime}}. 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 𝒜\mathcal{A} be a deterministic comparison-based KT-11 Congest algorithm that solves the MIS problem. Then the message complexity of 𝒜\mathcal{A} is Ω(n2)\Omega(n^{2}). This holds even if the vertices know the size of the network.

The following lemma for MIS parallels Lemma 2.11 for (Δ+1)(\Delta+1)-coloring. This has a very similar proof, which we skip.

Lemma 2.15.

Let 𝒜\mathcal{A} be a deterministic comparison-based KT-11 Congest algorithm that computes an MIS correctly on at least a constant δ\delta fraction of graphs in the family \mathcal{F}. Then the message complexity of 𝒜\mathcal{A} is Ω(δn2)\Omega(\delta n^{2}). 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. \mathcal{F} gives the following theorem.

Theorem 2.16 (Randomized Lower Bound).

Let 𝒜\mathcal{A} be a randomized Monte-Carlo comparison-based KT-11 Congest algorithm that computes an MIS with probability of error less than a constant ϵ[0,1)\epsilon\in[0,1). Then the worst case message complexity of 𝒜\mathcal{A} is Ω((1ϵ)n2)\Omega((1-\epsilon)n^{2}). This holds even if the vertices know the size of the network.

2.5. Ω(n)\Omega(n) message lower bound in KT-ρ\rho Congest

The Ω(m)\Omega(m) lower bounds we have proved apply to comparison-based algorithms in the KT-11 Congest model. We now prove a weaker Ω(n)\Omega(n) message complexity bound for (Δ+1)(\Delta+1)-coloring and MIS, but these apply more generally, to all algorithms (even non-comparison-based) and to the KT-ρ\rho Congest model, for any constant ρ\rho.

Theorem 2.17.

Any randomized Monte Carlo algorithm that computes an MIS or a (Δ+1)(\Delta+1)-vertex coloring with probability at least 58\tfrac{5}{8}, requires Ω(n)\Omega(n) messages in expectation in the KT-ρ\rho Congest model, for any constant ρ\rho.

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 ρ\rho, define the constant kk to be the smallest integer such that

log(k)2(ρ+3).\log^{*}(k)\geq 2(\rho+3).

Consider an nn-node graph GG consisting of the disjoint union of n/kn/k cycles each of kk nodes.666For simplicity, we assume that n/kn/k is an integer. For each cycle CiC_{i}, we fix a set of IDs RiR_{i} from some integer range of size kk such that all ID ranges assigned to the cycles are pairwise disjoint. We will equip the nodes of each cycle CiC_{i} with kk unique IDs, as described below.

Consider any randomized algorithm B0B_{0} that works on a cycle. We know from (Naor, 1991) that any randomized algorithm that succeeds in computing a 33-coloring on cycle CiC_{i} with probability more than 12\tfrac{1}{2} requires at least 12log(k)2\tfrac{1}{2}\log^{*}(k)-2 rounds in the worst case, under the KT-0 assumption. Now suppose that we execute B0B_{0} on our lower bound graph GG for at most ρ<12log(k)2\rho<\tfrac{1}{2}\log^{*}(k)-2 rounds under the KT-0 assumption. Even though B0B_{0} is not guaranteed to work on GG, it nevertheless exhibits some well-defined behavior on each cycle that we will exploit. Observe that each node uu in GG is part of some cycle CiC_{i} and hence the color output by uu is a function of the observed neighborhood and the random coin flips. We point out that, even though that uu also has knowledge of nn, 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 CiC_{i}, there exists some hard ID assignment IiI_{i}, which is a permutation of the set RiR_{i}, such that B0B_{0} fails to yield a valid coloring on CiC_{i} with some probability greater than 12\tfrac{1}{2} (assuming KT-0), where this probability is taken over the coin flips of the nodes in CiC_{i}.

Returning to the KT-ρ\rho assumption, suppose towards a contradiction that there exists an algorithm BρB_{\rho} that computes a 33-coloring on GG while sending o(n)o(n) messages in expectation. We provide additional power to the algorithm by revealing, to each node uu, the coin flips of the nodes in its ρ\rho-neighborhood.

We assign the IDs of the nodes in each cycle CiC_{i} according to IiI_{i}. Since there are n/k=Ω(n)n/k=\Omega(n) cycles but the expected message complexity of BρB_{\rho} is o(n)o(n), it holds that, with probability at least 34\tfrac{3}{4}, there exists a cycle CjC_{j} such that the nodes in CjC_{j} do not send any messages at all when executing BρB_{\rho}; call this event Mute. We now condition on Mute occurring: Consider any node uCju\in C_{j} and observe that the output of uu is a function of its initial knowledge, i.e., its random coin flips and the local state of its ρ\rho-neighborhood. Clearly, the behavior of uu follows the exact same probability distribution when executing BρB_{\rho} under the KT-ρ\rho assumption as it does when executing algorithm B0B_{0} under the KT-0 assumption. In particular, the result of (Naor, 1991) implies that some neighboring nodes in CjC_{j} will output the same color with probability greater than 12\tfrac{1}{2}. Since event Mute occurs with probability at least 34\tfrac{3}{4}, it follows that algorithm BρB_{\rho} fails with probability >38>\tfrac{3}{8}, yielding a contradiction. ∎

3. Upper bounds in KT-1 Congest

3.1. (Δ+1)(\Delta+1)-Coloring using O~(n1.5)\tilde{O}(n^{1.5}) Messages in KT-1 Congest

In this section we present a (Δ+1)(\Delta+1)-list-coloring algorithm in the KT-1 Congest model that uses O~(n1.5)\tilde{O}(n^{1.5}) 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 (Δ+1)(\Delta+1)-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 Ψ(v)\Psi(v) denote the palette of vertex vVv\in V and let k=Δk=\sqrt{\Delta}.

  • Vertex set partition: We partition VV into B1,,Bk,LB_{1},\dots,B_{k},L as follows. Include each vVv\in V in the set LL with probability q=Θ(lognΔ1/4)q=\Theta\left(\frac{\sqrt{\log n}}{\Delta^{1/4}}\right). Then each remaining vertex joins one of B1,,BkB_{1},\ldots,B_{k} uniformly at random.

  • Palette partition: Let C=vVΨ(v)C=\bigcup_{v\in V}\Psi(v) be the set of all colors. We partition CC into kk sets C1,,CkC_{1},\dots,C_{k} where each color cCc\in C joins one of the kk 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 Δ=ω(log2n)\Delta=\omega(\log^{2}n). These properties allow us to color each set BiB_{i} using palette CiC_{i}, in parallel, and then recursively color the set LL until it becomes small enough to color trivially.

(i) Size of Each Part::

|E(G[Bi])|=O(|V|)|E(G[B_{i}])|=O(|V|), for each i[k]i\in[k]. Also, |L|=O(q|V|)=O(lognΔ1/4)|V||L|=O(q|V|)=O\left(\frac{\sqrt{\log n}}{\Delta^{1/4}}\right)\cdot|V|.

(ii) Available Colors in BiB_{i}::

For each i{1,,k}i\in\{1,\ldots,k\} and vBiv\in B_{i}, let the number of available colors in vv in the subgraph BiB_{i} be gi(v):=|Ψ(v)Ci|g_{i}(v):=|\Psi(v)\cap C_{i}|. Then gi(v)Δi+1g_{i}(v)\geq\Delta_{i}+1, where Δi:=maxvBidegBi(v)\Delta_{i}:=\max_{v\in B_{i}}\deg_{B_{i}}(v).

(iii) Available Colors in LL::

For each vLv\in L, define gL(v):=|Ψ(v)|(degG(v)degL(v))g_{L}(v):=|\Psi(v)|-(\deg_{G}(v)-\deg_{L}(v)). It is required that gL(v)max{degL(v),ΔLΔL3/4}+1g_{L}(v)\geq\max\{\deg_{L}(v),\Delta_{L}-\Delta_{L}^{3/4}\}+1 for each vLv\in L, where ΔL:=maxvLdegL(v)\Delta_{L}:=\max_{v\in L}\deg_{L}(v). Note that gL(v)g_{L}(v) represents a lower bound on the number of available colors in vv’s palette after all of B1,,BkB_{1},\ldots,B_{k} have been colored.

(iv) Remaining Degrees::

The maximum degrees of BiB_{i} and LL are degBi(v)Δi=O(Δ)\deg_{B_{i}}(v)\leq\Delta_{i}=O(\sqrt{\Delta}) and degL(v)ΔL=O(qΔ)=O(lognΔ1/4)Δ\deg_{L}(v)\leq\Delta_{L}=O(q\Delta)=O\left(\frac{\sqrt{\log n}}{\Delta^{1/4}}\right)\cdot\Delta. For each vertex, we have that degBi(v)max{O(logn),O(1/Δ)deg(v)}\deg_{B_{i}}(v)\leq\max\{O(\log n),O(1/\sqrt{\Delta})\cdot\deg(v)\} and also have degL(v)max{O(logn),O(q)deg(v)}\deg_{L}(v)\leq\max\{O(\log n),O(q)\cdot\deg(v)\}.

We now present our algorithm, which takes as input an nn-vertex graph GG with maximum degree Δ\Delta and diameter DD. The algorithm runs in the KT-1 Congest model and produces a (Δ+1)(\Delta+1)-list-coloring of GG using O~(n1.5)\tilde{O}(n^{1.5}) messages and running in O~(D+n)\tilde{O}(D+\sqrt{n}) rounds.

1For δ=1/2\delta=1/2, build a danner HH, elect a leader \ell, and have the leader broadcast a string RR of O(log2n)O(\log^{2}n) random bits.
2 Nodes use the O(log2n)O(\log^{2}n) bits of RR to sample three O(logn)O(\log n)-wise independent hash functions: (a) hLh_{L}, to decide whether to join LL, (b) hh, to decide which set BiB_{i} to join, and (c) hch_{c}, to determine which color goes into which part CiC_{i}.
3 Nodes execute a randomized algorithm for list coloring by Johansson (Öjvind Johansson, 1999) in each BiB_{i} in parallel.
4 Using the danner HH, we can check whether the induced graph G[L]G[L] has O~(n)\tilde{O}(n) edges.
5 If it does, we execute the list coloring algorithm by Johansson (Öjvind Johansson, 1999) on G[L]G[L].
If not, we recursively run this algorithm on G[L]G[L] with the same parameter nn.
Algorithm 1 KT-11 (Δ+1)(\Delta+1)-Coloring Algorithm:

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 O(logn)O(\log n)-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 O(logn)O(\log n)-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 O(logn)O(\log n)-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 O(1)O(1) recursive calls w.h.p.

Theorem 3.3.

Given as input an nn-vertex graph GG with maximum degree Δ\Delta and diameter DD, Algorithm 1 runs in the KT-1 Congest model and produces a (Δ+1)(\Delta+1)-list-coloring of GG using O~(n1.5)\tilde{O}(n^{1.5}) messages and running in O~(D+n)\tilde{O}(D+\sqrt{n}) rounds.

Proof.

In Step 1, we create a danner with the parameter δ=1/2\delta=1/2, building the danner takes O~(n)\tilde{O}(\sqrt{n}) rounds and O~(n1.5)\tilde{O}(n^{1.5}) messages, see Lemma 1.1. Also, because of danner property, the diameter of the danner is O~(D+n)\tilde{O}(D+\sqrt{n}) and hence electing a leader and broadcasting a log2n\log^{2}n-bit random string takes O~(D+n)\tilde{O}(D+\sqrt{n}) rounds and O~(n1.5)\tilde{O}(n^{1.5}) messages (Corollary 1.2). Step 2 is just local computation.

In step 3 we use Johansson’s randomized algorithm on each G[Bi]G[B_{i}]. This algorithm works in O(logn)O(\log n) rounds and O~(|E(G[Bi])|)\tilde{O}(|E(G[B_{i}])|) messages whp even when the palette of each vertex vv has been initialized to an arbitrary subset of deg(v)+1\deg(v)+1 colors chosen from {1,2,,Δ+1}\{1,2,\dots,\Delta+1\} (Öjvind Johansson, 1999). According to Property (ii), the palettes of vertices in each BiB_{i} are large enough. And according to property (i), |E(G[Bi])|=|V||E(G[B_{i}])|=|V| So this step runs in O(logn)O(\log n) rounds and takes O~(nΔ)\tilde{O}(n\sqrt{\Delta}) messages over all the BiB_{i}’s whp, since there are O(Δ)O(\sqrt{\Delta}) BiB_{i}’s.

Step 4 takes O~(D+n)\tilde{O}(D+\sqrt{n}) rounds and O~(n1.5)\tilde{O}(n^{1.5}) messages by Corollary 1.2. Using Lemma 3.2 and the above arguments guarantee that steps 5 and 6 together take O~(D+n)\tilde{O}(D+\sqrt{n}) rounds and O~(n1.5)\tilde{O}(n^{1.5}) messages whp. The theorem follows. ∎

3.1.1. Asynchronous KT-1 Congest algorithm

The (Δ+1)(\Delta+1)-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 O~(n1.5)\tilde{O}(n^{1.5}) messages and in O(n)O(n) 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 vBiv\in B_{i}, for each i[k]i\in[k], knows which of its neighbors are in BiB_{i}. The coloring algorithm in Step 3 therefore can be executed by nodes in BiB_{i} by communicating just over the edges in the induced graph G[Bi]G[B_{i}]. The synchronous algorithm used in Step 3 in Algorithm 1 can be simulated by using an α\alpha-synchronizer (Awerbuch, 1985) (see Theorem A.5) in an asynchronous setting. This takes O~(n)\tilde{O}(n) messages since (i) according to Lemma 3.1, G[Bi]G[B_{i}] contains O(n)O(n) edges and (ii) Step 3 runs in O(logn)O(\log n) rounds. Checking if G[L]G[L] has O~(n)\tilde{O}(n) edges (Step 4) can be done via asynchronous upcast, using O~(n)\tilde{O}(n) messages and in O(n)O(n) rounds. This is possible because each node vLv\in L, knows which of its neighbors are in LL and can therefore send the size of its LL-restricted neighborhood up the spanning tree. Like Step 3, Step 5 can also be executed using O(n)O(n) messages, in O(logn)O(\log n) rounds. This description leads to the following theorem.

Theorem 3.4.

Given as input an nn-vertex graph GG with maximum degree Δ\Delta, there is an algorithm that runs in the asynchronous KT-1 Congest model and produces a (Δ+1)(\Delta+1)-list-coloring of GG using O~(n1.5)\tilde{O}(n^{1.5}) messages and running in O~(n)\tilde{O}(n) rounds.

3.2. (1+ϵ)Δ(1+\epsilon)\Delta-Coloring using O~(n)\tilde{O}(n) Messages in KT-1 Congest

In this section, we show that for any ϵ>0\epsilon>0, there is an algorithm that can compute a (1+ϵ)Δ(1+\epsilon)\Delta-coloring in the KT-1 Congest model in O~(n)\tilde{O}(n) rounds, using O~(n/ϵ2)\tilde{O}(n/\epsilon^{2}) messages.

At the beginning of the algorithm, for a large enough constant CC, one node generates (C/ϵ)log3n(C/\epsilon)\cdot\log^{3}n random bits and shares it with all other nodes using a danner (Gmyr and Pandurangan, 2018), using O~(n/ϵ)\tilde{O}(n/\epsilon) messages and O~(n)\tilde{O}(n) rounds in the KT-1 Congest model (cf. Corollary 1.2). In the following algorithm, each node vv that has not already permanently colored itself, will use random bit string sis_{i} in Phase ii to first select a random hash function hih_{i} from a family of Θ(logn)\Theta(\log n)-wise independent hash functions ={h:[poly(n)][(1+ϵ)Δ]}\mathcal{H}=\{h:[\text{poly}(n)]\to[(1+\epsilon)\Delta]\}. Node vv will then compute hi(IDv)h_{i}(\texttt{ID}_{v}) to pick a random color from the palette [(1+ϵ)Δ][(1+\epsilon)\Delta]. Note that the length of sis_{i} is Θ(log2n)\Theta(\log^{2}n) and by Lemma A.4, this number of random bits suffice to pick a Θ(logn)\Theta(\log n)-wise independent hash function with domain size poly(n)\text{poly}(n) and range size (1+ϵ)Δ(1+\epsilon)\Delta. In Corollary 3.6, it is shown that Algorithm 2 runs in O(logn/ϵ)O(\log n/\epsilon) phases and therefore r=Θ(logn/ϵ)r=\Theta(\log n/\epsilon) random bit strings suffice.

1Each active node (i.e., which has not been colored yet) chooses a random candidate color from (1+ε)Δ(1+\varepsilon)\Delta color palette.
2
3It makes this color permanent if it is sure that none of its neighbors has chosen this color yet.
4
If unsuccessful in choosing a permanent color, go to step 1.
Algorithm 2 (1+ϵ)Δ(1+\epsilon)\Delta-Coloring Algorithm (One phase):

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 ε/(1+ε)ε\varepsilon/(1+\varepsilon)\approx\varepsilon (for small ε\varepsilon). 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 O(logn/ε)O(\log n/\varepsilon) rounds whp.

Proof.

Fix a node vv and suppose that it has degree dd. Arbitrarily label the neighbors of vv, v1,v2,,vdv_{1},v_{2},\ldots,v_{d} and let XiX_{i} be the indicator variable that indicates if neighbor viv_{i} has picked same color as vv. Let X=i=1dXiX=\sum_{i=1}^{d}X_{i}. Then Pr[Xi=1]=1/(1+ϵ)Δ\text{Pr}[X_{i}=1]=1/(1+\epsilon)\Delta and 𝔼[X]d/(1+ϵ)Δ1/(1+ϵ)\mathbb{E}[X]\leq d/(1+\epsilon)\Delta\leq 1/(1+\epsilon). Then, by Markov’s inequality, Pr[X1]1/(1+ϵ)\text{Pr}[X\geq 1]\leq 1/(1+\epsilon). Therefore, Pr[X=0]ϵ/(1+ϵ)ε\text{Pr}[X=0]\geq\epsilon/(1+\epsilon)\approx\varepsilon, (for small ε>0\varepsilon>0). Since X=0X=0 represents the event that no neighbor of vv chooses the color vv picked, we get the first part of the lemma.

Thus after (clogn)/ε(c\log n)/\varepsilon rounds for a large enough constant cc, vv will successfully color itself whp. ∎

Corollary 3.6.

Whp, all nodes successfully color themselves in O(logn/ε)O(\log n/\varepsilon) 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 O(log2n/ε)O(\log^{2}n/\varepsilon) 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 vv and let cc be the color it samples in this round. Arbitrarily label the neighbors of vv, v1,v2,,vdv_{1},v_{2},\ldots,v_{d} and let XiX_{i} be the indicator variable that indicates if neighbor viv_{i} has picked same color as vv in this round. Let X=i=1dXiX=\sum_{i=1}^{d}X_{i}. Then Pr[Xi=1]=1/(1+ϵ)Δ\text{Pr}[X_{i}=1]=1/(1+\epsilon)\Delta and 𝔼[X]d/(1+ϵ)Δ1/(1+ϵ)\mathbb{E}[X]\leq d/(1+\epsilon)\Delta\leq 1/(1+\epsilon). Since the colors of vertices are chosen using an Θ(logn)\Theta(\log n)-wise independent family of hash functions, the variables X1,X2,,XdX_{1},X_{2},\ldots,X_{d} are Θ(logn)\Theta(\log n)-wise independent. Then, by Lemma A.2, for a sufficiently large constant AA, Pr[XAlogn]exp(2logn)=1/n2\text{Pr}[X\geq A\cdot\log n]\leq\exp(-2\log n)=1/n^{2}. Therefore, whp there are at most O(logn)O(\log n) neighbors of vv that could have picked color cc in this round.

This is true of color cc in previous rounds as well. Node vv has to check all these neighbors which have chosen cc in this round or prior rounds to be sure that there is no conflict in choosing cc. Since there are at most O(logn/ε)O(\log n/\varepsilon) phases whp (by Lemma 3.5), color cc is chosen by only O(lognlogn/ε)=O(log2n/ε)O(\log n\log n/\varepsilon)=O(\log^{2}n/\varepsilon) neighbors whp. ∎

Theorem 3.8.

There is a coloring algorithm that achieves (1+ε)Δ(1+\varepsilon)\Delta coloring using O(nlog3n/ε2)O(n\log^{3}n/\varepsilon^{2}) messages whp in KT1 model (with shared randomness).

Proof.

By Lemma 3.5, all nodes can legally color themselves in O(logn/ε)O(\log n/\varepsilon) rounds whp. By Lemma 2, each node exchanges O(log2n/ε)O(\log^{2}n/\varepsilon) messages in a phase and there are at most O(logn/ε)O(\log n/\varepsilon) phases. Hence the overall message complexity (of all nodes) is O(nlog3n/ε2)O(n\log^{3}n/\varepsilon^{2}) whp. ∎

4. An MIS algorithm using O~(n1.5)\tilde{O}(n^{1.5}) messages in KT-22 Congest

We now give a high-level overview of Algorithm 3 that uses KT-22 knowledge to compute an MIS using only O(n1.5log2n)O(n^{1.5}\log^{2}n) messages while taking O~(n)\tilde{O}(\sqrt{n}) rounds; the full details are explained in the proof of Theorem 4.1. We first sample a set SS of Θ(n)\Theta(\sqrt{n}) nodes and then add these nodes to the independent set according to the randomized greedy MIS algorithm. Since SS was chosen randomly, this has the same effect as performing Θ(n)\Theta(\sqrt{n}) iterations of the sequential randomized greedy algorithm, which is known to reduce the maximum degree in the remnant graph to O~(n)\tilde{O}(\sqrt{n}) (see (Konrad, 2018)). Then, each node uSu\in S that entered the independent set informs its 2-hop neighbors. It is crucial that node uu uses its KT-22 knowledge to convey this information, as otherwise the same 2-hop neighbor vv might receive uu’s message from multiple 1-hop neighbors of uu, which may result in ω(n)\omega(n) messages being sent on behalf of uu. Finally, we compute an MIS on the (sparsified) remnant graph using Luby’s algorithm.

1
2Sample O(n)O(\sqrt{n}) vertices: Add each node to a set SS with probability c/nc/\sqrt{n}.
3
4Run Randomized Greedy MIS: Each node in SS chooses a random rank at the start of the algorithm. In the parallel version of Greedy, a node enters the MIS as soon as it is a local maximum among undecided neighbors in SS.
5Inform 22-hop Neighbors: Each node uSu\in S that enters the MIS uu uses KT-2 knowledge to inform all of its 2-hop neighbors that it has joined the MIS.
6Pruning Inactive Edges: Each node vVv\in V uses its own KT-22 knowledge to either deactivate itself if a 11-hop neighbor has joined the MIS or deactivate edges incident on the 11-hop neighbors that are neighbors with a node that joins the MIS.
7
Finishing Up: All nodes in the remnant graph know which of their neighbors are deactivated and so we can run Luby’s algorithm on the remnant graph.
Algorithm 3 MIS Algorithm
Theorem 4.1.

Algorithm 3 computes a correct MIS. It uses O(n1.5log2n)O(n^{1.5}\log^{2}n) messages and runs in O~(n)\tilde{O}(\sqrt{n}) rounds with high probability.

Proof.

In the first two steps, we aim to simulate O(n)O(\sqrt{n}) 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 ii iterations of this algorithm is probabilistically equivalent to sampling ii vertices uniformly at random and generating random ranks at just tho sampled vertices. Note that since we sample vertices uniformly at random with probability c/nc/\sqrt{n}, we get |S|=O(n)|S|=O(\sqrt{n}) 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 O(logn)O(\log n) rounds whp, and so the message complexity of steps will just be O(|S|nlogn)=O(n1.5logn)O(|S|n\log n)=O(n^{1.5}\log n) whp.

Using KT-2 information, each vertex in uSu\in S that joins the MIS locally creates a depth 22 BFS tree on its 22-hop neighborhood and sends the message through this tree. This BFS tree is constructed by having all 11-hop neighbors of uu at depth 11 and assigning a node vv that is exactly 22-hops away as a child to the 11-hop neighbor with lowest ID. The local view of this BFS tree can be created at all 11-hop neighbors of uu using their own KT-2 information since the common 11-hop neighbors of uu and vv are all 22-hops away.

To send the message to 11-hop neighbors, uu can just broadcast. The one hop neighbors will just inform their neighbors in the BFS tree that uu has joined the MIS. In case a node ww gets multiple messages of 11-hop neighbors in SS joining the MIS and their BFS trees lead to the same 22-hop vertex vv, then ww will just send all these messages one by one to vv. The congestion on such an edge can be at most |S||S| in the worst case. This allows each such node vv 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 |S|=O(n)|S|=O(\sqrt{n}) whp, and each vertex in SS that joins the MIS can relay this information to it’s 2-hop neighbors using constant messages per neighbor, this process generates at most O(|S|n)=O(n1.5logn)O(|S|n)=O(n^{1.5}\log n) messages whp. But due to congestion, this process will take O(n)O(\sqrt{n}) whp in the worst case.

After the simulation, we know from Lemma 1 in (Konrad, 2018) that the remnant graph has maximum degree O(nlogn/|S|)=O(nlogn)O(n\log n/|S|)=O(\sqrt{n}\log n). And since the nodes know the remnant graph, running Luby’s algorithm (Luby, 1985) will require an additional O(logn)O(\log n) rounds and O(n1.5log2n)O(n^{1.5}\log^{2}n) messages whp.

Therefore, Algorithm 3 runs in O(n)O(\sqrt{n}) rounds and uses O(n1.5log2n)O(n^{1.5}\log^{2}n) 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 (Δ+1)(\Delta+1)-coloring. We show that while it is impossible to obtain o(m)o(m) message complexity in the KT-11 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-22 Congest model.

Several key open questions arise from our work. The first is whether one can obtain an o(m)o(m)-message, non-comparison-based algorithm for MIS in the KT-11 Congest model, running in polynomial time. We have shown that this is possible for (Δ+1)(\Delta+1)-coloring. The second is whether one can obtain (nearly optimal) O~(n)\tilde{O}(n)-message (non-comparison-based) algorithms for MIS and (Δ+1)(\Delta+1)-coloring in the KT-11 Congest model, running in polynomial time. The question is open for MIS even in the KT-22 Congest model. Another important issue is reducing the running time of our algorithms. In particular, can we make them run in polylogn\operatorname{polylog}{n} 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 (Δ\Delta+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 (Δ+1)(\Delta+1) 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 Δ\Delta) 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 (Δ+1)(\Delta+1)-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-11 model, we make use of hash functions with limited independence. These hash functions use cc-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 c4c\geq 4 be an even integer. Suppose Z1,Z2,,ZtZ_{1},Z_{2},\ldots,Z_{t} are cc-wise independent random variables taking values in [0,1][0,1]. Let Z=i=1tZiZ=\sum_{i=1}^{t}Z_{i} and μ=𝔼[Z]\mu=\mathbb{E}[Z], and let λ>0\lambda>0. Then,

Pr[|Zμ|λ]2(ctλ2)c/2.Pr[|Z-\mu|\geq\lambda]\leq 2\left(\frac{ct}{\lambda^{2}}\right)^{c/2}.
Lemma A.2.

Suppose that XX is the summation of nn, cc-wise independent 0-1 random variables, each with mean pp. Let μ\mu satisfy μ𝔼[X]=np\mu\geq\mathbb{E}[X]=np. Then,

Pr[X(1+δ)μ]exp(min{c,δ2μ}).\text{Pr}[X\geq(1+\delta)\mu]\leq exp(-\min\{c,\delta^{2}\mu\}).

The following is Definition 7 in (Czumaj et al., 2020).

Definition A.3.

For NN, LL, cc\in\mathbb{N}, such that cNc\leq N, a family of functions ={h:[N][L]}\mathcal{H}=\{h:[N]\to[L]\} is cc-wise independent if for all distinct x1,x2,,xc[N]x_{1},x_{2},\ldots,x_{c}\in[N], the random variables h(x1),h(x2),,h(xc)h(x_{1}),h(x_{2}),\ldots,h(x_{c}) are independent and uniformly distributed in [L][L] when hh is chosen uniformly at random from HH.

The following lemma appears as Corollary 3.34 in (Vadhan, 2012).

Lemma A.4.

For every a,b,ca,b,c, there is a family of cc-wise independent hash functions ={h:{0,1}a{0,1}b}\mathcal{H}=\{h:\{0,1\}^{a}\to\{0,1\}^{b}\} such that choosing a random function from \mathcal{H} takes cmax{a,b}c\cdot\max\{a,b\} random bits, and evaluating a function from \mathcal{H} takes poly(a,b,c)\text{poly}(a,b,c) computation.

A.2. Simulating synchronous algorithms in an asynchronous model

Theorem A.5 (Awerbuch’s α\alpha-synchronizer (Awerbuch, 1985)).

Given a synchronous Algorithm AA running in TT rounds on a graph with mm edges in the KT-ρ\rho Congest model for any ρ1\rho\geq 1, it is possible to simulate AA in the asynchronous KT-ρ\rho Congest model in TT rounds. The number of additional messages sent in the asynchronous execution compared to an execution of AA is at most 2(T+1)m2(T+1)m.