Connectivity Lower Bounds in Broadcast Congested Clique

We prove three new lower bounds for graph connectivity in the $1$-bit broadcast congested clique model, BCC$(1)$. First, in the KT-$0$ version of BCC$(1)$, in which nodes are aware of neighbors only through port numbers, we show an $\Omega(\log n)$ round lower bound for CONNECTIVITY even for constant-error randomized Monte Carlo algorithms. The deterministic version of this result can be obtained via the well-known"edge-crossing"argument, but, the randomized version of this result requires establishing new combinatorial results regarding the indistinguishability graph induced by inputs. In our second result, we show that the $\Omega(\log n)$ lower bound result extends to the KT-$1$ version of the BCC$(1)$ model, in which nodes are aware of IDs of all neighbors, though our proof works only for deterministic algorithms. Since nodes know IDs of their neighbors in the KT-$1$ model, it is no longer possible to play"edge-crossing"tricks; instead we present a reduction from the 2-party communication complexity problem PARTITION in which Alice and Bob are give two set partitions on $[n]$ and are required to determine if the join of these two set partitions equals the trivial one-part set partition. While our KT-$1$ CONNECTIVITY lower bound holds only for deterministic algorithms, in our third result we extend this $\Omega(\log n)$ KT-1 lower bound to constant-error Monte Carlo algorithms for the closely related CONNECTED COMPONENTS problem. We use information-theoretic techniques to obtain this result. All our results hold for the seemingly easy special case of CONNECTIVITY in which an algorithm has to distinguish an instance with one cycle from an instance with multiple cycles. Our results showcase three rather different lower bound techniques and lay the groundwork for further improvements in lower bounds for CONNECTIVITY in the BCC$(1)$ model.


Introduction
We are given an n-node, completely connected communication network in which each node can broadcast at most b bits in each round. These n nodes and a subset of the edges of the communication network form the input graph. The question we ask is this: how many rounds of communication does it take to determine if the input graph is connected? This is the well known Connectivity problem in the b-bit Broadcast Congested Clique, i.e., the BCC(b) model.
A series of recent rapid improvements [9,11,14] have shown that Connectivity and in fact minimum spanning tree (MST), can be solved in O(1) rounds w.h.p. 1 in the b-bit Congested Clique model, CC(b), when b = log n. The CC(b) model allows each node to send a possibly different b-bit message to each of the other n − 1 nodes in the network, in each round. In contrast, the fastest known algorithm for Connectivity in the BCC(log n) model, due to Jurdziński and Nowicki [13], is deterministic and it runs in O log n log log n rounds. This contrast between BCC(b) and CC(b) is not surprising, given how much larger the overall bandwidth in CC(b) is compared to BCC(b). Becker et al. [3] show that the pair-wise set disjointness problem can be solved in O(1) rounds in CC(1), but needs Ω(n) rounds in BCC(1). But, despite the fact that Connectivity is such a fundamental problem, no non-trivial lower bound is known for Connectivity in BCC(1). In fact, prior to this paper, we could not even rule out an O(1)-round Connectivity algorithm in BCC(1).
Lower bound arguments in "congested" distributed computing models typically use a "bottleneck" technique [4][5][6][7][8]12]. At a high level, this technique consists of showing that there is a low bandwidth cut in the communication network across which a high volume of information has to flow in order to solve the given problem. The lower bound on information flow is usually obtained via 2-party communication complexity lower bounds [16]. Not surprisingly, the "bottleneck" technique does not work in the CC(b) model because any cut with Θ(n) vertices in each part, has a high bandwidth of Θ(n 2 · b) bits. In fact, a result of Drucker et al. [7], showing that circuits can be simulated efficiently in the Congested Clique model, indicates that no technique we currently know of can prove nontrivial lower bounds in the CC(b) model. However, as further shown by [7], "bottlenecks" are possible for some problems in the weaker BCC(b) model. In this model, every cut has bandwidth O(n · b) and for example Drucker et al. [7] provide a reduction showing that for the problem of detecting the presence of a K 4 in the input graph there is a cut across which Ω(n 2 ) information has to flow. This leads to an Ω(n/b) lower bound for K 4 -detection in the BCC(b).
All known lower bounds [7,12] in the BCC(log n) model have this general structure and these techniques work for problems such as fixed subgraph detection, all pairs shortest paths, diameter computation, etc., that are relatively difficult, requiring polynomially many rounds to solve. For "simpler" problems such as Connectivity and MST, we need lower bound techniques that allow us to prove polylogarithmic lower bounds. Specifically, since Connectivity can be solved in BCC(b) for any b ≥ 1 in just O(poly(log n)) rounds, the best we can expect is to show the existence of a cut across which Ω(n · poly(log n)) volume of information needs to flow. In fact, the connected components of a subgraph can be represented in O(n log n) bits and this is all that needs to communicated across a cut to solve Connectivity. Thus the best lower bound we can expect for Connectivity via this technique is an Ω(log n/b). However, even this was unknown prior to this paper and one contribution of this paper is an Ω(log n/b) lower bound for Connectivity using the "bottleneck" technique. The reader is encouraged to refer to the full version of this paper available on arxiv [19] for all proofs and other technical details.

Our Contributions
We consider the Connectivity problem and the closely related ConnectedComponents problem in the BCC(1) model. In the latter problem, each node needs to output the label of the connected component it belongs to. We work in the BCC(1) model because it allows us to isolate barriers due to different levels of initial local knowledge (e.g., knowing IDs of neighbors vs not knowing IDs). This is also without loss of generality because a t-round lower bound in BCC(1) immediately translates to a t/b-round lower bound in BCC(b). We consider two natural versions of the BCC(1) model, that we call KT-0 and KT-1 (using notation from [1]). In the KT-0 ("Knowledge Till 0 hops") version, nodes are unaware of IDs of other nodes in the network and the n − 1 communication ports at each node are arbitrarily numbered 1 through n − 1. In the KT-1 ("Knowledge Till 1 hop") version, nodes know all n IDs in the network and the n − 1 communication ports at each node are respectively labeled with the IDs of the nodes at the other end of the port. Note that if the bandwidth b = Ω(log n), then there is essentially no distinction between the KT-0 and KT-1 versions since each node in the KT-0 version can send its ID to neighbors in constant rounds and then nodes would have as much knowledge as they initially do in the KT-1 version. But the difference in initial knowledge plays a critical role when b = o(log n) and in fact our best results in these two models use completely different techniques. We present three main lower bound results in this paper, derived using very different techniques.

Randomized KT-0 Lower Bounds
In the KT-0 version of BCC(1) we show an Ω(log n) round lower bound for Connectivity even for constant-error randomized Monte Carlo algorithms. In fact, the lower bound is shown for the seemingly simpler "one cycle vs two cycles" problem in which the input graph is either a single cycle or consists of two disjoint cycles and the algorithm has to distinguish between these two possibilities. We use a well-known indistinguishability argument involving "edge crossing" [2,15,20] for this result, but the main novelty here is how this argument deals with the possibility that the algorithm can err on a constant fraction of the input instances. In a standard edge crossing argument one shows that for a particular YES instance (i.e., a connected or "one-cycle" instance) G, many of the NO instances G(e, e ′ ) obtained by crossing pairs of edges e and e ′ in G cannot be distinguished even after some t rounds of a BCC(1) algorithm. But for a randomized lower bound in BCC(1), it is not enough to consider a single YES instance. Instead, we use the bipartite indistinguishability graph induced by all YES and NO instances and show that this satisfies a polygamous version of Hall's Theorem. This allows us to show the existence of a large generalized matching in the indistinguishability graph, which in turn shows that every o(log n) round constant-error Monte Carlo algorithm can be fooled into making more errors than it is allowed. The precise result we prove is the following. Here the TwoCycle problem refers to the problem, mentioned earlier, of distinguishing between two n-vertex graph types: a single cycle or two disconnected cycles each of length at least 3. The lower bound is for public coin randomized Monte Carlo algorithms with 2-sided error ϵ.

Deterministic KT-1 Lower Bounds
We then show that the above lower bound result extends to the KT-1 version of the BCC(1) model, though our proof only works for deterministic algorithms. In KT-1, because of knowledge of IDs of neighbors, it is no longer possible to perform "edge crossing" tricks. But we are able to successfully use the "bottleneck" technique and show that there is a cut for the Connectivity problem across which Ω(n log n) bits need to flow. We prove this result by presenting a reduction from the 2-party communication complexity problem Partition [10]. In the Partition problem, we have a ground set [n] and Alice and Bob respectively are given two set partitions P A and P B of [n]. The goal is to output 1 iff P A ∨ P B = 1 where P A ∨ P B (read as "P A join P B ") is the finest partition P such that both P A and P B are refinements of P 2 and 1 is the trivial partition consisting of the single set [n]. For example, if P A = (1, 2)(3, 4)(5), P B = (1, 2, 4)(3)(5), and P C = (1, 2, 4)(3, 5) then P A ∨ P B = (1, 2, 3, 4)(5) and P A ∨ P C = (1, 2, 3, 4, 5). We then use the fact that the deterministic communication complexity of Partition is Ω(n log n) to obtain our result. Again, this time using a linear-algebraic argument, we show our result for a seemingly simple special case of Connectivity: "one cycle vs multiple cycles. " As far as we know, randomized communication complexity of Partition is a long-standing unresolved problem. Showing a lower bound on the randomized communication complexity of Partition will immediately lead to a KT-1 lower bound for randomized Connectivity algorithms, via our reduction. The precise result we show in the following. Here the MultiCycle problem refers to the problem of distinguishing between input that is a single cycle versus input that consists of multiple cycles, each of length at least 4.
Theorem 2.2. The round complexity of any deterministic algorithm that solves the MultiCycle problem in the KT-1 model is Ω(log n).
Along the way to proving this result, we show the following new 2-party communication complexity result. Here TwoPartition refers to the special case of the Partition problem in which every part of the given set partitions has size exactly 2.
Theorem 2.3. The communication complexity of any 2-party deterministic protocol that solves TwoPartition is Ω(n log n).

Randomized KT-1 Lower Bounds for ConnectedComponents
Our final result arises from our attempt to obtain a KT-1 lower bound even for constant-error Monte Carlo algorithms. We consider a version of the Partition problem, called PartitionComp, in which Alice and Bob are required to output the join of their respective input partitions P A and P B instead of just determining if P A ∨ P B = 1. We use an information-theoretic argument to show that the mutual information of any algorithm, even a constanterror Monte Carlo algorithm, that solves this version of Partition is Ω(n log n). This leads to an Ω(log n)-round lower bound for ConnectedComponents in the KT-1 version of BCC(1), even for constant-error randomized Monte Carlo algorithms. The precise result we show in the following.
Theorem 2.4. For any constant 0 < ϵ < 1, the round complexity of an ϵ-error randomized Monte Carlo algorithm that solves the ConnectedComponents problem in the KT-1 version of the BCC(1) model is Ω(log n).

Conclusion
We prove in this paper the first non-trivial lower bounds for Connectivity in the BCC(1) model. The fact that our lower bounds hold even in the KT-1 model implies that the difficulty of the problem does not arise just from lack of knowledge of IDs of other nodes. The fact that our lower bounds hold for extremely sparse (i.e., 2regular) graphs, suggests that there might be room to get stronger lower bounds by considering dense input graphs. In fact, using a deterministic sketching technique [17,18], it is possible to obtain a deterministic O(log n)-round BCC(1) algorithm for Connectivity for graphs with arboricity bounded by a constant. This implies that our lower bounds are tight for uniformly sparse graphs.