Smaller Cuts, Higher Lower Bounds

TL;DR

This paper introduces the bit-gadget technique for constructing sparse graphs with small cuts, enabling strong lower bounds in distributed computing for various problems, including diameter, vertex cover, and coloring.

Contribution

It develops new sparse graph constructions with small cuts to establish near-linear and super-linear lower bounds in the CONGEST model, improving previous results especially for dense graphs.

Findings

Near-quadratic lower bounds for vertex cover and independent set

Optimal lower bounds for graph coloring and diameter approximation

Translation of CONGEST lower bounds to the semi-streaming model

Abstract

This paper proves strong lower bounds for distributed computing in the CONGEST model, by presenting the bit-gadget: a new technique for constructing graphs with small cuts. The contribution of bit-gadgets is twofold. First, developing careful sparse graph constructions with small cuts extends known techniques to show a near-linear lower bound for computing the diameter, a result previously known only for dense graphs. Moreover, the sparseness of the construction plays a crucial role in applying it to approximations of various distance computation problems, drastically improving over what can be obtained when using dense graphs. Second, small cuts are essential for proving super-linear lower bounds, none of which were known prior to this work. In fact, they allow us to show near-quadratic lower bounds for several problems, such as exact minimum vertex cover or maximum independent set, as well as for coloring a graph with its chromatic number. Such strong lower bounds are not limited to NP-hard problems, as given by two simple graph problems in P which are shown to require a quadratic and near-quadratic number of rounds. All of the above are optimal up to logarithmic factors. In addition, in this context, the complexity of the all-pairs-shortest-paths problem is discussed. Finally, it is shown that graph constructions for CONGEST lower bounds translate to lower bounds for the semi-streaming model, despite being very different in its nature.

Equations

$$U:=$$

$$\cup \mathrm{bin}(a_1^i)\cup \mathrm{bin}(a_2^j)\cup \mathrm{bin}(b_1^i)\cup \mathrm{bin}(b_2^j)$$

Full text

1. 1 Introduction

2. 1.1 Contributions

3. 1.1.1 Distance Computation

4. 1.1.2 Near-Quadratic Lower Bounds

5. 1.1.3 All Pairs Shortest Paths

6. 1.1.4 Streaming Algorithms

7. 1.2 Additional Related Work

8. 2 Preliminaries

9. 2.1 Computational Models

10. 2.2 Graph Parameters

11. 2.3 Communication Complexity

12. 2.4 Lower Bound Graphs

13. 3 The Bit-Gadget Construction

14. 4 Near-Linear Lower Bounds for Sparse Graphs

15. 4.1 Exact Diameter

16. 4.2 $(3/2-\varepsilon)$-Approximation of the Diameter

17. 4.3 Radius

18. 5 Near-Quadratic Lower Bounds for General Graphs

19. 5.1 Minimum Vertex Cover

20. 5.2 Graph Coloring

21. 6 Quadratic and Near-Quadratic Lower Bounds for Problems in P

22. 6.1 Weighted Cycle Detection

23. 6.2 Identical Subgraphs Detection

24. 7 Weighted APSP

25. 7.1 A Linear Lower Bound for Weighted APSP

26. 7.2 The Alice-Bob Framework Cannot Give a Super-Linear Lower Bound for Weighted APSP

27. 8 Streaming Lower Bounds

28. 9 Discussion

1 Introduction

This paper studies inherent limitations of distributed graph algorithms with bounded bandwidth, and shows new and strong lower bounds for some classical graph problems. A fundamental computational model for distributed networks is the congest model [82], where the network graph represents $n$ nodes that communicate in synchronous rounds in which $O(\log n)$-bit messages are exchanged among neighbors.

Many lower bounds for the congest model rely on reductions from two-party communication problems (see, e.g., [47, 58, 78, 84, 89, 38, 40, 79, 27]). In this setting, two players, Alice and Bob, are given inputs of $K$ bits and need to compute a single output bit according to some predefined function of their inputs.

The standard framework for reducing a two-party communication problem of computing a function $f$ to deciding a graph predicate $P$ in the congest model is as follows. Given an instance $(x,y)$ of the two-party problem $f$, a graph is constructed such that the value of $P$ on it can be used to determine the value of $f$ on $(x,y)$. Some of the graph edges are fixed, while the existence of some other edges depends on the inputs of Alice and Bob. Then, given an algorithm $ALG$ for solving $P$ in the congest model, the vertices of the graph are split into two sets, $V_{A}$ and $V_{B}$, and Alice simulates $ALG$ over $V_{A}$ while Bob simulates $ALG$ over $V_{B}$. The only communication required between Alice and Bob in order to carry out this simulation is the content of messages sent in each direction over the edges of the cut $C=E(V_{A},V_{B})$. Using this technique for a two-party problem $f$ on $K$ bits with communication complexity $\operatorname{CC}(f,K)$ and a graph with a cut $C$, it can be proven that the complexity of $ALG$ is in $\Omega(\operatorname{CC}(f,K)/|C|\log{n})$.111In this paper, and in many others, the nodes are partitioned into disjoint sets, and this partition remains fixed over time. We remark that in earlier work, the partition of the graph nodes between Alice and Bob is not fixed, and their nodes are not disjoint: there are many nodes they both simulate, and in each round each player simulates less nodes. This technique requires a more involved analysis, and we do not discuss it further.

Thus, the lower bound achieved using the reduction depends on two parameters of the graph construction: (i) the size of the input, $K$, and (ii) the size of the cut, $|C|$. All previously known constructions are both dense and have large cuts, which causes them to suffer from two limitations.

The first limitation is that lower bounds for global approximation tasks, such as approximating the diameter of the graph, which are typically obtained through stretching edges in the construction into paths by adding new nodes, must pay a significant decrease in the size of the input compared to the number of nodes because of their density. Together with their large cuts, this causes such lower bounds to stay well below linear. For example, the graph construction for the lower bound for computing the diameter [47] has $K=\Theta(n^{2})$ and $|C|=\Theta(n)$, which gives an almost linear lower bound of $\Omega(n/\log n)$ using the set-disjointness problem whose communication complexity is known to be $\Theta(K)$ [68]. However, because the construction is dense, although the resulting graph construction for computing a ($3/2-\epsilon$)-approximation of the diameter [47] has a smaller cut of $|C|=\Theta(\sqrt{n})$, this comes at the price of supporting a smaller input size, of $K=\Theta(n)$, which gives a lower bound that is roughly a square-root of $n$.

The second limitation is that large, say, linear cuts can inherently provide only linear lower bounds at best. However, tasks such as computing an exact minimum vertex cover seem to be much harder for the congest model, despite the inability of previous constructions to prove this.

In this paper, we present the bit-gadget technique for constructing graphs with small cuts that allow obtaining strong lower bounds for the congest model. Bit-gadgets are inspired by constructions that are used for proving conditional lower bounds for the sequential setting [88, 31, 2, 3, 26], whose power is in allowing a logarithmic-size cut. Our constructions allow bringing lower bounds for approximate diameter and radius up to a near-optimal near-linear complexity. Furthermore, they allow us to obtain the first near-quadratic lower bounds for natural graph problems, such as computing a minimum vertex cover or a coloring with a minimal number of colors. These are near-optimal since all of these problems admit simple $O(m)$ solutions in the congest model. Notably, these are the first super-linear lower bounds for this model.

In addition, this paper discusses the complexity of the weighted all-pairs-shortest-paths problem. This is one of the most-studied problems in the congest model, yet its complexity remains elusive. This problem was known to have at least almost-linear complexity; we improve this by presenting a linear lower bound, and also prove that the Alice-Bob technique discussed cannot achieve a super-linear lower bound for the problem.

Finally, we show that graph constructions for lower bounds for the congest model can be used directly to obtain lower bounds for the streaming model of computation in a black-box manner, and so we prove the lower bounds for problems such as computing a minimum vertex cover or a coloring with minimal number of colors. This is an artifact of usage of communication complexity problems with large input size in our lower bound constructions.

1.1 Contributions

1.1.1 Distance Computation

Frischknecht et al. [47] showed that the diameter is surprisingly hard to compute: $\widetilde{\Omega}(n)$ rounds are needed even in networks with constant diameter222The notations $\widetilde{\Omega}$ and $\widetilde{O}$ hide factors that are polylogarithmic in $n$. . This lower bound is nearly tight, due to an $O(n)$ upper bound [83, 58, 70]. Naturally, approximate solutions are a desired relaxation, and were indeed addressed in several cornerstone studies [56, 83, 58, 70, 47], bringing us even closer to a satisfactory understanding of the time complexity of computing the diameter in the congest model. Here we answer several central questions that remained elusive.

Sparse Graphs.

The graphs constructed by Frischknecht et al. [47] have $\Theta(n^{2})$ edges and constant diameter, and require any distributed algorithm for computing their diameter to spend $\widetilde{\Omega}(n)$ rounds. Almost all large networks of practical interest are very sparse [72], e.g., the Internet in 2012 had roughly $4$ billion nodes and $128$ billion edges [75]. The only known lower bound for computing the diameter of a sparse network is obtained by a simple modification to the construction of [47] which yields a much weaker bound of $\widetilde{\Omega}(\sqrt{n})$. Our first result is to rule out the possibility that the $\widetilde{\Omega}(n)$ bound can be beaten significantly in sparse networks.

Theorem 1**.**

Any algorithm for computing the exact diameter, even of a network of $\Theta(n\log n)$ edges, requires $\Omega\left(\frac{n}{\log^{2}{n}}\right)$ rounds.

We remark that, as in [47], our lower bound holds even for networks with constant diameter and even against randomized algorithms. Due to simple transformations, e.g., adding dummy nodes, our lower bound for computing the diameter also holds for the more strict definition of sparse graphs as having $O(n)$ edges, up to a loss of a log factor.

Approximation Algorithms.

An important question is whether one can bypass this near-linear barrier by settling for an approximation to the diameter. An $\alpha$-approximation algorithm to the diameter returns a value $\hat{D}$ such that $D\leq\hat{D}\leq\alpha\cdot D$, where $D$ is the true diameter of the network. From [47] we know that $\widetilde{\Omega}(\sqrt{n}+D)$ rounds are needed, even for computing a $(3/2-\varepsilon)$-approximation to the diameter, for any constant $\varepsilon>0$, while from [56] we know that a $3/2$-approximation can be computed in $O(\sqrt{n\log{n}}+D)$ rounds. This raises the question of whether there is a sharp threshold at a $3/2$-approximation factor, or whether a $(3/2-\epsilon)$-approximation can also be obtained in a sub-linear number of rounds.

Progress towards answering this question was made by Holzer and Wattenhofer [58] who showed that any algorithm that needs to decide whether the diameter is $2$ or $3$ has to spend $\widetilde{\Omega}(n)$ rounds. However, as the authors point out, their lower bound is not robust and does not rule out the possibility of a $(3/2-\varepsilon)$-approximation when the diameter is larger than $2$, or an algorithm that is allowed an additive $+1$ error in addition to a multiplicative $(3/2-\varepsilon)$ error.

As mentioned earlier, perhaps the main difficulty in extending the lower bound constructions of Frischknecht et al. [47] and Holzer and Wattenhofer [58] in order to resolve these gaps was that their original graphs are dense. A natural way to go from a lower bound construction for exact algorithms to a lower bound for approximations is to subdivide each edge into a path; however, in dense graphs this dramatically blows up the number of nodes, resulting in much weaker bounds. The sparseness of our new construction allows us to tighten the bounds and negatively resolve the above question: we show a $\widetilde{\Omega}(n)$ lower bound for computing a ($3/2-\varepsilon$)-approximation to the diameter, even if a constant additive approximation factor is also allowed.

Theorem 2**.**

For any constant $0<\varepsilon<1/2$, any algorithm for computing a $(3/2-\varepsilon)$-approximation of the diameter, even of a network of $\Theta(n\log n)$ edges, requires $\Omega\left(\frac{n}{\log^{3}{n}}\right)$ rounds.

Radius.

In many scenarios we want one special node to be able to efficiently send information to all other nodes. In this case, we would like this node to be the one that is closest to every other node, i.e., the center of the graph. The radius of the graph is the largest distance from the center, and it captures the number of rounds needed for the center node to transfer a message to all another node in the network. While radius and diameter are closely related, the previous lower bounds for diameter do not transfer to radius and it was conceivable that the radius of the graph could be computed much faster. Obtaining a non-trivial lower bound for radius is stated as an open problem in [58]. Another advantage of our technique is that it extends to computing the radius, for which we show that the same strong near-linear barriers above hold.

Theorem 3**.**

Any algorithm for computing the radius, even of a network of $\Theta(n\log n)$ edges, requires $\Omega\left(\frac{n}{\log^{2}{n}}\right)$ rounds.

Our techniques can also be used for proving lower bounds for approximating the network’s radius, computing its eccentricity, and for verifying that a given subgraph is a spanner, even on sparse networks with a constant degree. The interested reader can find the details in [1].

1.1.2 Near-Quadratic Lower Bounds

High lower bounds for the congest model can be obtained rather artificially, by forcing large inputs and outputs that must be exchanged, e.g., by having large edge weights, or by requiring a node to output its $t$-neighborhood for some value of $t$. However, until this work no super-linear lower bound for a natural problem was known, let alone near-quadratic bound. We remedy this state of affairs by showing quadratic and near-quadratic lower bound for several natural decision problems on graphs, where each input can be represented by $O(\log n)$ bits, and each output value consists of a single bit, or $O(\log n)$ bits. Specifically, using the bit-gadget we obtain graph constructions with small cuts that lead to the following lower bounds.

Theorem 4**.**

Any algorithm for computing a minimum vertex cover of the network or deciding whether there is a vertex cover of a given size requires $\Omega(n^{2}/\log^{2}n)$ rounds.

This directly applies also to computing an exact maximum independent set, as the latter is the complement of an exact minimum vertex cover. This lower bound is in stark contrast to the recent $O(\log\Delta/\log\log\Delta)$-round algorithm of [11] for obtaining a $(2+\epsilon)$-approximation to the minimum vertex cover.

An additional lower bound that we obtain using the bit-gadget is for coloring, as follows.

Theorem 5**.**

Any algorithm for coloring a $\chi$-colorable network in $\chi$ colors, or for deciding if it is $c$-colorable for a given $c$, requires $\Omega(n^{2}/\log^{2}n)$ rounds.

We further show that certain approximations of $\chi$ are hard, though we believe that such a lower bound should hold for even looser approximations. All these lower bounds hold even for randomized algorithms which succeed with high probability.333An event occurs with high probability (w.h.p) if it occurs with probability $\frac{1}{n^{c}}$, for some constant $c>0$.

We then show that not only NP-hard problems are near-quadratically hard in the congest model, by showing two simple problems that admit polynomial-time sequential algorithms, but require quadratic or near-quadratic time in the congest model. The weighted cycle detection problem requires $\Omega(n^{2}/\log{n})$ rounds, even when using randomized algorithms. The identical subgraph detection problem requires $\Omega(n^{2})$ rounds deterministically, while we present a randomized algorithm for it that completes in only $O(D)$ rounds, providing the strongest possible separation between deterministic and randomized complexities for global problems in the congest model. A slight variant of this problem gives even stronger separation, for general problems: we prove an $\Omega(n^{2})$ rounds lower bound for it, and give a constant-time randomized algorithm.

1.1.3 All Pairs Shortest Paths

An intriguing question in the congest model is the complexity of computing exact weighted all-pairs-shortest-paths (APSP). The complexity of unweighted APSP is known to be $\Theta(n/\log{n})$ [47, 59], both for deterministic and randomized algorithms. Several recent works study the complexity of computing weighted APSP [42, 60, 21, 6, 5], and the most recent results are a randomized $\tilde{O}(n)$-round algorithm [21], and a deterministic $\tilde{O}(n^{3/2})$-round algorithm [6].

We provide an extremely simple linear lower bound of $\Omega(n)$ rounds for weighted APSP, extending a construction of Nanongkai [78], which separates its complexity from that of the unweighted case. Moreover, we formally prove that the commonly used framework of reducing a two-party communication problem to a problem in the congest model cannot provide a super-linear lower bound for weighted APSP, regardless of the function and the graph construction used. We then extend this claim for $t$-party communication complexity with a shared blackboard. For the randomized case, this is not surprising in light of the recent randomized $\tilde{O}(n)$ algorithm [21]; however, it shows that closing the gap for the deterministic case might require a new technique, unless the true complexity will turn out to be $O(n)$.

1.1.4 Streaming Algorithms

The semi-streaming model of computation [44] is an important model for processing massive graphs. Here, a single processing unit with a bounded amount of memory obtains information of the graph edges one-by-one and is required to process them and return an output based on the graph properties Usually, the memory is assumed to be of $O(n\operatorname{poly}\log n)$ bits for an $n$-node graph, and the number of allowed passes over the edges is one, constant, or logarithmic in $n$.

In the standard model, called the edge arrival model, the order of the edges is adversarial. in the node arrival model, the adversary is restricted in that edges must arrive grouped by nodes—all the edges connecting a node to the previous nodes arrive together; in the adjacency streaming model, all the edges adjacent a node arrive together, regardless of the previous nodes. For simplicity, we prove our bounds for the edge arrival model, but it is immediate to check that they also apply to the edge arrival and the adjacency streaming models.

We prove that constructions for lower bounds for the congest model translate directly to give lower bounds for the semi-streaming model, and, with the standard parameters, impossibility results. Specifically, for the problems for which we obtain near-quadratic lower bounds in the congest model, we establish that the product of the memory size and the number of passes in the streaming model must be quadratic in $n$.

The mentioned lower bound applies to vertex cover, maximum independent set, coloring and other problem in the semi-streaming model. Our construction for maximum independent set also easily translates to give the same lower bound for the maximum clique problem. Some bounds close to ours are known in the literature, as discussed next, but our work has several advantages: we give a unified framework, using simple lower bound graphs and simple communication complexity problems, and these bounds are robust to multiple-pass algorithms and to variants of the model.

For vertex cover, there is a known lower bound of $\Omega(k^{2})$ for deciding the existence of a cover of size $k$ in one pass, and an algorithm for the problem using $\tilde{O}(k^{2})$ memory [33]. Our work matches the lower bound for one-pass, and extends it to multiple-pass algorithms. The maximum independent set and maximum clique problems were also previously studied [50, 36, 24, 50]; the known lower bounds also apply to these problems with a gap promise, so our construction is weaker in that sense. On the other hand, we improve upon the best results for maximum independent set [50] in a poly-logarithmic factor and in the simplicity of our construction, and on the results for maximum clique [24] in that we handle multiple-pass algorithms.

Note that the bounds we present are not only for problems with a linear output size, such as finding a maximum independent set or a coloring, but even for decision and computation problems, e.g., computing the size of a maximum independent set or approximating the chromatic number. For these problems, it is not even trivial that a linear memory is necessary.

Roadmap

In the following section we describe additional related work about the problems discussed in this paper. Section 2 contains our preliminaries. In Section 3 we define the bit gadget and discuss some of its properties. Sections 4, 5, and 6 contains our near-linear lower bounds, near-quadratic lower bounds for NP hard problems, and near-quadratic lower bounds for problems in P, respectively. Section 7 contains our results for computing APSP. Finally, in Section 8, we show how our results imply new lower bounds for the streaming model.

1.2 Additional Related Work

Vertex Coloring, Minimum Vertex Cover, and Maximum Independent Set: One of the most central problems in graph theory is vertex coloring, which has been extensively studied in the context of distributed computing (see, e.g., [18, 14, 15, 16, 17, 73, 43, 45, 46, 53, 76, 90, 85, 34, 29, 35, 13] and references therein). The special case of finding a $(\Delta+1)$-coloring, where $\Delta$ is the maximum degree of a node in the network, has been the focus of many of these studies, but is a local problem, and can be solved in much less than linear number of rounds. Much less attention was given to the problem of distributively coloring a graph with the minimal number of colors possible: Linial [73] discusses this problem for rings, and coloring planar graphs in less than $\delta+1$ rounds also received increased attention lately [4, 32]. However, all these works focus on the local model and on specific graph topologies, and we are unaware of any study of $\chi$-coloring on the congest model, or of general graph topologies.

Our paper suggests a reason for this state of affairs: coloring with a minimal number of colors requires studying almost all the graph edges, so it is very likely that no nontrivial algorithms for this problem exist.

Another classical problem in graph theory is finding a minimum vertex cover (MVC). In distributed computing, the time complexity of approximating MVC has been addressed in several cornerstone studies [8, 11, 9, 48, 49, 64, 65, 67, 86, 18, 52, 80, 66].

Finding a minimum size vertex cover is equivalent to finding a maximum size independent set, as mentioned earlier, but note that this equivalence is not approximation preserving. Distributed approximation algorithms for maximum independent set were studied in [71, 37, 22, 10]. Finally, finding a maximum independent set and finding maximum clique are equivalent in sequential execution, but not in distributed or streaming settings. Nevertheless, our lower bounds for maximum independent set in the streaming model do translate to lower bounds for maximum clique.

Distance Computation: It is known that a $3/2$-approximation for the diameter can be computed in a sublinear number of rounds: both $O(n^{3/4}+D)$-round algorithm [58] and an (incomparable) $O(D\sqrt{n}\log{n})$ bound algorithm [83] are known. These bounds were later improved [70] to $O(\sqrt{n}\log{n}+D)$, and finally [56] reduce to $O(\sqrt{n\log{n}}+D)$.

Additional distance computation problems have been widely studied in the congest model for both weighted and unweighted networks [1, 47, 58, 56, 83, 57, 69, 70, 78, 59, 54]. One of the most fundamental problems of distance computation is computing all pairs shortest paths. For unweighted networks, an upper bound of $O(n/\log n)$ was recently shown [59], matching an earlier lower bound [47]. Moreover, the possibility of bypassing this near-linear barrier for any constant approximation factor was ruled out [78]. For weighted randomized APSP, an $\tilde{O}(n^{5/3})$-round algorithm was shown [42], improved by an $\tilde{O}(n^{5/4})$-round algorithm [60], and finally by an $\tilde{O}(n)$-round algorithm [21]. For the deterministic case, an $\widetilde{O}(n^{3/2})$-round algorithm was recently presented [6, 5].

Streaming Algorithms: Streaming algorithms [55, 77] are a way process massive information streams that cannot fit into the memory of a single machine. In this paper we focus on streaming algorithms for graph problems, and mainly on the semi-streaming algorithms [44], where the memory is assume to be in $\Theta(n\operatorname{poly}\log n)$.

Some problems solvable in the semi-streaming model include deciding connectivity and bipartiteness, building a minimum spanning tree, finding a 2-approximate maximum cardinality matching (all discussed in [44]), $(1+\epsilon)(\Delta+1)$-coloring [20], finding a $(2+\epsilon)$-approximate maximum weight matching [81], building cut sparsifiers [7], spectral sparsifiers [63], spanners [19, 41], and counting subgraphs such as triangles [12], unweighted cycles [74], full bipartite graphs[25], and small graph minors [23].

On the lower bounds side, maximum matching cannot be approximated better than $e/(e-1)\approx 1.58$ factor [61] in the semi-streaming model. Deciding $(s,t)$-connectivity requires $\Omega(n)$ bits of memory, and $\Omega(n/R)$ bits if $R$ passes on the input are allowed, and so does computing the connected components, testing planarity and more (see [55]). Maximum cut approximation was studied both for upper and lower bounds [62]. The mentioned lower bounds are achieved using reductions to communication complexity problems, and we essentially follow their footsteps in term of techniques, while achieving new lower bounds for different problems.

The Caro-Wei bound is a degree-sequence based lower bound on the size of a maximum independent set in a graph. Finding an independent set matching this bound was studied in [50], and evaluating the value of the bound was recently studied in [36]; note that such a set might not be a maximum independent set. There is a variety of upper and lower bounds for the maximum independent set and maximum clique problems, under a gap assumption: either the graph contains a large independent set (clique), or only a very small one [24, 51].

2 Preliminaries

2.1 Computational Models

The congest model:

In the congest model [82], the nodes of an undirected connected graph $G=(V,E)$ of size $\left|V\right|=n$ communicate over the graph edges in synchronous rounds. In each round, each node can send messages of $O(\log n)$ bits to each of its neighbors. The complexity measure of a distributed algorithm in this model is the number of rounds the algorithm needs in order to complete. A weighted graph $G=(V,E,w)$ is a graph augmented with an edge weight function $w:E\to\left\{1,\ldots,W\right\}$. We assume that the maximum edge weight $W$ is polynomial in $n$, and thus an edge weight, or a sum of $O(n)$ edge weights, can be sent in a single message.

Each node is assumed to have a unique id in $\left\{1,\ldots,n\right\}$. At the beginning of an execution of an algorithm, each node knows its own id and, if the graph is weighted, also the weights of the edges adjacent to it. If the algorithm computes a graph parameter, it terminates when all nodes know the value of this parameter. If it outputs a labeling (e.g., a coloring or an indication of membership in a set) then each node should know its label.

The semi-streaming model:

In the semi-streaming model [44], a single computational unit executes a centralized algorithm in order to process a large graph. The graph nodes are given in advance to the algorithm, and the edges are read one-by-one (with their weights), in an adversarial order. The algorithm is allowed to keep only $M$ bits of memory, where usually $M=O(n\operatorname{poly}\log n)$, and to make only $R$ passes over the input edges, where usually $R=O(1)$ or $R=O(\log n)$.

2.2 Graph Parameters

We are interested in several classical graph problems. The distance between two nodes $u,v$ in the graph, denoted $\operatorname{d}(u,v)$, is the minimum number of hops in a path between them in an unweighted graph, or the minimum weight of a path between them in a weighted graph. The diameter $D$ of the graph is the maximum distance between two nodes in it. The eccentricity of a node $u$ is $e(u)=\max_{v}\left\{\operatorname{d}(u,v)\right\}$, and the radius of the graph is $\min_{u}\left\{e(u)\right\}$. For a given integer $i$, an $i$-path in $G$ is a simple path of $i$ hops.

A vertex cover of a graph is a set $U\subseteq V$ such that for each edge $e\in E$ we have $e\cap U\neq\emptyset$. A minimum vertex cover is a vertex cover of minimum cardinality. An independent set is a set $U\subseteq V$ for which $u,v\in U\implies(u,v)\notin E$, and a clique is a set $U\subseteq V$ for which $u,v\in U\implies(u,v)\in E$. A maximum independent set is an independent set of maximum cardinality, and a maximum clique is a clique of maximum cardinality. A (proper) $c$-coloring of a graph is a function $f:V\to\left\{1,\ldots,c\right\}$ such that $(u,v)\in E\implies f(u)\neq f(v)$. The chromatic number $\chi$ of a graph is the minimum $c$ such that a $c$-coloring of the graph exists.

2.3 Communication Complexity

In the two-party communication setting [91, 68], two players, Alice and Bob, are given two input strings, $x,y\in\left\{0,1\right\}^{K}$, respectively, and need to jointly compute a function $f:\left\{0,1\right\}^{K}\times\left\{0,1\right\}^{K}\to\left\{\operatorname{{\scriptstyle{TRUE}}},\operatorname{{\scriptstyle{FALSE}}}\right\}$ on their inputs. The communication complexity of a protocol $\pi$ for computing $f$, denoted $\operatorname{CC}(\pi)$, is the maximal number of bits Alice and Bob exchange in $\pi$, taken over all values of the pair $(x,y)$. The deterministic communication complexity of $f$, denoted $\operatorname{CC}(f)$, is the minimum over $\operatorname{CC}(\pi)$, taken over all deterministic protocols $\pi$ that compute $f$.

In a randomized protocol $\pi$, Alice and Bob may each use a random bit string. A randomized protocol $\pi$ computes $f$ if the probability, over all possible bit strings, that $\pi$ outputs $f(x,y)$ is at least $2/3$. The randomized communication complexity of $f$, $\operatorname{CC}^{R}(f)$, is the minimum over $\operatorname{CC}(\pi)$, taken over all randomized protocols $\pi$ that compute $f$.

For a vector $x$, let $x[i]$ be the $i$-th bit in the string $x$. In the set-disjointness problem ($\mathrm{DISJ}_{K}$), the function $f$ is $\mathrm{DISJ}_{K}(x,y)$, whose value is $\operatorname{{\scriptstyle{FALSE}}}$ if there is an index $i\in\left\{0,\ldots,K-1\right\}$ such that $x[i]=y[i]=1$, and $\operatorname{{\scriptstyle{TRUE}}}$ otherwise. We say that $x$ and $y$ are disjoint if $\mathrm{DISJ}_{K}(x,y)=\operatorname{{\scriptstyle{TRUE}}}$, and not disjoint otherwise. In the Equality problem ($\mathrm{EQ}_{K}$), the function $f$ is $\mathrm{EQ}_{K}(x,y)$, whose output is $\operatorname{{\scriptstyle{TRUE}}}$ if $x=y$, and $\operatorname{{\scriptstyle{FALSE}}}$ otherwise. When $K$ is clear from the context, or is determined in a later stage, we omit it from the notation.

Both the deterministic and randomized communication complexities of the $\mathrm{DISJ}_{K}$ problem are known to be $\Omega(K)$ [68, Example 3.22]. The deterministic communication complexity of $\mathrm{EQ}_{K}$ is in $\Omega(K)$ [68, Example 1.21], while its randomized communication complexity is in $\Theta(\log K)$ [87] (see also [68, Example 3.9]).

Remark: For some of our constructions which use the $\mathrm{DISJ}$ function, we need to exclude the all-[math] or all-$1$ input vectors, in order to guarantee that the graphs are connected, as otherwise proving impossibility is trivial. However, this restriction does not change the asymptotic bounds for $\mathrm{DISJ}$, since computing this function while excluding, e.g. the all-$1$ input vector, can be reduced to computing this function for inputs that are shorter by one bit (by having the last bit fixed to [math] or to $1$).

2.4 Lower Bound Graphs

To prove lower bounds on the number of rounds necessary in order to solve a distributed problem in the congest model, we use reductions from two-party communication complexity problems. The reductions are defined as follows.

Definition 1**.**

*(Family of Lower Bound Graphs)

Fix an integer $K$, a function $f:\left\{0,1\right\}^{K}\times\left\{0,1\right\}^{K}\to\left\{\operatorname{{\scriptstyle{TRUE}}},\operatorname{{\scriptstyle{FALSE}}}\right\}$ and a graph predicate $P$. A family of graphs $\left\{G_{x,y}=(V,E_{x,y})\mid x,y\in\left\{0,1\right\}^{K}\right\}$ with a partition $V=V_{A}\dot{\cup}V_{B}$ is said to be a family of lower bound graphs for the congest model w.r.t. $f$ and $P$ if the following properties hold:*

Only the existence or the weight of edges in $V_{A}\times V_{A}$ may depend on $x$; 2. 2.

Only the existence or the weight of edges in $V_{B}\times V_{B}$ may depend on $y$; 3. 3.

$G_{x,y}$* satisfies the predicate $P$ iff $f(x,y)=\operatorname{{\scriptstyle{TRUE}}}$.*

We use the following theorem, which is standard in the context of communication complexity-based lower bounds for the congest model (see, e.g. [1, 47, 38, 57]). Its proof is by a standard simulation argument.

Theorem 6**.**

Fix a function $f:\left\{0,1\right\}^{K}\times\left\{0,1\right\}^{K}\to\left\{\operatorname{{\scriptstyle{TRUE}}},\operatorname{{\scriptstyle{FALSE}}}\right\}$ and a predicate $P$. If there is a family $\{G_{x,y}\}$ of lower bound graphs for the congest model w.r.t. $f$ and $P$ with $C=E(V_{A},V_{B})$ then any deterministic algorithm for deciding $P$ in the congest model requires $\Omega(\operatorname{CC}(f)/\left|C\right|\log n)$ rounds, and any randomized algorithm for deciding $P$ in the congest model requires $\Omega(\operatorname{CC}^{R}(f)/\left|C\right|\log n)$ rounds.

Proof.

Let $ALG$ be a distributed algorithm in the congest model that decides $P$ in $T$ rounds. Given inputs $x,y\in\left\{0,1\right\}^{K}$ to Alice and Bob, respectively, Alice constructs the part of $G_{x,y}$ for the nodes in $V_{A}$ and Bob does so for the nodes in $V_{B}$. This can be done by items 1 and 2 in Definition 1, and since $V_{A}$ and $V_{B}$ are disjoint. Alice and Bob simulate $ALG$ by exchanging the messages that are sent during the algorithm between nodes of $V_{A}$ and nodes of $V_{B}$ in either direction, while the messages within each set of nodes are simulated locally by the corresponding player without any communication. Since item 3 in Definition 1 also holds, we have that Alice and Bob correctly output $f(x,y)$ based on the output of $ALG$. For each edge in the cut, Alice and Bob exchange $O(\log{n})$ bits per round. Since there are $T$ rounds and $\left|C\right|$ edges in the cut, the number of bits exchanged in this protocol for computing $f$ is $O(T\left|C\right|\log{n})$. The lower bounds for $T$ now follows directly from the lower bounds for $\operatorname{CC}(f)$ and $\operatorname{CC}^{R}(f)$, where in the randomized case we note that an algorithm that succeeds w.h.p. definitely succeeds with probability at least $2/3$. ∎

In what follows, for each decision problem addressed, we describe a fixed graph construction $G=(V,E)$ with a partition $V=V_{A}\dot{\cup}V_{B}$, which we then generalize to a family of graphs $\left\{G_{x,y}=(V,E_{x,y})\mid x,y\in\left\{0,1\right\}^{K}\right\}$. We then show that $\left\{G_{x,y}\right\}$ is a family lower bound graphs w.r.t. to some communication complexity problem $f$ and the required predicate $P$. By Theorem 6 and the known lower bounds for the two-party communication problem $f$, we deduce a lower bound for any algorithm for deciding $P$ in the congest model.

We use $n$ for the number of nodes, $K$ for the size of the input strings, and a third parameter $k$ as an auxiliary parameter, usually for the size of the node-set that touches the edges that depend on the input. The number of nodes $n$ determines $k$ and $K$, and we usually only show the asymptotic relation between the three parameters and leave the exact values implicit.

3 The Bit-Gadget Construction

The main technical novelty in our lower bounds comes from the ability to encode large communication complexity problems in graphs with small cuts. To this end, we use the following construction (see Figure 1).

Fix an integer $k$ which is a power of $2$, and start with two sets of nodes $k$ nodes each, $A=\{a^{i}\mid i\in\left\{0,\ldots,k-1\right\}\}$ and $B=\{b^{i}\mid i\in\left\{0,\ldots,k-1\right\}\}$. For each set $S\in\left\{A,B\right\}$, add two corresponding sets of $\log k$ nodes each, denoted $F_{S}=\{f^{h}_{S}\mid h\in\left\{0\ldots,\log k-1\right\}\}$ and $T_{S}=\{t^{h}_{S}\mid h\in\left\{0,\ldots,\log k-1\right\}\}$. The latter are called the bit-nodes and they constitute the bit-gadget. Connect the nodes of each set $S\in\left\{A,B\right\}$ to their corresponding bit-nodes according to their indices, as follows. Let $s^{i}$ be a node in a set $S\in\{A,B\}$, i.e., $s\in\left\{a,b\right\}$ and $i\in\left\{0,\ldots,k-1\right\}$, and let $i_{h}$ denote the $h$-th bit in the binary representation of $i$. For such $s^{i}$, define $\operatorname{bin}(s^{i})=\left\{f_{S}^{h}\mid i_{h}=0\right\}\cup\left\{t_{S}^{h}\mid i_{h}=1\right\}$, and connect $s^{i}$ by an edge to each of the nodes in $\operatorname{bin}(s^{i})$. Finally, connect the bit-nodes: for each $h\in\left\{0,\ldots,\log k-1\right\}$ connect $f_{A}^{h}$ to $t_{B}^{h}$ and $t_{A}^{h}$ to $f_{B}^{h}$. Set $V_{A}=A\cup F_{A}\cup T_{A}$ and $V_{B}=V\setminus V_{A}$.

In the next sections, we augment the above construction with fixed nodes and edges, and then add some more edges according to the input strings, in order to create a family of graphs with some desired properties. The next claim exemplifies one of the basic properties of this construction.

Claim 1**.**

For every $i,j\in\left\{0,\ldots,k-1\right\}$, if $i\neq j$ then $\operatorname{d}(a^{i},b^{j})\leq 3$.

Proof.

Since $i\neq j$, there is $h\in\left\{0,\ldots,\log k-1\right\}$ such that $i_{h}\neq j_{h}$. If $i_{h}=1$ and $j_{h}=0$, then the $3$-path $(a^{i},t_{A}^{h},f_{B}^{h},b^{j})$ connects the desired nodes; otherwise, $i_{h}=0$ and $j_{h}=1$, and the $3$-path $(a^{i},f_{A}^{h},t_{B}^{h},b^{j})$ connects the nodes. ∎

It is not hard to also show that $\operatorname{d}(a^{i},b^{j})\geq 3$ and that $\operatorname{d}(a^{i},b^{i})=5$, and we indeed prove similar claims in Section 4. In Section 5.1 we discuss the size and structure of a minimum vertex cover for this gadget.

4 Near-Linear Lower Bounds for Sparse Graphs

In this section we present our near-linear lower bounds for sparse networks. Sections 4.1 and 4.2 contain our lower bounds for computing the exact or approximate diameter, and Section 4.3 contains our lower bound for computing the radius.

4.1 Exact Diameter

Our goal in this section is to prove the following theorem.

• **Theorem 1 **

Any algorithm for computing the exact diameter, even of a network of $\Theta(n\log n)$ edges, requires $\Omega\left(\frac{n}{\log^{2}{n}}\right)$ rounds.

In order to prove Theorem 1, we describe a family of lower bound graphs with respect to the set-disjointness function and the predicate $P$ that says that the graph has diameter at least $5$. We start by describing the fixed graph construction and then define the family of lower bound graphs and analyze its relevant properties.

The fixed graph construction: Start with the graph $G$ and partition $(V_{A},V_{B})$ described in Section 3, and add two nodes $c_{A},\bar{c}_{A}$ to $V_{A}$, and another two nodes $c_{B},\bar{c}_{B}$ to $V_{B}$ (see Figure 2). For each set $S\in\left\{A,B\right\}$, connect all nodes in $S$ to the center $c_{S}$, all the bit-nodes $F_{S}\cup T_{S}$ to $\bar{c}_{S}$, and the two centers $c_{S},\bar{c}_{S}$ to one other. Finally, connect $\bar{c}_{A}$ to $\bar{c}_{B}$.

Adding edges corresponding to the strings $x$ and $y$: Given two binary strings $x,y\in\left\{0,1\right\}^{k}$, augment the graph defined above with additional edges, which defines $G_{x,y}$. For each $i\in\left\{0,\ldots,k-1\right\}$, if $x[i]=0$ then add an edge between the nodes $a^{i}$ and $\bar{c}_{A}$, and if $y[i]=0$ then add an edge between $b^{i}$ and $\bar{c}_{B}$.

Claim 2**.**

For every $u,v$ such that $(u,v)\notin(A\times B)\cup(B\times A)$, it holds that $\operatorname{d}(u,v)\leq 4$.

Proof.

Observe that every node in $V\setminus(A\cup B)$ is connected to $\bar{c}_{A}$ or to $\bar{c}_{B}$, and these two nodes are neighbors. Thus, the distance between every two nodes in $V\setminus(A\cup B)$ is at most $3$. The claim follows from this, and from the fact that any node in $A$ and any node in $B$ are connected to a node in $V\setminus(A\cup B)$. ∎

The following lemma is the main ingredient in proving that $\left\{G_{x,y}\right\}$ is a family of lower bound graphs.

Lemma 1**.**

The diameter of $G_{x,y}$ is at least 5 if and only if $x$ and $y$ are not disjoint.

Proof.

Assume that the sets are disjoint, i.e., for every $i\in\left\{0,\ldots,k-1\right\}$ either $x[i]=0$ or $y[i]=0$. We show that for every $u,v\in V$ it holds that $\operatorname{d}(u,v)\leq 4$. Consider the following cases:

$(u,v)\notin(A\times B)\cup(B\times A)$: By Claim 2, $\operatorname{d}(u,v)\leq 4$. 2. 2.

$u=a^{i}\in A$ and $v=b^{j}\in B$ (or vice versa) for $i\neq j$: Claim 1 implies $\operatorname{d}(u,v)\leq 3$. 3. 3.

$u=a^{i},v=b^{i}$ (or vice versa) for some $i$: By the assumption, either $x[i]=0$ or $y[i]=0$, and assume the former without loss of generality, implying that $a^{i}$ is connected by an edge to $\bar{c}_{A}$. Thus, the path $(a^{i},\bar{c}_{A},\bar{c}_{B},c_{B},b^{i})$ exists in the graph, and $\operatorname{d}(a^{i},b^{i})\leq 4$.

For the other direction, assume that the two sets are not disjoint, i.e., there is some $i\in\left\{0,\ldots,k-1\right\}$ for which $x[i]=y[i]=1$. In this case, $a^{i}$ is not connected by an edge to $\bar{c}_{A}$ and $b^{i}$ is not connected by an edge to $\bar{c}_{B}$. Note that $V_{A},V_{B}$ are disjoint, $a^{i}$ belongs to $V_{A}$ and $b^{i}$ to $V_{B}$, so any path between $a^{i}$ and $b^{i}$ must go through an edge connecting a node from $V_{A}$ and a node from $V_{B}$. Fix a shortest path from $a^{i}$ to $b^{i}$, and consider the following cases, distinguished by the first edge in the path crossing from $V_{A}$ to $V_{B}$:

The path uses the edge $(\bar{c}_{A},\bar{c}_{B})$: Since $a^{i}$ is not connected by an edge to $\bar{c}_{A}$, and $b^{i}$ is not connected to $\bar{c}_{B}$, we have $\operatorname{d}(a^{i},\bar{c}_{A})\geq 2$ and $\operatorname{d}(b^{i},\bar{c}_{B})\geq 2$, so the length of the path is at least 5. 2. 2.

The path uses an edge $(f_{A}^{h},t_{B}^{h})$ with $f_{A}^{h}\notin\operatorname{bin}(a^{i})$, or an edge $(t_{A}^{h},f_{B}^{h})$ with $t_{A}^{h}\notin\operatorname{bin}(a^{i})$: For the first case, note that $a^{i}$ and $t_{A}^{h}$ are not connected by an edge, and they do not even have a common neighbor. Thus, $\operatorname{d}(a^{i},t_{A}^{h})\geq 3$, and $\operatorname{d}(a^{i},b^{i})\geq 5$. The case of $(t_{A}^{h},f_{B}^{h})$ with $t_{A}^{h}\notin\operatorname{bin}(a^{i})$ is analogous. 3. 3.

The path uses an edge $(f_{A}^{h},t_{B}^{h})$ with $f_{A}^{h}\in\operatorname{bin}(a^{i})$, or an edge $(t_{A}^{h},f_{B}^{h})$ with $t_{A}^{h}\in\operatorname{bin}(a^{i})$: The definitions of $\operatorname{bin}(a^{i})$ and $\operatorname{bin}(b^{i})$ immediately imply $t_{B}^{h}\notin\operatorname{bin}(b^{i})$ for the first case, or $f_{B}^{h}\notin\operatorname{bin}(b^{i})$ for the second. The rest of the argument is the same as the previous: $\operatorname{d}(t_{B}^{h},b^{i})\geq 3$ or $\operatorname{d}(f_{B}^{h},b^{i})\geq 3$, both implying $\operatorname{d}(a^{i},b^{i})\geq 5$.

Thus, any path between $a^{i}$ and $b^{i}$ must have length at least $5$. ∎

Having constructed a family of lower bound graphs, we are now ready to prove Theorem 1.

• **Proof of Theorem 1: **

To complete the proof of Theorem 1, note that $n\in\Theta(k)$, and thus $K=|x|=|y|=\Theta(n)$. Furthermore, the only edges in the cut $E(V_{A},V_{B})$ are the edges between nodes in $F_{A}\cup T_{A}$ and nodes in $F_{B}\cup T_{B}$, and the edge $(\bar{c}_{A},\bar{c}_{B})$. Thus, in total, there are $\Theta(\log n)$ edges in the cut $E(V_{A},V_{B})$. Since Lemma 1 shows that $\{G_{x,y}\}$ is a family of lower bound graphs, we can apply Theorem 6 and deduce that any algorithm in the congest model for deciding whether a given graph has a diameter at least $5$ requires at least $\Omega(k/\log n)=\Omega(n/\log n)$ rounds. Finally, observe that the number of edges in the construction is $O(n\log n)$. ∎

4.2 $(3/2-\varepsilon)$-Approximation of the Diameter

In this section we show how to modify our sparse construction presented in the previous section in order to achieve a near-linear lower bound even for computing a ($3/2-\varepsilon$)-approximation of the diameter.

• **Theorem 2 **

For any constant $0<\varepsilon<1/2$, any algorithm for computing a $(3/2-\varepsilon)$-approximation of the diameter, even of a network of $\Theta(n\log n)$ edges, requires $\Omega\left(\frac{n}{\log^{3}{n}}\right)$ rounds.

As in the proof of Theorem 1, we show that there is a family of lower bound graphs with respect to the set-disjointness function and the predicate $P$ that says that the graph has a diameter of length at least $\widetilde{D}$, where $\widetilde{D}$ is an integer that may depend on $n$. Note that, unlike the case of proving a lower bound for computing the exact diameter, here we need to construct a family of lower bound graphs for which even an algorithm that computes a $(3/2-\epsilon)$-approximation to the diameter can be used to determine whether $P$ holds.

The fixed graph construction: Start with our graph construction from the previous section and stretch it by replacing some edges by paths of length $q$, an integer that is chosen later. Apply the following changes to the construction described in the previous section (see Figure 3):

Replace all the edges inside $V_{A}$ and all the edges inside $V_{B}$ by paths of length $q$. The cut edges and the edges that depend on the inputs remain intact. 2. 2.

Add two additional sets of nodes $\bar{A}=\{\bar{a}^{i}\mid i\in\left\{0,\ldots,k-1\right\}\}$, $\bar{B}=\{\bar{b}^{i}\mid i\in\left\{0,\ldots,k-1\right\}\}$, each of size $k$. For each $i\in\left\{0,\ldots,k-1\right\}$, connect $\bar{a}^{i}$ to $a^{i}$ and $\bar{b}^{i}$ to $b^{i}$, by paths of length $q$.

The partition of nodes into $V_{A}$ and $V_{B}$ is similar to the previous: $V_{A}$ is composed of the nodes in $V_{A}$ in the previous construction, the set $\bar{A}$, and the nodes in the paths between them. $V_{B}$ is composed of the rest of the nodes.

Adding edges corresponding to the strings $x$ and $y$: Given two binary strings $x,y\in\left\{0,1\right\}^{k}$, define $G_{x,y}$ by adding edges to the graph in a way similar to the the one described in the previous section. That is, if $x[i]=0$ then add an edge between the nodes $a^{i}$ and $\bar{c}_{A}$, and if $y[i]=0$ then add an edge between $b^{i}$ and $\bar{c}_{B}$.

In this construction, the nodes $A\cup B\cup\left\{\bar{c}_{A},\bar{c}_{B}\right\}$ serve as hubs, in the sense that any node is at distance at most $q$ from one of the hubs and the hubs are at distance at most $2q+2$ from one another, implying $D\leq 4q+2$. The only exception to this is if the input strings are not disjoint, in which case there are $a^{i},b^{i}$ with $\operatorname{d}(a^{i},b^{i})\geq 4q+1$, implying $D\geq\operatorname{d}(\bar{a}^{i},\bar{b}^{i})\geq 6q+1$. Let us formalize these arguments.

Claim 3**.**

For every $u,v\in A\cup B\cup\left\{\bar{c}_{A},\bar{c}_{B}\right\}$, if there is no index $i\in\left\{0,\ldots,k-1\right\}$ such that $u=a^{i}$ and $v=b^{i}$, then $\operatorname{d}(u,v)\leq 2q+1$.

Proof.

For each $i$ there is a path from $a^{i}$ to $\bar{c}_{B}$ of length $2q+1$, which passes through $c_{A}$ and $\bar{c}_{A}$, so $\operatorname{d}(a^{i},\bar{c}_{B})\leq 2q+1$, and also $\operatorname{d}(a^{i},\bar{c}_{A})\leq 2q+1$. Similarly, $\operatorname{d}(b^{i},\bar{c}_{A})\leq 2q+1$, and also $\operatorname{d}(b^{i},\bar{c}_{B})\leq 2q+1$. For every $i,j\in\left\{0,\ldots,k-1\right\}$, there is a $2q$-path from $a^{i}$ to $a^{j}$ through $c_{A}$, so $\operatorname{d}(a^{i},a^{j})\leq 2q$, and similarly $\operatorname{d}(b^{i},b^{j})\leq 2q$ using $c_{B}$.

We are left with the case of $a^{i}$ and $b^{j}$ where $i\neq j$, which is a simple extension of Claim 1. In this case, there must be some $h$ such that $i_{h}\neq j_{h}$, and assume without loss of generality that $i_{h}=1$ and $j_{h}=0$. Hence, $a^{i}$ is connected to $t_{A}^{h}$ by a $q$-path, and $b^{j}$ is similarly connected to $f_{B}^{h}$. Since $t_{A}^{h}$ and $f_{B}^{h}$ are connected by an edge, we have $\operatorname{d}(a^{i},b^{j})\leq 2q+1$, as desired. ∎

The next lemma proves that $\left\{G_{x,y}\right\}$ is a family of lower bound graphs.

Lemma 2**.**

If $x$ and $y$ are disjoint then the diameter of $G_{x,y}$ is at most $4q+2$, and otherwise it is at least $6q+1$.

Proof.

Assume that the sets are disjoint, so for every $i\in\left\{0,\ldots,k-1\right\}$ either $x[i]=0$ or $y[i]=0$. Hence, for every $i$ there is a $(2q+2)$-path from $a^{i}$ to $b^{i}$, whether through $\bar{c}_{A},\bar{c}_{B},c_{B}$ or through $c_{A},\bar{c}_{A},\bar{c}_{B}$. Hence, $\operatorname{d}(a^{i},b^{i})\leq 2q+2$, and together with Claim 2, we can conclude that for every $u^{\prime},v^{\prime}\in(A\cup B\cup\left\{\bar{c}_{A},\bar{c}_{B}\right\})$ we have $\operatorname{d}(u,v)\leq 2q+2$.

For each node $v\in V$, there exists a node $v^{\prime}\in(A\cup B\cup\left\{\bar{c}_{A},\bar{c}_{B}\right\})$ such that $\operatorname{d}(v,v^{\prime})\leq q$. Consider any two nodes $u,v\in V$, and the nodes $u^{\prime},v^{\prime}\in(A\cup B\cup\left\{\bar{c}_{A},\bar{c}_{B}\right\})$ closest to them. By the triangle inequality, $\operatorname{d}(u,v)\leq\operatorname{d}(u,u^{\prime})+\operatorname{d}(u^{\prime},v^{\prime})+\operatorname{d}(v^{\prime},v)\leq q+2q+2+q=4q+2$, as desired.

Assume that the two sets are not disjoint, i.e., there is some $i\in\left\{0,\ldots,k-1\right\}$ such that $x[i]=y[i]=1$. Hence, $a^{i}$ is not connected directly to $\bar{c}_{A}$ and $b^{i}$ is not connected directly to $\bar{c}_{B}$. We show that $\operatorname{d}(\bar{a}^{i},\bar{b}^{i})\geq 6q+1$.

First, note that any path connecting $\bar{a}^{i}$ and $\bar{b}^{i}$ must go through the $q$-paths connecting $\bar{a}^{i}$ to $a^{i}$ and $\bar{b}^{i}$ to $b^{i}$, hence it suffices to prove $\operatorname{d}(a^{i},b^{i})\geq 4q+1$. Let $u\in V_{A}$ be a cut node, i.e., a node in $V_{A}$ with a neighbor in $V_{B}$. Observe that no shortest path from $a^{i}$ to $u$ uses a node $a^{j}$ for $j\neq i$, as $\operatorname{d}(a^{i},a^{j})=2q$ and $\operatorname{d}(a^{i},u)\leq 2q$, and a similar claim holds for $b^{i}$. Thus, shortest paths connecting $a^{i}$ and $b^{i}$ do not use any edges of the form $(a^{j},\bar{c}_{A})$ or $(b^{j}\bar{c}_{B})$, but only $q$-paths that replace edges of the graph from the previous section, and cut edges. The proof of Lemma 1 shows that any such path must go through at least 4 edges which are internal to $V_{A}$ or $V_{B}$, and one cut edge. In the current construction, this translates into $4$ $q$-paths and an edge, which implies $\operatorname{d}(a^{i},b^{i})\geq 4q+1$, as desired. ∎

Using this family of lower bound graphs, we prove Theorem 2.

• **Proof of Theorem 2: **

To complete the proof of Theorem 2, consider the predicate $P$ of the diameter of the graph being at least $6q+1$. In order to make $\left\{G_{x,y}\right\}$ a family of lower bound graphs for which even a $(3/2-\epsilon)$-approximation algorithm decides $P$, we choose a constant $q$ such that $(\frac{3}{2}-\varepsilon)\cdot(4q+2)<(6q+1)$, which holds for any $q>\frac{1}{2\varepsilon}-\frac{1}{2}$. Observe that $k\in\Theta(n/\log n)$ for any constant $\varepsilon$, and thus $K=|x|=|y|\in\Theta(n/\log n)$. Furthermore, the number of edges in the cut is $|E(V_{A},V_{B})|\in\Theta(\log n)$. By applying Theorem 6 to the above construction, we deduce that any algorithm in the congest model for computing a $(3/2-\epsilon)$-approximation for the diameter requires at least $\Omega\left(n/\log^{3}(n)\right)$ rounds. ∎

4.3 Radius

In this section we extend our sparse construction and show that computing the radius requires a near-linear number of rounds in the congest model, even on sparse graphs.

• **Theorem 3 **

Any algorithm for computing the radius, even of a network of $\Theta(n\log n)$ edges, requires $\Omega\left(\frac{n}{\log^{2}{n}}\right)$ rounds.

The fixed graph construction: The graph construction for the radius is very similar to the one described in Section 4.1, with the following changes (see also Figure 4).

For each $h\in\left\{0,\ldots,\log k-1\right\}$, add the edge $(f_{A}^{h},t_{A}^{h})$. 2. 2.

Add a $2$-path $(w^{0},w^{1},w^{2})$, and connect $w^{0}$ to all the nodes in $A$. Add the nodes $w^{0},w^{1},w^{2}$ to $V_{A}$.

Adding edges corresponding to the strings $x$ and $y$: Given two binary strings $x,y\in\left\{0,1\right\}^{k}$, we define $G_{x,y}$ as follows. If $x[i]=1$, then we add an edge between $a^{i}$ and $\bar{c}_{A}$, and if $y[i]=1$ we add an edge between $b^{i}$ and $\bar{c}_{B}$. Note that unlike the reduction from the previous section, here we add an edge if the corresponding bit is 1 rather than 0.

Claim 4**.**

The graph family $\{G_{x,y}\}$ defined above has the following properties:

For every node $u\in V\setminus A$, it holds that $e(u)\geq 4$. 2. 2.

For every $a^{i}\in A$ and $u\in V\setminus\left\{b^{i},c_{B}\right\}$, it holds that $\operatorname{d}(a^{i},u)\leq 3$.

Proof.

For $u\notin A\cup\left\{w^{0},w^{1},w^{2}\right\}$, any path from $u$ to $w^{2}$ must go through a node $a^{i}\in A$. Since $\operatorname{d}(w^{2},a^{i})=3$ for every such $a^{i}\in A$, we get $\operatorname{d}(w^{2},u)>3$. For $u\in\left\{w^{0},w^{1},w^{2}\right\}$, note that no $a^{i}$ has a common neighbor with $c_{B}$, so $\operatorname{d}(a^{i},c_{B})\geq 3$ for all $a^{i}$, so $\operatorname{d}(u,c_{B})>3$, proving 1.

For 2, if $u\in\left\{w^{0},w^{1},w^{2}\right\}$ then $\operatorname{d}(a^{i},u)\leq 3$ by construction. If $u\in\left\{c_{A},\bar{c}_{A},\bar{c}_{B}\right\}$ then the path $(a_{,}c_{A},\bar{c}_{A},\bar{c}_{B})$ proves the claim. Every $v\in F_{A}\cup T_{A}$ is in $\operatorname{bin}(a^{i})$ or a neighbor of a node in $\operatorname{bin}(a^{i})$, so $\operatorname{d}(a^{i},v)\leq 2$, and every $u\in F_{B}\cup T_{B}$ is a neighbor of some $v\in F_{A}\cup T_{A}$, implying $\operatorname{d}(a^{i},u)\leq 3$. Finally, if $u=b^{i}$ for $i\neq j$ then $\operatorname{d}(a^{i},u)\leq 3$ by Claim 1. ∎

Lemma 3**.**

The strings $x$ and $y$ are disjoint if and only if the radius of $G$ is at least $4$.

Proof.

If the strings are not disjoint, i.e., there exists an $i\in\left\{0,\ldots,k-1\right\}$ such that $x[i]=y[i]=1$, then the edges $(a^{i},\bar{c}_{A}),(b^{i},\bar{c}_{B})$ exist in the graph. The $3$-path $(a^{i},\bar{c}_{A},\bar{c}_{B},b^{i})$ implies $\operatorname{d}(a^{i},b^{i})\leq 3$, and the $3$-path $(a^{i},\bar{c}_{A},\bar{c}_{B},c_{B})$ implies $\operatorname{d}(a^{i},c_{B})\leq 3$. Claim 4(2) completes the proof: $\operatorname{d}(a^{i},u)\leq 3$ for every $u\in V$, and $e(a^{i})\leq 3$ as desired.

If the radius is at most $3$, then by Claim 4(1) there must be a node $a^{i}\in A$ with $e(a^{i})\leq 3$, which implies $\operatorname{d}(a^{i},b^{i})\leq 3$. Since the nodes of $\operatorname{bin}(a^{i})$ and $\operatorname{bin}(b^{i})$ are not neighbors, there must be a $3$-path connecting $a^{i}$ and $b^{i}$ that goes through the cut edge $(\bar{c}_{A},\bar{c}_{B})$. Hence, the edges $(a^{i},\bar{c}_{A})$ and $(b^{i},\bar{c}_{B})$ exist in $G_{\left\{x,y\right\}}$, so $x[i]=y[i]=1$ and the strings are not disjoint. ∎

• **Proof of Theorem 3: **

Note that the number of edges on the cut is $\left|E(V_{A},V_{B})\right|=\Theta(\log n)$, and that $K=k=\Theta(n)$. By Lemma 3, $\{G_{x,y}\}$ is a family of lower bound graphs, so we can apply Theorem 6 on the above construction to deduce that any algorithm in the congest model for computing the radius of a sparse network requires at least $\Omega(n/\log^{2}(n))$ rounds. ∎

5 Near-Quadratic Lower Bounds for General Graphs

In this section we present the first super-linear lower bounds for natural graph problems in the congest model. Section 5.1 introduces a relatively simple lower bound for the minimum vertex cover and maximum independent set algorithms, and Section 5.2 presents lower bounds for $\chi$-coloring algorithms.

5.1 Minimum Vertex Cover

The first near-quadratic lower bound we present is for computing a minimum vertex cover, as stated in the following theorem.

• **Theorem 4 **

Any algorithm for computing a minimum vertex cover of the network or deciding whether there is a vertex cover of a given size requires $\Omega(n^{2}/\log^{2}n)$ rounds.

A set of nodes is a vertex cover if and only if its complement is an independent set, which implies that finding the minimum size of a vertex cover is equivalent to finding the maximum size of an independent set. Thus, the following theorem is a direct corollary of Theorem 4.

Theorem 7**.**

Any distributed algorithm for computing a maximum independent set or for deciding whether there is an independent set of a given size requires $\Omega(n^{2}/\log^{2}n)$ rounds.

Observe that a lower bound for deciding whether there is a vertex cover of some given size or not implies a lower bound for computing a minimum vertex cover. This is because computing the size of a given subset of nodes can be easily done in $O(D)$ rounds using standard tools. Therefore, to prove Theorem 4 it is sufficient to prove its second part. We do so by describing a family of lower bound graphs with respect to the set-disjointness function and the predicate $P$ that says that the graph has a vertex cover of size $M$, where $M=M(n)$ is chosen later. We begin with describing the fixed graph construction $G=(V,E)$ and then define the family of lower bound graphs and analyze its relevant properties.

The fixed graph construction:

Start with two copies of the gadget described in Section 3. That is, the fixed graph (Figure 5) consists of four sets of size $k$: $A_{1}=\{a^{i}_{1}\mid i\in\left\{0,\ldots,k-1\right\}\}$, $A_{2}=\{a^{i}_{2}\mid i\in\left\{0,\ldots,k-1\right\}\}$, $B_{1}=\{b^{i}_{1}\mid i\in\left\{0,\ldots,k-1\right\}\}$ and $B_{2}=\{b^{i}_{2}\mid i\in\left\{0,\ldots,k-1\right\}\}$. Each such set $S$ is connected to $2\log k$ nodes: $F_{S}=\{f^{h}_{S}\mid h\in\left\{0\ldots,\log k-1\right\}\}$ and $T_{S}=\{t^{h}_{S}\mid h\in\left\{0,\ldots,\log k-1\right\}\}$, where $F_{A_{1}},T_{A_{1}},F_{B_{1}},T_{B_{1}}$ constitute one bit-gadget, and $F_{A_{2}},T_{A_{2}},F_{B_{2}},T_{B_{2}}$ constitute another. Partition the nodes into $V_{A}=A_{1}\cup A_{2}\cup F_{A_{1}}\cup T_{A_{1}}\cup F_{A_{2}}\cup T_{A_{2}}$ and $V_{B}=V\setminus V_{A}$.

Let $s^{i}_{\ell}$ be a node in a set $S\in\left\{A_{1},A_{2},B_{1},B_{2}\right\}$, i.e., $s\in\left\{a,b\right\}$, $\ell\in\left\{1,2\right\}$ and $i\in\left\{0,\ldots,k-1\right\}$. As before, connect $s^{i}_{\ell}$ to $\operatorname{bin}(s^{i}_{\ell})=\left\{f^{h}_{S}\mid i_{h}=0\right\}\cup\left\{t^{h}_{S}\mid i_{h}=1\right\}$. In addition, in each of the sets $A_{1},A_{2},B_{1},B_{2}$, connect all the nodes to one another, forming a clique. Also, connect the nodes of the bit-gadgets to form $4$-cycles: for each $h\in\left\{0,\ldots,\log k-1\right\}$ and $\ell\in\left\{1,2\right\}$, connect the $4$-cycle $(f^{h}_{A_{\ell}},t^{h}_{A_{\ell}},f^{h}_{B_{\ell}},t^{h}_{B_{\ell}})$.

The following two claims address the basic properties of vertex covers of $G$.

Claim 5**.**

Any vertex cover of $G$ must contain at least $k-1$ nodes from each of the cliques in $A_{1},A_{2},B_{1}$ and $B_{2}$, and at least $4\log k$ bit-nodes.

Proof.

In order to cover all the edges of each of the cliques in $A_{1},A_{2},B_{1}$ and $B_{2}$, any vertex cover must contain at least $k-1$ nodes of each clique. For each $h\in\left\{0,\ldots,\log k-1\right\}$ and $\ell\in\{1,2\}$, in order to cover the edges of the 4-cycle $(f^{h}_{A_{\ell}},t^{h}_{A_{\ell}},f^{h}_{B_{\ell}},t^{h}_{B_{\ell}})$, any vertex cover must contain at least two of the cycle nodes. ∎

Claim 6**.**

If $U\subseteq V$ is a vertex cover of $G$ of size $4(k-1)+4\log k$, then there are two indices $i,j\in\left\{0,\ldots,k-1\right\}$ such that all four nodes $a^{i}_{1},a^{j}_{2},b^{i}_{1},b^{j}_{2}$ are not in $U$.

Proof.

By Claim 5, $U$ must contain $k-1$ nodes from each clique $A_{1},A_{2},B_{1}$ and $B_{2}$, and $4\log k$ bit-nodes, so in each clique there is a node that is not in $U$. Let $a^{i}_{1},a^{j}_{2},b^{i^{\prime}}_{1},b^{j^{\prime}}_{2}$ be the nodes in $A_{1},A_{2},B_{1},B_{2}$ which are not in $U$, respectively. To cover the edges connecting $a^{i}_{1}$ to $\operatorname{bin}(a^{i}_{1})$, $U$ must contain all the nodes of $\operatorname{bin}(a^{i}_{1})$, and similarly, $U$ must contain all the nodes of $\operatorname{bin}(b^{i^{\prime}}_{1})$. If $i\neq i^{\prime}$ then there is an index $h\in\left\{0,\ldots,\log k-1\right\}$ such that $i_{h}\neq i^{\prime}_{h}$, so one of the edges $(f^{h}_{A_{1}},t^{h}_{B_{1}})$ or $(t^{h}_{A_{1}},f^{h}_{B_{1}})$ is not covered by $U$. Thus, it must hold that $i=i^{\prime}$. A similar argument shows $j=j^{\prime}$. ∎

Adding edges corresponding to the strings $x$ and $y$: Given two binary strings $x,y\in\left\{0,1\right\}^{k^{2}}$, assume they are indexed by pairs of the form $(i,j)\in\left\{0,\ldots,k-1\right\}^{2}$. To define $G_{x,y}$, augment the graph $G$ defined above with edges as following. For each such pair $(i,j)$, if $x[i,j]=0$, then add an edge between $a_{1}^{i}$ and $a_{2}^{j}$, and if $y[i,j]=0$ then we add an edge between $b_{1}^{i}$ and $b_{2}^{j}$. To prove that $\left\{G_{xy}\right\}$ is a family of lower bound graphs, it remains to prove the following lemma.

Lemma 4**.**

The graph $G_{x,y}$ has a vertex cover of cardinality $M=4(k-1)+4\log k$ iff $x$ and $y$ are not disjoint.

Proof.

For the first implication, assume that $x$ and $y$ are not disjoint, and let $i,j\in\left\{0,\ldots,k-1\right\}$ be such that $x[i,j]=y[i,j]=1$. Note that in this case $a^{i}_{1}$ is not connected to $a^{j}_{2}$, and $b^{i}_{1}$ is not connected to $b^{j}_{2}$. Define a set $U\subseteq V$ as

[TABLE]

and show that $U$ is a vertex cover of $G_{x,y}$, as follows.

First, $U$ covers all the edges inside the cliques $A_{1},A_{2},B_{1}$ and $B_{2}$, as it contains $k-1$ nodes from each clique. These nodes also cover all the edges connecting nodes in $A_{1}$ to nodes in $A_{2}$ and all the edges connecting nodes in $B_{1}$ to nodes in $B_{2}$, since the edges $(a^{i}_{1},a^{j}_{2})$ and $(b^{i}_{1},b^{j}_{2})$ do not exist in $G_{x,y}$. Furthermore, $U$ covers any edge connecting nodes $(A_{1}\setminus\{a^{i}_{1}\})\cup(A_{2}\setminus\{a^{j}_{2}\})\cup(B_{1}\setminus\{b^{i}_{1}\})\cup(B_{2}\setminus\{b^{j}_{2}\})$ to the bit-gadgets. For each node $s\in\left\{a^{i}_{1},a^{j}_{2},b^{i}_{1},b^{j}_{2}\right\}$, the nodes $\operatorname{bin}(s)$ are in $U$, so $U$ also covers the edges connecting $s$ to the bit-gadget. Finally, $U$ covers all the edges inside the bit-gadgets, as from each $4$-cycle $(f^{h}_{A_{\ell}},t^{h}_{A_{\ell}},f^{h}_{B_{\ell}},t^{h}_{B_{\ell}})$ it contains two non-adjacent nodes: if $i_{h}=0$ then $f^{h}_{A_{1}},f^{h}_{B_{1}}\in U$ and otherwise $t^{h}_{A_{1}},t^{h}_{B_{1}}\in U$, and if $j_{h}=0$ then $f^{h}_{A_{2}},f^{h}_{B_{2}}\in U$ and otherwise $t^{h}_{A_{2}},t^{h}_{B_{2}}\in U$. Thus, $U$ is a vertex cover of size $4(k-1)+4\log k$, as claimed.

For the other implication, let $U\subseteq V$ be a vertex cover of $G_{x,y}$ of size $4(k-1)+4\log k$. Since all the edges of $G$ are also edges of $G_{x,y}$, $U$ is also a cover of $G$, so Claim 6 implies that there are indices $i,j\in\left\{0,\ldots,k-1\right\}$ such that $a^{i}_{1},a^{j}_{2},b^{i}_{1},b^{j}_{2}$ are not in $U$. Since $U$ is a cover, the graph does not contain the edges $(a^{i}_{1},a^{j}_{2})$ and $(b^{i}_{1},b^{j}_{2})$, so we conclude that $x[i,j]=y[i,j]=1$, which implies that $x$ and $y$ are not disjoint. ∎

Having constructed the family of lower bound graphs, we are now ready to prove Theorem 4.

• **Proof of Theorem 4: **

Note that $n\in\Theta(k)$, and thus $K=|x|=|y|=\Theta(n^{2})$, and furthermore, the only edges in the cut $E(V_{A},V_{B})$ are the edges between nodes in $F_{A_{1}}\cup T_{A_{1}}\cup F_{A_{2}}\cup T_{A_{2}}$ and nodes in $F_{B_{1}}\cup T_{B_{1}}\cup F_{B_{2}}\cup T_{B_{2}}$, which are in total $\Theta(\log n)$ edges. Since Lemma 4 shows that $\{G_{x,y}\}$ is a family of lower bound graphs, we can apply Theorem 6 to deduce that any algorithm in the congest model for deciding whether a given graph has a cover of cardinality $M=4(k-1)+4\log k$ requires at least $\Omega(K/\log^{2}(n))=\Omega(n^{2}/\log^{2}(n))$ rounds. ∎

5.2 Graph Coloring

In this section we consider the problems of coloring a graph with $\chi$ colors, computing $\chi$ and approximating it. We prove the following theorem.

• **Theorem 5 **

Any algorithm for coloring a $\chi$-colorable network in $\chi$ colors, or for deciding if it is $c$-colorable for a given $c$, requires $\Omega(n^{2}/\log^{2}n)$ rounds.

The fixed graph construction: Define $G=(V,E)$ as follows (see Figure 6 for the general construction, and Figure 9 for an example with specific $k$ and inputs).

Start with the family of graphs defined in Section 5.1, omitting the clique edges inside the four sets $A_{1},A_{2},B_{1},B_{2}$. Add the following two gadgets to the graph.

Add three nodes $c^{0}_{a},c^{1}_{a},c^{2}_{a}$ connected as a triangle, another three nodes $c^{0}_{b},c^{1}_{b},c^{2}_{b}$ connected as a triangle, and edges connecting $c^{i}_{a}$ to $c^{j}_{b}$ for each $i\neq j\in\left\{0,1,2\right\}$. 2. 2.

For each set $S\in\left\{A_{1},A_{2},B_{1},B_{2}\right\}$, add two sets of nodes, $\bar{S}=\left\{\bar{s}^{i}_{\ell}\mid s^{i}_{\ell}\in S\right\}$ and $\bar{\bar{S}}=\left\{\bar{\bar{s}}^{i}_{\ell}\mid s^{i}_{\ell}\in S\right\}$. For each $\ell\in\left\{1,2\right\}$ and $i\in\left\{0,\ldots,k-1\right\}$ connect a path $(s^{i}_{\ell},\bar{s}^{i}_{\ell},\bar{\bar{s}}^{i}_{\ell})$, and for each $\ell\in\left\{1,2\right\}$ and $i\in\left\{0,\ldots,n-2\right\}$, connect $\bar{\bar{s}}^{i}_{\ell}$ to $\bar{s}^{i+1}_{\ell}$.

In addition, connect the gadgets by the following edges:

1. (a)

$(c_{a}^{1},f^{h}_{A_{1}})$, $(c_{a}^{1},t^{h}_{A_{1}})$, $(c_{b}^{1},f^{h}_{B_{1}})$ and $(c_{b}^{1},t^{h}_{B_{1}})$, for each $h\in\left\{0,\ldots,\log k-1\right\}$. 2. (b)

$(c_{a}^{2},f^{h}_{A_{2}})$, $(c_{a}^{2},t^{h}_{A_{2}})$, $(c_{b}^{2},f^{h}_{B_{2}})$ and $(c_{b}^{2},t^{h}_{B_{2}})$, for each $h\in\left\{0,\ldots,\log k-1\right\}$. 3. (c)

$(c^{2}_{a},a_{1}^{i})$ and $(c^{1}_{a},\bar{\bar{a}}_{1}^{i})$, for each $i\in\left\{0,\ldots,k-1\right\}$; $(c^{2}_{a},\bar{a}^{0}_{1})$ and $(c^{2}_{a},\bar{\bar{a}}^{k-1}_{1})$. 4. (d)

$(c^{2}_{b},b_{1}^{i})$ and $(c^{1}_{b},\bar{\bar{b}}_{1}^{i})$, for each $i\in\left\{0,\ldots,k-1\right\}$; $(c^{2}_{b},\bar{b}^{0}_{1})$ and $(c^{2}_{b},\bar{\bar{b}}^{k-1}_{1})$. 5. (e)

$(c^{1}_{a},a_{2}^{i})$ and $(c^{2}_{a},\bar{\bar{a}}_{2}^{i})$, for each $i\in\left\{0,\ldots,k-1\right\}$; $(c^{1}_{a},\bar{a}^{0}_{2})$ and $(c^{1}_{a},\bar{\bar{a}}^{k-1}_{2})$. 6. (f)

$(c^{1}_{b},b_{2}^{i})$ and $(c^{2}_{b},\bar{\bar{b}}_{2}^{i})$, for each $i\in\left\{0,\ldots,k-1\right\}$; $(c^{1}_{b},\bar{b}^{0}_{2})$ and $(c^{1}_{b},\bar{\bar{b}}^{k-1}_{2})$.

Assume there is a proper $3$-coloring of $G$. Denote by $c_{0},c_{1}$ and $c_{2}$ the colors of $c^{0}_{a},c^{1}_{a}$ and $c^{2}_{a}$ respectively. By construction, these are also the colors of $c^{0}_{b},c^{1}_{b}$ and $c^{2}_{b}$, respectively. In Section 5.1 we present a specific vertex cover, and mention that its complement is an independent set. In the current section, this independent set is colored by $c_{0}$, and the part of the graph that did not appear in the previous section is used in order to guarantee that coloring this independent set by $c_{0}$ is the only valid option. The following claims are thus very similar to those appearing in the previous section.

Claim 7**.**

In each set $S\in\{A_{1},A_{2},B_{1},B_{2}\}$, at least one node is colored by $c_{0}$.

Proof.

We start by proving the claim for $S=A_{1}$ (see figure 7). Assume, towards a contradiction, that none of the nodes of $A_{1}$ is colored by $c_{0}$. All these nodes are connected to $c^{2}_{a}$, so they are not colored by $c_{2}$ either, i.e., they all must be colored $c_{1}$. Hence, all the nodes $\bar{A}_{1}$ are colored by $c_{0}$ and $c_{2}$. The nodes of $\bar{\bar{A}}_{1}$ are connected to $c^{1}_{a}$, so they are colored by $c_{0}$ and $c_{2}$ as well.

Hence, we have a path $(\bar{a}^{0}_{1},\bar{\bar{a}}^{0}_{1},\bar{a}^{1}_{1},\bar{\bar{a}}^{1}_{1},\ldots\bar{a}^{k-1}_{1},\bar{\bar{a}}^{k-1}_{1})$ with an even number of nodes, starting in $\bar{a}^{0}_{1}$ and ending in $\bar{\bar{a}}^{k-1}_{1}$. The colors of this path must alternate between $c_{0}$ and $c_{2}$, but both its endpoint are connected to $c^{2}_{a}$, so they must both be colored $c_{0}$, a contradiction.

A similar proof shows the claim for $S=B_{1}$. For $S\in\left\{A_{2},B_{2}\right\}$, we use a similar argument but change the roles of $c_{1}$ and $c_{2}$. ∎

Claim 8**.**

For all $i,j\in\left\{0,\ldots,k-1\right\}$, the node $a_{1}^{i}$ is colored by $c_{0}$ iff $b_{1}^{i}$ is colored by $c_{0}$ and the node $a_{2}^{j}$ is colored by $c_{0}$ iff $b_{2}^{j}$ is colored by $c_{0}$.

Proof.

Assume $a_{1}^{i}$ is colored by $c_{0}$, so all of its adjacent nodes $\operatorname{bin}(a_{1}^{i})$ can only be colored by $c_{1}$ or $c_{2}$ (see Figure 8). As all of these nodes are connected to $c_{a}^{1}$, they must be colored by $c_{2}$. By Claim 7, there is a node in $b_{1}^{i^{\prime}}\in B_{1}$ that is colored by $c_{0}$, and by a similar argument the nodes $\operatorname{bin}(b_{1}^{i^{\prime}})$ must also be colored by $c_{2}$.

If $i\neq i^{\prime}$ then there is a bit $h$ such that $i_{h}\neq i^{\prime}_{h}$, and there must be a pair of neighboring nodes $(f^{h}_{A_{1}},t^{h}_{B_{1}})$ or $(t^{h}_{A_{1}},f^{h}_{B_{1}})$ which are both colored by $c_{2}$, a contradiction. Thus, the only option is $i=i^{\prime}$.

An analogous argument shows that if $b_{1}^{i}$ is colored by $c_{0}$, then so does $a_{1}^{i}$. For $a_{2}^{j}$ and $b_{2}^{j}$, similar arguments apply, where $c_{1}$ plays the role of $c_{2}$. ∎

Adding edges corresponding to the strings $x$ and $y$: To get $G_{x,y}$ from $G$, add edges exactly as in the previous section: if $x[i,j]=0$ then add $(a_{1}^{i},a_{2}^{j})$, and if $y[i,j]=0$ then add $(b_{1}^{i},b_{2}^{j})$. The following lemma proves that $\left\{G_{x,y}\right\}$ is a family of lower bound graphs.

Lemma 5**.**

The graph $G_{x,y}$ is $3$-colorable iff $x$ and $y$ are not disjoint.

Proof.

Assume $G_{x,y}$ is $3$-colorable, and denote the colors of $c^{0}_{a},c^{1}_{a}$ and $c^{2}_{a}$ by $c_{0},c_{1}$ and $c_{2}$ respectively, as before. By Claim 7, there are nodes $a_{1}^{i}\in A_{1}$ and $a_{2}^{j}\in A_{2}$ that are both colored by $c_{0}$. Hence, the edge $(a_{1}^{i},a_{2}^{j})$ does not exist in $G_{x,y}$, implying $x[i,j]=1$. By Claim 8, the nodes $b_{1}^{i}$ and $b_{2}^{j}$ are also colored $c_{0}$, so $y[i,j]=1$ as well, implying that $x$ and $y$ are not disjoint.

For the other direction, assume $x$ and $y$ are not disjoint, i.e., there is an index $(i,j)\in\left\{0,\ldots,k-1\right\}^{2}$ such that $x[i,j]=y[i,j]=1$. Consider the following coloring (see Figure 9).

Color $c_{a}^{i}$ and $c_{b}^{i}$ by $c_{i}$, for $i\in\left\{0,1,2\right\}$. 2. 2.

Color the nodes $a_{1}^{i},b_{1}^{i},a_{2}^{j}$ and $b_{2}^{j}$ by $c_{0}$. Color the nodes $a_{1}^{i^{\prime}}$ and $b_{1}^{i^{\prime}}$, for $i^{\prime}\neq i$, by $c_{1}$, and the nodes $a_{2}^{j^{\prime}}$ and $b_{1}^{j^{\prime}}$, for $j^{\prime}\neq j$, by $c_{2}$. 3. 3.

Color the nodes of $\operatorname{bin}(a_{1}^{i})$ by $c_{2}$, and similarly color the nodes of $\operatorname{bin}(b_{1}^{i})$ by $c_{2}$. Color the rest of the nodes in this gadget, i.e., $\operatorname{bin}(a_{1}^{k-i})$ and $\operatorname{bin}(b_{1}^{k-i})$, by $c_{0}$. Similarly, color $\operatorname{bin}(a_{2}^{j})$ and $\operatorname{bin}(b_{2}^{j})$ by $c_{0}$ and $\operatorname{bin}(a_{2}^{k-j})$ and $\operatorname{bin}(b_{2}^{k-j})$ by $c_{1}$. 4. 4.

Finally, color the nodes of the forms $\bar{s}^{i}_{\ell}$ and $\bar{\bar{s}}^{i}_{\ell}$ as follows.

1. (a)

Color $\bar{a}_{1}^{i}$ and $\bar{b}_{1}^{i}$ by $c_{1}$, all nodes $\bar{a}_{1}^{i^{\prime}}$ and $\bar{b}_{1}^{i^{\prime}}$ with $i^{\prime}<i$ by $c_{0}$, and all nodes $\bar{a}_{1}^{i^{\prime}}$ and $\bar{b}_{1}^{i^{\prime}}$ with $i^{\prime}>i$ by $c_{2}$. 2. (b)

Similarly, color $\bar{a}_{2}^{i}$ and $\bar{b}_{2}^{i}$ by $c_{2}$, all nodes $\bar{a}_{2}^{i^{\prime}}$ and $\bar{b}_{2}^{i^{\prime}}$ with $i^{\prime}<i$ by $c_{0}$, and all nodes $\bar{a}_{2}^{i^{\prime}}$ and $\bar{b}_{2}^{i^{\prime}}$ with $i^{\prime}>i$ by $c_{1}$. 3. (c)

Color all nodes $\bar{\bar{a}}_{1}^{i^{\prime}}$ and $\bar{\bar{b}}_{1}^{i^{\prime}}$ with $i^{\prime}<i$ by $c_{2}$, and all nodes $\bar{\bar{a}}_{1}^{i^{\prime}}$ and $\bar{\bar{b}}_{1}^{i^{\prime}}$ with $i^{\prime}\geq i$ by $c_{0}$. 4. (d)

Similarly, color all nodes $\bar{\bar{a}}_{2}^{i^{\prime}}$ and $\bar{\bar{b}}_{2}^{i^{\prime}}$ with $i^{\prime}<i$ by $c_{1}$, and all nodes $\bar{\bar{a}}_{2}^{i^{\prime}}$ and $\bar{\bar{b}}_{2}^{i^{\prime}}$ with $i^{\prime}\geq i$ by $c_{0}$.

Checking all edges gives that the above coloring is indeed a proper $3$-coloring of $G_{x,y}$, which completes the proof. ∎

Having constructed the family of lower bound graphs, we are now ready to prove Theorem 5.

• **Proof of Theorem 5: **

The edges in the cut $E(V_{A},V_{B})$ are the $6$ edges connecting $\left\{c_{a}^{0},c_{a}^{1},c_{a}^{2}\right\}$ and $\left\{c_{b}^{0},c_{b}^{1},c_{b}^{2}\right\}$, and $2$ edges from every $4$-cycle of the nodes of $F_{A_{1}}\cup T_{A_{1}}\cup F_{B_{1}}\cup T_{B_{1}}$ and $F_{A_{2}}\cup T_{A_{2}}\cup F_{B_{2}}\cup T_{B_{2}}$, for a total of $\Theta(\log n)$ edges. Note that $n\in\Theta(k)$ and $K=k^{2}\in\Theta(n^{2})$. Lemma 5 shows that $\{G_{x,y}\}$ is a family of lower bound graphs with respect to $\mathrm{DISJ}_{K}$ and the predicate $\chi>3$, so by applying Theorem 6 on the above partition we deduce that any algorithm in the congest model for deciding whether a given graph is $3$-colorable requires $\Omega(n^{2}/\log^{2}n)$ rounds.

Any algorithm that computes $\chi$ of the input graph, or produces a $\chi$-coloring of it, may be used to deciding whether $\chi\leq 3$, in $O(D)$ additional rounds. Thus, the lower bound applies to these problems as well. ∎

A lower bound for $c$-coloring: Our construction and proof naturally extend to handle $c$-coloring, for any $c\geq 3$. We prove the next theorem.

Claim 9**.**

Any algorithm that decides if $\chi(G)\leq c$, for an integer $3\leq c<n$ that may depend on $n$, requires $\Omega((n-c)^{2}/(c\log n+\log^{2}n))$ rounds.

The proof of this claim is an extension of the proof of Theorem 5. Start with the graph $G_{x,y}$ defined above, add new nodes denoted $c_{a}^{i}$, $i\in\left\{3,\ldots,c-1\right\}$, and connect them to all of $V_{A}$, and new nodes denoted $c_{b}^{i}$, $i\in\left\{3,\ldots,c-1\right\}$, and connect them to all of $V_{B}$ and also to $c_{a}^{0},c_{a}^{1}$ and $c_{a}^{2}$ (see Figure 10). The nodes $c_{a}^{i}$ are added to $V_{a}$, and the rest are added to $V_{b}$, which increases the cut size by $\Theta(c)$ edges.

Assume the extended graph is colorable by $c$ colors, and denote by $c_{i}$ the color of the node $c_{a}^{i}$ (these nodes are connected by a clique, so their colors must be distinct). The nodes $c_{b}^{i}$, $i\in\left\{2,\ldots,c-1\right\}$ form a clique, and they are all connected to the nodes $c_{a}^{0},c_{a}^{1}$ and $c_{a}^{2}$, so they are colored by the colors $\left\{c_{3},\ldots,c_{c-1}\right\}$, in some arbitrary order. All the original nodes of $V_{A}$ are connected to $c_{a}^{i}$, $i\in\left\{3,\ldots,c-1\right\}$, and all the original nodes of $V_{B}$ are connected to $c_{b}^{i}$, $i\in\left\{3,\ldots,c-1\right\}$, so the original graph must be colored by $3$ colors, which we know is possible iff $x$ and $y$ are not disjoint. Thus, the newly defined family $\left\{G_{x,y}\right\}$ is a family of lower bound graphs, and we can easily prove the claim.

• **Proof of Claim 9: **

To construct $G_{x,y}$, we added $2c-6$ nodes to the graph, so now $K=k^{2}=\Theta((n-c)^{2})$. Thus, the new graphs constitute a family of lower bound graphs with respect to $\mathrm{DISJ}_{K}$ and the predicate $\chi>c$, the communication complexity of $\mathrm{DISJ}_{K}$ is in $\Omega(K^{2})=\Omega((n-c)^{2})$, the cut size is $\Theta(c+\log n)$, and Theorem 6 completes the proof. ∎

A lower bound for $(4/3-\epsilon)$-approximation: Finally, we extend our construction to give a lower bound for approximate coloring. That is, we show a similar lower bound for computing a $(4/3-\varepsilon)$-approximation to $\chi$ and for finding a coloring in $(4/3-\varepsilon)\chi$ colors.

Observe that since $\chi$ is integral, any $(4/3-\epsilon)$-approximation algorithm must return the exact solution in case $\chi=3$. Thus, in order to rule out the possibility for an algorithm which is allowed to return a $(4/3-\varepsilon)$-approximation which is not the exact solution, we need a more general construction. For any integer $c$, we show a lower bound for distinguishing between the case $\chi\leq 3c$ and $\chi\geq 4c$.

Claim 10**.**

Given an integer $c$, any algorithm that distinguishes a graph $G$ with $\chi(G)\leq 3c$ from a graph with $\chi(G)\geq 4c$ requires $\Omega(n^{2}/(c^{3}\log^{2}n))$ rounds.

To prove Claim 10 we show a family of lower bound graphs with respect to the $\mathrm{DISJ}_{K}$ function, where $K\in\Theta(n^{2}/c^{2})$, and the predicate $\chi\geq 4c$ ($\operatorname{{\scriptstyle{TRUE}}}$) or $\chi\leq 3c$ ($\operatorname{{\scriptstyle{FALSE}}}$). The predicate is not defined for other values of $\chi$.

We create a graph $G^{c}_{x,y}$, composed of $c$ copies of $G_{x,y}$. The $i$-th copy is denoted $G_{x,y}(i)$, and its nodes are partitioned into $V_{A}(i)$ and $V_{B}(i)$. Naturally, let $V_{A}=\cup_{i}V_{A}(i)$ and $V_{B}=\cup_{i}V_{B}(i)$. We connect all the nodes of $V_{A}(i)$ to all nodes of $V_{A}(j)$, for each $i\neq j$. Similarly, we connect all the nodes of $V_{B}(i)$ to all the nodes of $V_{B}(j)$. This construction guarantees that each copy is colored using different colors, and hence if $x$ and $y$ are disjoint then $\chi(G^{c}_{x,y})\geq 4c$, while otherwise $\chi(G^{c}_{x,y})=3c$. Therefore, $G^{c}_{x,y}$ is a family of lower bound graphs.

• **Proof of Claim 10: **

Note that $n\in\Theta(kc)$. Thus, $K=|x|=|y|=\Theta(n^{2}/c^{2})$. Furthermore, observe that for each $G_{x,y}(i)$, there are $O(\log k)$ edges in the cut, so in total $G^{c}_{x,y}$ contains $O(c\log k)=O(c\log n)$ edges in the cut. Since we showed that $G^{c}_{x,y}$ is a family of lower bound graphs, we can apply Theorem 6 to deduce that because of the lower bound for set-disjointness, any algorithm in the congest model for distinguishing between $\chi\leq 3c$ and $\chi\geq 4c$ requires at least $\Omega(n^{2}/(c^{3}\log^{2}n))$ rounds. ∎

For any $\epsilon>0$ and any $c$ it holds that $(4/3-\epsilon)3c<4c$. Thus, we can choose $c$ to be an arbitrary constant to achieve the following theorem.

Theorem 8**.**

For any constant $\varepsilon>0$, any algorithm that computes a $(4/3-\varepsilon)$-approximation to $\chi$ requires $\Omega(n^{2}/\log^{2}n)$ rounds.

As in the case of diameter, we note that our construction is not only for distinguishing $\chi=3$ from $\chi=4$, and thus it can be used to show a lower bound for multiplicative $(4/3-\varepsilon)$-approximation even if a constant additive error is also allowed.

6 Quadratic and Near-Quadratic Lower Bounds for Problems in P

In this section we support our claim that what makes problems hard for the congest model is not necessarily them being NP-hard problems. First, we address a class of subgraph detection problems, which requires detecting cycles of length $8$ and a given weight, and show a near-quadratic lower bound on the number of rounds required for solving it, although its sequential complexity is polynomial. Then, we define a problem which we call the Identical Subgraphs Detection problem, in which the goal is to decide whether two given subgraphs are identical. While this last problem is rather artificial, it allows us to obtain a strictly quadratic lower bound for the congest model, for a decision problem.

6.1 Weighted Cycle Detection

In this section we show a lower bound on the number of rounds needed in order to decide if the graph contains a simple cycle of length $8$ and weight $W$, such that $W$ is a $\mbox{polylog}(n)$-bit value given as an input. Note that this problem can be solved easily in polynomial time in the sequential setting by simply checking all the $\binom{n}{8}\cdot 7!$ potential cycles of length $8$.

Theorem 9**.**

Any distributed algorithm that decides if a weighted graph contains a simple cycle of length $8$ and a given weight requires $\Omega(n^{2}/\log^{2}n)$ rounds.

Similarly to the previous sections, to prove Theorem 9 we describe a family of lower bound graphs with respect to the set-disjointness function and the predicate $P$ that says that the graph contains a simple cycle of length $8$ and weight $W$.

The fixed graph construction: The fixed graph construction $G=(V,E)$ is defined as follows (see Figure 11). The set of nodes contains four sets $A_{1},A_{2},B_{1}$ and $B_{2}$, each of size $k\geq 3$. For each set $S\in\{A_{1},A_{2},B_{1},B_{2}\}$ there is a node $c_{S}$, which is connected to each of the nodes in $S$ by an edge of weight [math]. In addition there is an edge between $c_{A_{1}}$ and $c_{B_{1}}$ of weight 0 and an edge between $c_{A_{2}}$ and $c_{B_{2}}$ of weight [math]. We set $V_{A}=A_{1}\cup A_{2}\cup\left\{c_{A_{1}},c_{A_{2}}\right\}$ and $V_{B}=V\setminus V_{A}$.

Adding edges corresponding to the strings $x$ and $y$: Given two binary strings $x,y\in\left\{0,1\right\}^{k^{2}}$, we augment the fixed graph $G$ defined above with additional edges, which defines $G_{x,y}$. If $x[i,j]=1$, then we add an edge of weight $k^{3}+ki+j$ between the nodes $a_{1}^{i}$ and $a_{2}^{j}$. If $y[i,j]=1$, then we add an edge of weight $k^{3}-(ki+j)$ between the nodes $b_{1}^{i}$ and $b_{2}^{j}$. We denote by $\operatorname{InputEdges}$ the set of edges depending on the input, i.e. the edges in $(A_{1}\times A_{2})\cup(B_{1}\times B_{2})$.

Claim 11**.**

Any simple cycle of weight $2k^{3}$ contains exactly two edges from $\operatorname{InputEdges}$, one from $A_{1}\times A_{2}$ and one from $B_{1}\times B_{2}$.

Proof.

The weight of each edge in $\operatorname{InputEdges}$ is in $\left\{k^{3}-k^{2}+1,\ldots,k^{3}+k^{2}-1\right\}$ (the extremes are $w(b^{k-1}_{1},b^{k-1}_{2})$ and $w(a^{k-1}_{1},a^{k-1}_{2})$, if those edges exist), and all other edges weigh [math]. A cycle of weight $2k^{3}$ must contain at least two edges from $\operatorname{InputEdges}$ since $k^{3}+k^{2}-1<2k^{3}$, and cannot contain three or more of these since $2k^{3}<3(k^{3}-k^{2}+1)$.

Since the edges of $A_{1}\times A_{2}$ weigh at least $k^{3}$, and all but one of them weighs strictly more than that, two of these weigh more than $2k^{3}$. Similarly, two edges of $B_{1}\times B_{2}$ weigh less than $2k^{3}$. ∎

To prove that $\left\{G_{x,y}\right\}$ is a family of lower bound graphs, we prove the following lemma.

Lemma 6**.**

The graph $G_{x,y}$ contains a simple cycle of length $8$ and weight $W=2k^{3}$ if and only if $x$ and $y$ are not disjoint.

Proof.

For the first direction, assume that $x$ and $y$ are not disjoint, and let $i,j\in\left\{0,\ldots,k-1\right\}$ be such that $x[i,j]=y[i,j]=1$. The $8$-cycle $(a^{i}_{1},c_{A_{1}},c_{B_{1}},b^{i}_{1},b^{j}_{2},c_{B_{2}},c_{A_{2}},a^{j}_{2})$ has weight $w(a^{j}_{1},a^{i}_{2})+w(b^{i}_{1},b^{j}_{2})=k^{3}+ki+j+k^{3}-ki-j=2k^{3}$, as needed.

For the other direction, assume that the graph contains a simple cycle $C$ of length $8$ and weight $2k^{3}$. By Claim 11, $C$ contains two edges of the form $(a^{i}_{1},a^{j}_{2})\in A_{1}\times A_{2}$ and $(b^{i^{\prime}}_{1},b^{j^{\prime}}_{2})\in B_{1}\times B_{2}$. Since all other edge weights in $C$ are [math], we conclude $w(a^{i}_{1},a^{j}_{2})+w(b^{i^{\prime}}_{1},b^{j^{\prime}}_{2})=2k^{3}$, i.e. $k^{3}+ki+j+k^{3}-(ki^{\prime}+j^{\prime})=2k^{3}$, or $k(i-i^{\prime})=(j^{\prime}-j)$. The fact that $|j^{\prime}-j|<k$ implies $i=i^{\prime}$ and $j=j^{\prime}$, completing the proof. ∎

Having constructed a family of lower bound graphs, we are now ready to prove Theorem 9.

• **Proof of Theorem 9: **

Note that $n\in\Theta(k)$, and thus $K=|x|=|y|=\Theta(n^{2})$. Furthermore, the only edges in the cut $E(V_{A},V_{B})$ are the edges $(c_{A_{1}},c_{B_{1}})$ and $(c_{A_{2}},c_{B_{2}})$. Since Lemma 6 shows that $\{G_{x,y}\}$ is a family of lower bound graphs, we apply Theorem 6 on the above partition to deduce that any algorithm in the congest model for deciding whether a given graph contains a simple cycle of length $8$ and weight $W=2k^{3}$ requires at least $\Omega(K/\log n)=\Omega(n^{2}/\log n)$ rounds. ∎

6.2 Identical Subgraphs Detection

In this section we show the strongest possible, quadratic lower bound, for a global decision problem which can be solved in linear time in the sequential setting.

Consider the following graph problem.

Definition 2**.**

*(The Identical Subgraphs Detection Problem)

Given a weighted graph $G=(V,E,w)$, a partition $V=V_{A}\dot{\cup}V_{B}$, $\left|V_{A}\right|=\left|V_{B}\right|$, and node labeling $V_{A}=\{a^{0},...,a^{k-1}\}$ and $V_{B}=\{b^{0},...,b^{k-1}\}$, the Identical Subgraphs Detection problem is to determine whether the subgraph induced by $V_{A}$ is identical to the subgraph induced by $V_{B}$, in the sense that for each $i,j\in\left\{0,\ldots,k-1\right\}$ it holds that $(a^{i},a^{j})\in E$ if and only if $(b^{i},b^{j})\in E$ and $w(a^{i},a^{j})=w(b^{i},b^{j})$ if these edges exist.*

The identical subgraphs detection problem can be solved easily in linear time in the sequential setting by a single pass over the set of edges. However, as we prove next, it requires a quadratic number of rounds in the congest model, for any deterministic solution (note that this restriction did not apply in the previous sections). We emphasize that in the distributed setting, the input to each node in $A$ or $B$ in this problem includes its enumeration as $a_{i}$ or $b_{i}$, and the weights of its edges. The outputs of all nodes should be $\operatorname{{\scriptstyle{TRUE}}}$ if the subgraphs are identical, and $\operatorname{{\scriptstyle{FALSE}}}$ otherwise.

Theorem 10**.**

Any deterministic algorithm for solving the identical subgraphs detection problem requires $\Omega(n^{2})$ rounds.

To prove Theorem 10 we describe a family of lower bound graphs.

The fixed graph construction: The fixed graph $G=(V,E)$ is composed of two disjoint cliques on sets of $k$-nodes each, denoted $V_{A}=\{a^{0},...,a^{k-1}\}$ and $V_{B}=\{b^{0},...,b^{k-1}\}$, and one extra edge $(a^{0},b^{0})$ (see Figure 12).

Adding edge weights corresponding to the strings $x$ and $y$: Given two binary strings $x$ and $y$, each of $K=\binom{k}{2}\log n$ bits, augment the graph $G$ with additional edge weights as follows, to define $G_{x,y}$. For simplicity, assume that $x$ and $y$ are vectors of $(\log n)$-bit numbers, each having $\binom{k}{2}$ entries enumerated as $x[i,j]$ and $y[i,j]$, with $i<j$, $i,j\in\left\{0,\ldots,k-1\right\}$. For each such $i$ and $j$ set the weights $w(a^{i},a^{j})=x[i,j]$ and $w(b^{i},b^{j})=y[i,j]$, and set $w(a^{0},b^{0})=0$. Note that $\left\{G_{x,y}\right\}$ is a family of lower bound graphs with respect to $\mathrm{EQ}_{K}$ and the predicate $P$ that says that the subgraphs are identical in the aforementioned sense.

• **Proof of Theorem 10: **

Note that $n\in\Theta(k)$, and thus $K=|x|=|y|=\Theta(n^{2}\log n)$. Furthermore, the only edge in the cut $E(V_{A},V_{B})$ is the edge $(a^{0},b^{0})$. Since $\left\{G_{x,y}\right\}$ is a family of lower bound graphs, we can apply Theorem 6 on the above partition to deduce that because of the lower bound for $\mathrm{EQ}_{K}$, any deterministic algorithm in the congest model for solving the identical subgraphs detection problem requires at least $\Omega(K/\log n)=\Omega(n^{2})$ rounds. ∎

In a deterministic distributed algorithm for the identical subgraphs detection problem running on our family of lower bound graphs, information about essentially all the edges and weights in the subgraphs induced on $V_{A}$ or $V_{B}$ needs to be sent across the edge $(a^{0},b^{0})$. This might raise the suspicion that this problem is reducible to learning the entire graph, making the lower bound trivial. To argue that this is far from being the case, we present a randomized algorithm that solves the identical subgraphs detection problem in $O(D)$ rounds and succeeds w.h.p. This has the additional benefit of providing the strongest possible separation between deterministic and randomized complexities for global decision problems in the congest model, as the former is $\Omega(n^{2})$ and the latter is at most $O(D)$.

Theorem 11**.**

There is a randomized that solves the identical subgraphs detection problem with probability at least $1-O(1/n^{2})$ in $O(D)$ rounds.

Proof.

Our starting point is the following randomized algorithm for the $\mathrm{EQ}_{K}$ problem, presented, e.g., in [68, Exersise 3.6]. Alice chooses a prime number $p$ among the first $K^{2}$ primes uniformly at random. She treats her input string $x$ as a binary representation of an integer $\bar{x}=\sum_{\ell=0}^{K-1}2^{\ell}x_{\ell}$, and sends $p$ and $\bar{x}\pmod{p}$ to Bob. Bob similarly computes $\bar{y}$, compares $\bar{x}\bmod p$ with $\bar{y}\bmod p$, and returns $\operatorname{{\scriptstyle{TRUE}}}$ if they are equal and false otherwise. The error probability of this protocol is at most $1/K$.

We present a simple adaptation of this algorithm for the identical subgraph detection problem. Consider the following encoding of a weighted induced subgraph on $V_{A}$: for each pair $i,j$ of indices, we have $\lceil\log W\rceil+1$ bits, indicating the existence of the edge and its weight (recall that $W\in\operatorname{poly}n$ is the upper bound on the edge weights). This weighted induced subgraph is thus represented by a $K\in O(n^{2}\log n)$ bit-string, denoted $x=x_{0},\ldots,x_{K-1}$, and each pair $(i,j)$ has a set $S_{i,j}$ of indices representing the edge $(a^{i},a^{j})$ and its weight. The bits $\left\{x_{\ell}\mid\ell\in s_{i,j}\right\}$ are known to both $a^{i}$ and $a^{j}$, and in the algorithm we use the node with smaller index in order to encode these bits. Similarly, a $K\in O(n^{2}\log n)$ bit-string, denoted $y=y_{0},\ldots,y_{K-1}$ encodes a weighted induced subgraph on $V_{B}$.

The Algorithm. Given a graph with nodes enumerated as in Definition 2, the algorithm starts with an arbitrary node, say $a^{0}$, and constructs a BFS tree from it, which completes in $O(D)$ rounds. Then, $a^{0}$ chooses a prime number $p$ among the first $K^{2}$ primes uniformly at random and sends $p$ to all the nodes over the tree, in another $O(D)$ rounds.

Each node $a^{i}$ computes the sum $\sum_{j>i}\sum_{\ell\in S_{i,j}}x_{\ell}2^{\ell}\mod p$, and the nodes then aggregate these local sums modulo $p$ up the tree, until $a^{0}$ computes the sum $\bar{x}\mod p=\sum_{j\neq i}\sum_{\ell\in S_{i,j}}x_{\ell}2^{\ell}\mod p$. A similar procedure is then invoked by $a^{0}$ (not by $b^{0}$) w.r.t. $\bar{y}$. Finally, $a^{0}$ compares $\bar{x}\mod p$ and $\bar{y}\mod p$, and downcasts over the BFS tree its output, which is $\operatorname{{\scriptstyle{TRUE}}}$ if these values are equal and is $\operatorname{{\scriptstyle{FALSE}}}$ otherwise.

If the subgraphs are identical, $a^{0}$ always returns $\operatorname{{\scriptstyle{TRUE}}}$, while otherwise their encoding differs in at least one bit, and as in the case of $\mathrm{EQ}_{K}$, $a^{0}$ returns $\operatorname{{\scriptstyle{TRUE}}}$ falsely with probability at most $1/K\in O(1/n^{2})$. ∎

A more artificial problem can give even a larger gap: given the labeled graph $G$ defined in our lower bound construction with a weight function satisfying $w(a^{0},a^{j})=0$ and $w(b^{0},b^{j})=0$ for all $j$, the balanced hourglass problem is to determine whether $w(a^{i},a^{j})=w(b^{i},b^{j})$ for all $i,j\in\left\{0,\ldots,k-1\right\}$ (see Figure 13) The same lower and upper bounds hold: for the lower bound, the inputs are of $\binom{k-1}{2}\log n$ bits, which is asymptotically the same; for the upper bound, we get $O(D)=O(1)$. Thus, this problem gives asymptotically the maximal possible gap for any decision in the congest model.

7 Weighted APSP

In this section we use the following, natural extension of Definition 1, in order to address more general 2-party functions, as well as distributed problems that are not decision problems.

For a function $f:\left\{0,1\right\}^{K_{1}}\times\left\{0,1\right\}^{K_{2}}\to\left\{0,1\right\}^{L_{1}}\times\left\{0,1\right\}^{L_{2}}$, we define a family of lower bound graphs in a similar way as Definition 1, except that we replace item 3 in the definition with a generalized requirement that says that for $G_{x,y}$, the values of the of nodes in $V_{A}$ uniquely determine the left-hand side of $f(x,y)$, and the values of the of nodes in $V_{B}$ uniquely determine the right-hand side of $f(x,y)$. Next, we argue that theorem similar to Theorem 6 holds for this case.

Theorem 12**.**

Fix a function $f:\left\{0,1\right\}^{K_{1}}\times\left\{0,1\right\}^{K_{2}}\to\left\{0,1\right\}^{L_{1}}\times\left\{0,1\right\}^{L_{2}}$ and a graph problem $P$. If there is a family $\left\{G_{x,y}\right\}$ of lower bound graphs with $C=E(V_{A},V_{B})$ then any deterministic algorithm for solving $P$ requires $\Omega(\operatorname{CC}(f)/\left|C\right|\log n)$ rounds, and any randomized algorithm for deciding $P$ requires $\Omega(\operatorname{CC}^{R}(f)/\left|C\right|\log n)$ rounds.

The proof is similar to that of Theorem 6. Notice that the only difference between the theorems, apart from the sizes of the inputs and outputs of $f$, are with respect to item 3 in the definition of a family of lower bound graphs. However, the essence of this condition remains the same and this is all that is required for the proof: The values that a solution to $P$ assigns to nodes in $V_{A}$ determine the output of Alice for $f(x,y)$, and the values that a solution assigns to nodes in $V_{B}$ determine the output of Bob.

7.1 A Linear Lower Bound for Weighted APSP

Nanongkai [78] showed that any algorithm in the congest model for computing a $\operatorname{poly}(n)$-approximation for weighted all pairs shortest paths (APSP) requires at least $\Omega(n/\log n)$ rounds. In this section we show that a slight modification to this construction yields an $\Omega(n)$ lower bound for computing exact weighted APSP. As explained in the introduction, this gives a separation between the complexities of the weighted and unweighted versions of APSP. At a high level, while we use the same simple topology for our lower bound as in [78], the reason that we are able to shave off the extra logarithmic factor is because our construction uses $O(\log{n})$ bits for encoding the weight of each edge out of many optional weights, while in [78] only a single bit is used per edge for encoding one of only two options for its weight.

Theorem 13**.**

Any algorithm for computing weighted all pairs shortest paths requires at least $\Omega(n)$ rounds.

The reduction is from the following, perhaps simplest, two-party communication problem. Alice has an input string $x$ of size $K$ and Bob needs to learn the string of Alice. In terms of the above definition, this problem is computing the function $f:\left\{0,1\right\}^{K}\times\left\{0,1\right\}^{0}\to\left\{0,1\right\}^{0}\times\left\{0,1\right\}^{K}$ defined by $f(x,\bot)=(\bot,x)$. Any algorithm (possibly randomized) for solving this problem requires at least $\Omega(K)$ bits of communication, by a trivial information theoretic argument.

Notice that the problem of having Bob learn Alice’s input is not a binary function as addressed in Section 2. Similarly, computing weighted APSP is not a decision problem, but rather a problem whose solution assigns a value to each node (which is its vector of distances from all other nodes). We therefore use the extended Theorem 12 stated above.

The fixed graph construction: The fixed graph $G=(V,E)$ is composed of $n-2$ integers, $A=\{a_{0},...,a_{n-3}\}$, all connected to an additional node $a$, which is connected to another node $b$. Set $V_{A}=A\cup\left\{a\right\}$ and $V_{B}=\left\{b\right\}$.

Adding edge weights corresponding to the string $x$: Given a binary string $x$ of size $K=(n-2)\log n$, assume for simplicity that $x$ is a vector of $n-2$ numbers, each represented by $O(\log n)$ bits. To define $G_{x}$, add to $G$ the edge weights $w(a^{i},a)=x[i]$ for $i\in\left\{0,\ldots,n-3\right\}$, and $w(a,b)=0$. It is straightforward to see that $G_{x}$ is a family of lower bound graphs for the function $f$.

• **Proof of Theorem 13: **

To prove Theorem 13, note that $K=|x|=\Theta(n\log n)$, and that the cut $E(V_{A},V_{B})$ has a single edge, $(a,b)$. Since $\{G_{x}\}$ is a family of lower bound graphs with respect to $f$ on $K$ bits, Theorem 12 implies that any algorithm in the congest model for computing weighted APSP requires $\Omega(K/\log n)=\Omega(n)$ rounds. ∎

7.2 The Alice-Bob Framework Cannot Give a Super-Linear Lower Bound for Weighted APSP

In this section we argue that a reduction from any 2-party function with a fixed partition of the graph into Alice and Bob’s sides is incapable of providing a super-linear lower bound for computing weighted all pairs shortest paths in the congest model. A more detailed inspection of our analysis shows a stronger claim: our claim also holds for algorithms for the congest-broadcast model, where in each round each node must send the same $O(\log{n})$-bit message to all of its neighbors. The following theorem states our claim.

Theorem 14**.**

Let $f:\left\{0,1\right\}^{K_{1}}\times\left\{0,1\right\}^{K_{2}}\to\left\{0,1\right\}^{L_{1}}\times\left\{0,1\right\}^{L_{2}}$ be a function and let $G_{x,y}$ be a family of lower bound graphs w.r.t. $f$ and the weighted APSP problem. When applying Theorem 12 to $f$ and $G_{x,y}$, the lower bound obtained for the number of rounds for computing weighted APSP is at most linear in $n$.

Roughly speaking, we show that given an input graph $G=(V,E)$ with a partition $V=V_{A}\dot{\cup}V_{B}$, such that the graph induced by the nodes in $V_{A}$ is simulated by Alice and the graph induced by nodes in $V_{B}$ is simulated by Bob, Alice and Bob can compute weighted all pairs shortest paths by communicating $O(n\log n)$ bits of information for each node touching the cut $C=E(V_{A},V_{B})$ induced by the partition. In this way, we show that any attempt to apply Theorem 12 cannot give a lower bound higher than $\Omega(n)$: we consider an arbitrary function $f$, and an arbitrary family of lower bound graphs with respect to a function $f$ and the weighted APSP problem, defined according to the extended definition from the beginning of Section 7. We then prove that Alice and Bob can compute weighted APSP, which determines their output for $f$, by exchanging only $O(|V(C)|n\log n)$ bits, where $V(C)$ is the set of nodes touching $C$. This implies that $\operatorname{CC}(f)$ is at most $O(|V(C)|n\log n)$. Thus, the lower bound obtained by Theorem 12 cannot be better than $\Omega(n)$, and hence no super-linear lower can be deduced by this framework.

Formally, given a graph $G=(V_{A}\dot{\cup}V_{B},E)$, let $G_{A}=(V_{A},E_{A})$ be the subgraph induced by the nodes in $V_{A}$ and let $G_{B}=(V_{B},E_{B})$ be the subgraph induced by the nodes in $V_{B}$ (see Figure 14(a)). Let $C=E(V_{A},V_{B})$, and let $V(C)$ denote the nodes touching the cut $C$, with $C_{A}=V(C)\cap V_{A}$ and $C_{B}=V(C)\cap V_{B}$. For a graph $H$, denote the weighted distance between two nodes $u,v$ by $\operatorname{wd}_{H}(u,v)$.

Lemma 7**.**

Let $G=(V_{A}\dot{\cup}V_{B},E,w)$ be a weighted graph. Suppose that $G_{A}$, $C_{B}$, $C$ and the values of $w$ on $E_{A}$ and $C$ are given as input to Alice, and that $G_{B}$, $C_{A}$, $C$ and the values of $w$ on $E_{B}$ and $C$ are given as input to Bob.

Then, Alice can compute the distances in $G$ from all nodes in $V_{A}$ to all nodes in $V$ and Bob can compute the distances from all nodes in $V_{B}$ to all the nodes in $V$, using $O(\left|V(C)\right|n\log n)$ bits of communication.

Proof.

We describe a protocol for the required computation. For each node $u\in C_{B}$, Bob sends to Alice the weighted distances in $G_{B}$ from $u$ to all nodes in $V_{B}$, that is, Bob sends $\{\operatorname{wd}_{G_{B}}(u,v)\mid u\in C_{B},v\in V_{B}\}$ (or $\infty$ for pairs of nodes not connected in $G_{B}$). Alice constructs a virtual graph $G_{A}^{\prime}=(V_{A}^{\prime},E_{A}^{\prime},w_{A}^{\prime})$ (see Figure 14(b)) with the nodes $V_{A}^{\prime}=V_{A}\cup C_{B}$ and edges $E_{A}^{\prime}=E_{A}\cup C\cup(C_{B}\times C_{B})$. The edge-weight function $w_{A}^{\prime}$ is defined by $w_{A}^{\prime}(e)=w(e)$ for each $e\in E_{A}\cup C$, and by $w_{A}^{\prime}(u,v)=w_{G_{B}}(u,v)$ for $u,v\in C_{B}$, as received from Bob. Alice then computes the set of all weighted distances in $G_{A}^{\prime}$, $\{\operatorname{wd}_{G_{A}^{\prime}}(u,v)\mid u,v\in V_{A}^{\prime}\}$.

Alice assigns her output for the weighted distances in $G$ as follows (see Figure 14(c)). For two nodes $u,v\in V_{A}\cup C_{B}$, Alice outputs their weighted distance in $G_{A}^{\prime}$, $\operatorname{wd}_{G_{A}^{\prime}}(u,v)$. For a node $u\in V_{A}^{\prime}$ and a node $v\in V_{B}\setminus C_{B}$, Alice outputs $\min\{\operatorname{wd}_{G_{A}^{\prime}}(u,x)+\operatorname{wd}_{G_{B}}(x,v)\mid x\in C_{B}\}$, where $\operatorname{wd}_{G_{A}^{\prime}}$ is the distance in $G_{A}^{\prime}$ as computed by Alice, and $\operatorname{wd}_{G_{B}}$ is the distance in $G_{B}$ that was sent by Bob.

For Bob to compute his required weighted distances, similar information is sent by Alice to Bob, that is, Alice sends to Bob the weighted distances in $G_{A}$ from each node $u\in C_{A}$ to all nodes in $V_{A}$. Bob constructs the analogous graph $G_{B}^{\prime}$ and outputs his required distance. The next paragraph formalizes this for completeness, but may be skipped by a convinced reader.

Formally, Alice sends $\{\operatorname{wd}_{G_{A}}(u,v)\mid u\in C_{A},v\in V_{A}\}$. Bob constructs $G_{B}^{\prime}=(V_{B}^{\prime},E_{B}^{\prime},w_{B}^{\prime})$ with $V_{B}^{\prime}=V_{B}\cup C_{A}$ and edges $E_{B}^{\prime}=E_{B}\cup C\cup(C_{A}\times C_{A})$. The edge-weight function $w_{B}^{\prime}$ is defined by $w_{B}^{\prime}(e)=w(e)$ for each $e\in E_{B}\cup C$, and $w_{B}^{\prime}(u,v)$ for $u,v\in C_{A}$ is defined to be the weighted distance between $u$ and $v$ in $G_{A}$, as received from Alice (or $\infty$ if they are not connected in $G_{A}$). Bob then computes the set of all weighted distances in $G_{B}^{\prime}$, $\{\operatorname{wd}_{G_{B}^{\prime}}(u,v)\mid u,v\in V_{B}^{\prime}\}$. Bob assigns his output for the weighted distances in $G$ as follows. For two nodes $u,v\in V_{B}\cup C_{A}$, Bob outputs their weighted distance in $G_{B}^{\prime}$, $\operatorname{wd}_{G_{B}^{\prime}}(u,v)$. For a node $u\in V_{B}^{\prime}$ and a node $v\in V_{A}\setminus C_{A}$, Bob outputs $\min\{\operatorname{wd}_{G_{B}^{\prime}}(u,x)+\operatorname{wd}_{G_{A}}(x,v)\mid x\in C_{A}\}$, where $\operatorname{wd}_{G_{B}^{\prime}}$ is the distance in $G_{B}^{\prime}$ as computed by Bob, and $\operatorname{wd}_{G_{A}}$ is the distance in $G_{A}$ that was sent by Alice.

Complexity. Bob sends to Alice the distances from all nodes in $C_{B}$ to all node in $V_{B}$, which takes $O(\left|C_{B}\right|\left|V_{B}\right|\log n)$ bits, and similarly Alice sends $O(\left|C_{A}\right|\left|V_{A}\right|\log n)$ bits to Bob. Since $\left|V_{A}\right|\leq n$, $\left|V_{B}\right|\leq n$ and $\left|C_{A}\right|+\left|C_{B}\right|=\left|V(C)\right|$, we have $\left|C_{B}\right|\left|V_{B}\right|\log n+\left|C_{A}\right|\left|V_{A}\right|\log n\leq\left(\left|C_{A}\right|+\left|C_{B}\right|\right)n\log n=\left|V(C)\right|n\log n$, and the players exchange a total of $O(\left|V(C)\right|n\log n)$ bits.

Correctness. By construction, for every edge $(u,v)\in C_{B}\times C_{B}$ in $G_{A}^{\prime}$ with weight $\operatorname{wd}_{G_{A}^{\prime}}(u,v)$, there is a corresponding shortest path $P_{u,v}$ of the same weight in $G_{B}$. Hence, for any path $P^{\prime}=(v_{0},v_{1},\ldots,v_{k})$ in $G_{A}^{\prime}$ between $v_{0},v_{k}\in V_{A}^{\prime}$, there is a corresponding path $P_{v_{0},v_{k}}$ of the same weight in $G$, where $P$ is obtained from $P^{\prime}$ by replacing every two consecutive nodes $v_{i},v_{i+1}$ in $P\cap C_{B}$ by the path $P_{v_{i},v_{i+1}}$ in $G_{B}$. Thus, $\operatorname{wd}_{G_{A}^{\prime}}(v_{0},v_{k})\geq\operatorname{wd}_{G}(v_{0},v_{k})$.

On the other hand, for any shortest path $P=(v_{0},v_{1},\ldots,v_{k})$ in $G$ connecting $v_{0},v_{k}\in V_{A}^{\prime}$, there is a corresponding path $P^{\prime}$ of the same weight in $G_{A}^{\prime}$, where $P^{\prime}$ is obtained from $P$ by replacing any sub-path $(v_{i},\ldots,v_{j})$ of $P$ contained in $G_{B}$ and connecting $v_{i},v_{j}\in C_{B}$ by the edge $(v_{i},v_{j})$ in $G_{A}^{\prime}$. Thus, $\operatorname{wd}_{G}(v_{0},v_{k})\geq\operatorname{wd}_{G_{A}^{\prime}}(v_{0},v_{k})$. Alice thus correctly computes the weighted distances between pairs of nodes in $V_{A}^{\prime}$.

It remains to argue about the weighted distances that Alice computes to nodes in $V_{B}\setminus C_{B}$. Any shortest path $P$ in $G$ connecting a node $u\in V_{A}^{\prime}$ and a node $v\in V_{B}\setminus C_{B}$ must cross at least one edge of $C$ and thus must contain a node in $C_{B}$. Therefore, $\operatorname{wd}_{G}(u,v)=\min\{\operatorname{wd}_{G}(u,x)+\operatorname{wd}_{G}(x,v)\mid x\in C_{B}\}$. Recall that we have shown that $\operatorname{wd}_{G_{A}^{\prime}}(u,x)=\operatorname{wd}_{G}(u,x)$ for any $u,x\in V_{A}^{\prime}$. The sub-path of $P$ connecting $x$ and $v$ is a shortest path between these nodes, and is contained in $G_{B}$, so $\operatorname{wd}_{G_{B}}(x,v)=\operatorname{wd}_{G}(x,v)$. Hence, the distance $\min\{\operatorname{wd}_{G_{A}^{\prime}}(u,x)+\operatorname{wd}_{G_{B}}(x,v)\mid x\in C_{B}\}$ returned by Alice is indeed equal to $\operatorname{wd}_{G}(u,v)$.

The outputs of Bob are correct by an analogous arguments, completing the proof. ∎

• **Proof of Theorem 14: **

Let $f:\left\{0,1\right\}^{K_{1}}\times\left\{0,1\right\}^{K_{2}}\to\left\{0,1\right\}^{L_{1}}\times\left\{0,1\right\}^{L_{2}}$ be a function and let $G_{x,y}$ be a family of lower bound graphs w.r.t. $f$ and the weighted APSP problem. By Lemma 7, Alice and Bob can compute the weighted distances for any graph in $G_{x,y}$ while exchanging at most $O(|V(C)|n\log{n})$ bits, which is in $O(|C|n\log{n})$ bits. Since $G_{x,y}$ is a family of lower bound graphs w.r.t. $f$ and weighted APSP, item 3 in the definition of lower bound graphs implies that they can use the solution of the APSP problem to compute $f$ without further communication, implying $\operatorname{CC}(f)=O(\left|C\right|n\log n)$. Therefore, when applying Theorem 12 to $f$ and $G_{x,y}$, the lower bound obtained for the number of rounds for computing weighted APSP is $\Omega(\operatorname{CC}(f)/|C|\log{n})$, which is no higher than a bound of $\Omega(n)$. ∎

Extending to $t$ players: We argue that generalizing the Alice-Bob framework to a shared-blackboard multi-party setting is still insufficient for providing a super-linear lower bound for weighted APSP. Suppose that we increase the number of players in the above framework to $t$ players, $P_{0},\dots,P_{t-1}$, each simulating the nodes in a set $V_{i}$ in a partition of $V$ in a family of lower bound graphs w.r.t. a $t$-party function $f$ and weighted APSP. That is, the outputs of nodes in $V_{i}$ for an algorithm $ALG$ for solving a problem $P$ in the congest model, uniquely determines the output of player $P_{i}$ in the function $f$. The function $f$ is of the form $f:\{0,1\}^{K_{0}}\times\cdots\times\{0,1\}^{K_{t-1}}\to\{0,1\}^{L_{0}}\times\cdots\times\{0,1\}^{L_{t-1}}$.

The communication complexity $\operatorname{CC}(f)$ is the total number of bits written on the shared blackboard by all players. Denote by $C$ the set of cut edges, that is, the edge whose endpoints do not belong to the same set $V_{i}$. Then, if $ALG$ is an $R$-round algorithm, we have that writing $O(R|C|\log{n})$ bits on the shared blackboard suffice for computing $f$, and so $R=\Omega(\operatorname{CC}(f)/|C|\log{n})$.

Consider the weighted APSP problem. Let $f$ be a $t$-party function and let $G_{x_{0},\dots,x_{t-1}}$ be a family of lower bound graphs w.r.t. $f$ and weighted APSP. The players first write all the edges in $C$ on the shared blackboard, for a total of $O(|C|\log{n})$ bits. Then, each player $P_{i}$ writes the weighted distances from all nodes in $V_{i}$ to all nodes in $V(C)\cap V_{i}$. This requires no more than $O(|V(C)|n\log{n})$ bits.

It is easy to verify that every player $P_{i}$ can now compute the weighted distances from all nodes in $V_{i}$ to all nodes in $V$, in a manner that is similar to that of Lemma 7.

This gives an upper bound on $\operatorname{CC}(f)$, i.e. $\operatorname{CC}(f)=O(\left|V(C)\right|n\log n)$. A lower bound obtained by a reduction from $f$ is $\Omega(\operatorname{CC}(f)/|C|\log{n})$, which is no larger than $\Omega(|V(C)|n\log{n}/(|C|\log{n}))$. But $|V(C)|\leq 2|C|$, so the lower bound cannot actually be larger than $\Omega(n)$, as claimed.

Remark 1: Notice that the $t$-party simulation of the algorithm for the congest model does not require a shared blackboard and can be done in the peer-to-peer multiparty setting as well, since simulating the delivery of a message does not require the message to be known globally. This raises the question of why would one consider a reduction to the congest model from the stronger shared-blackboard model to begin with. Notice that our argument for $t$ players does not translate to the peer-to-peer multiparty setting, because it assumes that the edges of the cut $C$ can be made global knowledge within writing $|C|\log{n}$ bits on the blackboard. However, what our extension above shows is that if there is a lower bound that is to be obtained using a reduction from peer-to-peer $t$-party computation, it must use a function $f$ that is strictly harder to compute in the peer-to-peer setting than in the shared-blackboard setting.

Remark 2: We suspect that a similar argument can be applied for the framework of non-fixed Alice-Bob partitions (e.g., [89]), but this requires precisely defining this framework, which we do not addressed in this paper.

8 Streaming Lower Bounds

In this section we show how our super-linear lower bound constructions can be used to prove lower bounds in the streaming model in a straightforward manner. We start by defining a family of lower bound graphs for the semi-streaming model.

Definition 3**.**

*(Family of Streaming Lower Bound Graphs)

Fix an integer $K$, a function $f:\left\{0,1\right\}^{K}\times\left\{0,1\right\}^{K}\to\left\{\operatorname{{\scriptstyle{TRUE}}},\operatorname{{\scriptstyle{FALSE}}}\right\}$ and a graph predicate $P$. A family of graphs $\left\{G_{x,y}=(V,E_{x,y})\mid x,y\in\left\{0,1\right\}^{K}\right\}$ with a partition of the edges $E=E_{A}\dot{\cup}E_{B}$ is said to be a family of streaming lower bound graphs w.r.t. $f$ and $P$ if the following properties hold:*

Only the existence of edges in $E_{A}$ may depend on $x$; 2. 2.

Only the existence of edges in $E_{B}$ may depend on $y$; 3. 3.

$G_{x,y}$* satisfies the predicate $P$ iff $f(x,y)=\operatorname{{\scriptstyle{TRUE}}}$.*

This definition is a variant of Definition 1. Unsurprisingly, the existence of such a family implies a lower bound in a way similar to Theorem 6, as stated next. Note that for the semi-streaming model, the cut size does not play a role.

Theorem 15**.**

Fix a function $f:\left\{0,1\right\}^{K}\times\left\{0,1\right\}^{K}\to\left\{\operatorname{{\scriptstyle{TRUE}}},\operatorname{{\scriptstyle{FALSE}}}\right\}$ and a predicate $P$. If there is a family $\{G_{x,y}\}$ of streaming lower bound graphs w.r.t. $f$ and $P$ then any semi-streaming algorithm for deciding $P$ in $R$ passes and $M$ bits of memory requires $RM=\Omega(\operatorname{CC}(f))$ rounds, and any randomized semi-streaming algorithm for deciding $P$ in $R$ passes and $M$ bits of memory requires $RM=\Omega(\operatorname{CC}^{R}(f))$ rounds.

Proof.

Let $ALG$ be a semi streaming algorithm for deciding $P$ in $R$ passes and $M$ bits of memory. Given inputs $x,y\in\left\{0,1\right\}^{K}$ to Alice and Bob, respectively, Alice and Bob simulate the execution of the algorithms, as follows. To simulate a pass of the algorithm, Alice executes the algorithm using the edges of $E_{A}$ as input—she can do so since these edges depend only on $x$. Alice then sends the current state of the memory to Bob, who continues the execution of $ALG$ from the point where Alice stopped, using the edges of $E_{B}$ as input—he can do so since these edges depend only on $y$. This concludes a simulation of a single pass; if there are more passes left, Bob sends the current memory state to Alice, who continues the execution from this state. Otherwise, Bob knows the value of $P$, and by Item 3 in Definition 3, he can compute $f(x,y)$.

To simulate a pass, Alice sent to Bob at most $M$ bits, and in all passes but the last, Bob sent Alice another $M$ memory bits at the most. This sums to $R(2M-1)$ bits of communication, using which the players have computed $f(x,y)$ correctly. The lower bounds follows directly from the lower bounds for $\operatorname{CC}(f)$ and $\operatorname{CC}^{R}(f)$. ∎

Any family of lower bound graphs for the congest model is also a family of streaming lower bound graphs: use exactly the same graphs, and set $E_{A}$ to be the edges in $V_{A}\times V_{A}$ and in $C$, and $E_{B}$ be the edges in $V_{B}\times V_{B}$. This implies the following, simple corollary.

Corollary 1**.**

Fix a function $f:\left\{0,1\right\}^{K}\times\left\{0,1\right\}^{K}\to\left\{\operatorname{{\scriptstyle{TRUE}}},\operatorname{{\scriptstyle{FALSE}}}\right\}$ and a predicate $P$. If there is a family $\{G_{x,y}\}$ of lower bound graphs for the congest model w.r.t. $f$ and $P$ then any semi-streaming algorithm for deciding $P$ using $R$ passes and $M$ bits of memory requires $RM=\Omega(\operatorname{CC}(f))$ rounds, and any randomized semi-streaming algorithm for deciding $P$ using $R$ passes and $M$ bits of memory requires $RM=\Omega(\operatorname{CC}^{R}(f))$ rounds.

With this corollary in hand, the lower bounds from Section 5 easily extend to a series of lower bounds in the semi-streaming model.

Theorem 16**.**

Any algorithm in the semi-streaming model for the following problems that uses $R$ passes and $M$ bits of memory requires $RM=\Omega(n^{2})$.

Computing a minimum vertex cover or deciding whether there is a minimum vertex cover of a given size. 2. 2.

Computing a maximum independent set or deciding whether there is an independent set of a given size. 3. 3.

Computing a maximum clique or deciding whether there is a clique of a given size. 4. 4.

Computing a coloring of a graph with a minimal number of colors or deciding whether there is a coloring with a given number of colors. 5. 5.

Deciding if a graph contains an $8$-cycle of a given weight. 6. 6.

Deterministically deciding the identical subgraphs detection problem.

In addition, any such algorithm for deciding whether a graph is $c$-colorable, for an input parameter $3\leq c<n$ that may depend on $n$, requires $RM=\Omega((n-c)^{2})$, and any algorithm distinguishing $\chi(G)\leq 3c$ from $\chi(G)\geq 4c$, for $c=c(n)\geq 3$, requires $RM=\Omega((n/c)^{2})$.

Proof.

Theorem 16 is obtained from Corollary 1 and the constructions from Sections 5 and 6.

Item 1 follows from the lower bound graph of Section 5.1, as proven in Lemma 4. Item 2 follows from the same lemma, as the complement of a minimum vertex cover is a maximum independent set.

For Item 3, consider the complement graph of the graph from Lemma 4: a graph with the same node set but complement edges. An independent set translates into a clique in the complement graph, each non-edge is either fixed, depends solely on Alice’s input, or depends solely on Bob’s input, and so the complement graph is a family of lower bound graph w.r.t. $\mathrm{DISJ}$ and maximum clique. Theorem 15 completes the proof.

Item 4 follows from the construction in Section 5.2, and specifically from Lemma 5. Item 5 follows from the construction in Section 6.1, and specifically from Lemma 6. Item 6 follows from the construction in Section 6.2, and specifically from the proof of Theorem 10. In all these cases, the communication complexity problem is $\mathrm{DISJ}_{K}$, where $K\in\Theta(n^{2})$.

The $c$-coloring lower bound follows the construction in the proof of Claim 9, where $K\in\Theta((n-c)^{2})$. The result for distinguishing $\chi(G)\leq 3c$ from $\chi(G)\geq 4c$ follows from the proof of Claim 10, where $K\in\Theta\left((n/c)^{2}\right)$. ∎

9 Discussion

We introduced the bit-gadget, a powerful tool for constructing graphs with small cuts. Using the bit-gadget, we were able to prove new lower bounds for the congest model for fundamental graph problems, such as computing the exact or approximate diameter, radius, minimum vertex cover, and the chromatic number of a graph.

Our lower bound for computing the radius answers an open question that was raised by Holzer and Wattenhofer[58]. Notably, our lower bound for computing the diameter implies a large gap between the complexity of computing a ($3/2$)-approximation, which can be done in $\widetilde{O}(\sqrt{n})$ rounds[56], and the complexity of computing a ($3/2-\epsilon$)-approximation, which we show to require $\widetilde{\Omega}(n)$ rounds. As there are no known lower bounds for computing a ($3/2$)-approximation, an intriguing open question that immediately arises is the complexity of ($3/2$)-approximation.

Furthermore, our bit-gadget allows us to show the first super-linear lower bounds for the congest model, raising a plethora of open questions. First, we showed for some specific problems, namely, computing a minimum vertex cover, a maximum independent set and a $\chi$-coloring, that they are nearly as hard as possible for the congest model. However, we know that approximate solutions for some of these problems can be obtained much faster, in a polylogarithmic number of rounds or even less. For vertex cover, our lower bound can easily be amplified to any constant additive approximation444We thank David Wajc for pointing this out., but this also leaves huge gaps in our understanding of the trade-offs between approximation factors and efficiency for this problem. Thus, a family of specific open questions is to characterize the exact trade-offs between approximation factors and round complexities for various optimization problems.

Finally, we propose a more general open question which addresses a possible classification of complexities of global problems in the congest model. Some such problems have complexities of $\Theta(D)$, such as constructing a BFS tree. Others have complexities of $\tilde{\Theta}(D+\sqrt{n})$, such as finding an MST. Some problems have near-linear complexities, such as unweighted APSP. And now we know about the family of hardest problems for the congest model, whose complexities are near-quadratic. Do these complexities capture all possibilities, as far as natural global graph problems are concerned? Or are there such problems with a complexity of, say, $\Theta(n^{1+\delta})$, for some constant $0<\delta<1$? A similar question was recently addressed in [30] for LCL problems the local model, and we propose investigating the possibility that such a hierarchy exists for the congest model for certain classes of problems.

Acknowledgement: We are grateful to Yuval Emek for many discussions and fruitful comments about the connection between communication complexity and streaming lower bounds, and for pointing out that our technique can be useful for streaming models. We also thank Ohad Ben Baruch, Michael Elkin, Yuval Filmus, Merav Parter and Christoph Lenzen for useful discussions.