Connectivity Lower Bounds in Broadcast Congested Clique

TL;DR

This paper establishes new lower bounds of (log n) rounds for solving graph connectivity in the broadcast congested clique model, using combinatorial, reduction, and information-theoretic techniques.

Contribution

It introduces three novel lower bounds for connectivity in BCC(1), extending known results to randomized and deterministic algorithms and different knowledge models.

Findings

Lower bound of (log n) rounds for KT-0 BCC(1) model.

Lower bound extends to KT-1 deterministic algorithms.

Lower bound applies to constant-error Monte Carlo algorithms for connected components.

Abstract

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.

Equations

$$|{\mathcal{V}}_2|=\sum _{i=3}^{n/2}|{\mathcal{T}}_i|\le \sum _i\frac{n}{i\cdot (n-i)}\cdot |{\mathcal{V}}_1|=|{\mathcal{V}}_1|\cdot O(\log n)$$

$$|\Pi |\ge H(\Pi (P_A,P_B))\ge I(\Pi (P_A,P_B);P_A,P_B)=I(P_A,P_B;\Pi (P_A,P_B))=I(P_A;\Pi (P_A,P_B))$$

$$H(P_A|\Pi (P_A,P_B))$$

$$=\sum _{\pi \in B}\text{Pr}[\Pi (P_A,P_B)=\pi ]H(P_A|\Pi (P_A,P_B)=\pi )\le ϵH(P_A)$$

Full text

1 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 [Heg+15, GP16, JN18] have shown that Connectivity and in fact MST, can be solved in $O(1)$ rounds w.h.p.111We use “w.h.p.” as short for “with high probability” which refers to the probability that is at least $1-1/n^{c}$ for $c\geq 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 [JN17], is deterministic and it runs in $O\left(\frac{\log n}{\log\log n}\right)$ 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. [Bec+16] show that the pair-wise set disjointness problem can be solved in $O(1)$ rounds in CC$(1)$, but needs $\Omega(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 [CKP17, CK18, DS+11, DKO14, Fis+18, HP15]. 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 [KN97]. Not surprisingly, the “bottleneck” technique does not work in the CC$(b)$ model because any cut with $\Theta(n)$ vertices in each part, has a high bandwidth of $\Theta(n^{2}\cdot b)$ bits. In fact, a result of Drucker et al. [DKO14], showing that circuits can be simulated efficiently in the Congested Clique model, indicates that no technique we currently know of can prove non-trivial lower bounds in the CC$(b)$ model. However, as further shown by [DKO14], “bottlenecks” are possible for some problems in the weaker BCC$(b)$ model. In this model, every cut has bandwidth $O(n\cdot b)$ and for example Drucker et al. [DKO14] 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 $\Omega(n^{2})$ information has to flow. This leads to an $\Omega(n/b)$ lower bound for $K_{4}$-detection in the BCC$(b)$.

All known lower bounds [DKO14, HP15] 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 more fine-grained lower bound techniques that allow us to prove polylogarithmic lower bounds. Specifically, since Connectivity can be solved in BCC$(b)$ for any $b\geq 1$ in just $O(\text{poly}(\log n))$ rounds, the best we can expect is to show the existence of a cut across which $\Omega(n\cdot\text{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 $\Omega(\log n/b)$. However, even this was unknown prior to this paper and one contribution of this paper is an $\Omega(\log n/b)$ lower bound for Connectivity using the “bottleneck” technique.

1.1 Our Contribution

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 [Awe+90]). 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=\Omega(\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.

• •

In the KT-0 version of BCC$(1)$ we show an $\Omega(\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” [KKP10, BFP15, PP17] 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^{\prime})$ obtained by crossing pairs of edges $e$ and $e^{\prime}$ in $G$ cannot be distinguished even after some $t$ rounds of a BCC$(1)$ algorithm (see Definition 3.3 for the precise definition of a crossing). 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 (see Theorem 2.1). 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.

• •

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 $\Omega(n\log n)$ bits need to flow. We prove this result by presenting a reduction from the 2-party communication complexity problem Partition [HMT88]. 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}\vee P_{B}=\mathbf{1}$ where $P_{A}\vee 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$ 222Given two set partitions $P$ and $P^{\prime}$ of $[n]$, $P$ is said to be a refinement of $P^{\prime}$ if for every part $S\in P$, there is a part $S^{\prime}\in P^{\prime}$ such that $S\subseteq S^{\prime}$. For example the partition $(1,2)(3,4)(5)$ is a refinement of $(1,2)(3,4,5)$. and $\mathbf{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}\vee P_{B}=(1,2,3,4)(5)$ and $P_{A}\vee P_{C}=(1,2,3,4,5)$. We then use the fact that the deterministic communication complexity of Partition is $\Omega(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.

• •

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}\vee P_{B}=\mathbf{1}$. We use an information-theoretic argument to show that the mutual information of any algorithm, even a constant-error Monte Carlo algorithm, that solves this version of Partition is $\Omega(n\log n)$. This leads to an $\Omega(\log n)$-round lower bound for ConnectedComponents  in the KT-1 version of BCC$(1)$, even for constant-error randomized Monte Carlo algorithms.

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., 2-regular) graphs, suggests that there might be room to get stronger lower bounds by considering dense input graphs. In fact, using a deterministic sketching technique [MT16a, MT16], 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.

1.2 The BCC$(b)$ Model

A size-$n$ KT-0* instance* of the BCC$(1)$ model consists of $n$ vertices, each with a unique $O(\log n)$-bit ID. Each vertex has $n-1$ communication ports labeled distinctly, 1 through $n-1$, in an arbitrary manner. A key feature of the KT-0 instance is that port labels have nothing to do with IDs. Pairs of communication ports are connected by network edges such that the underlying communication network is a clique. The $n$ vertices along with a subset of the edges form the input graph. Thus some edges are both network edges and input graph edges, whereas the remaining edges are just network edges. The initial knowledge of a vertex $v$ consists of its ID, its port numbering, an identification of ports that correspond to input edges, and an arbitrarily long string $r_{v}$ of random bits. In each round $t$, each vertex $u$ receives messages via broadcast from the remaining $n-1$ vertices in the previous round, performs local computation, and broadcasts a message of length at most $b$-bits. This message is received at the beginning of round $t+1$ by the remaining $n-1$ vertices along each of their communication ports that connect to $u$. After $t$ rounds, the at most $t\cdot b$ bits that $v$ sends and the at most $(n-1)\cdot t\cdot b$ bits that $v$ receives, along with the ports that they are received from make up the transcript of $v$ at round $t$. A size-$n$ KT-1* instance* of the BCC$(b)$ model differs from a KT-0 instance in one important way: each network edge $e=\{u,v\}$ is connected to $u$ at port number $ID(v)$ and connected to $v$ at port number $ID(u)$. Thus, in a KT-1 instance, IDs serve as port numbers and the initial knowledge of a vertex consists include all $n$ vertex IDs.

Since the main focus of the paper is to derive lower bounds, we assume the public coin model in which all the random strings $r_{v}$ are identical. Lower bounds proved in the public coin model hold in the private coin model as well, in which all the $r_{v}$’s are distinct. For a decision problem, such as Connectivity, when we run a BCC$(b)$ algorithm $\mathcal{A}$ on an input graph $G$, each vertex outputs either YES or NO and the output of the system is YES if all vertices output YES and is NO otherwise. For a deterministic algorithm $\mathcal{A}$ for Connectivity  the system must output YES if $G$ is connected and NO if $G$ is disconnected. If $\mathcal{A}$ is an $\epsilon$-error randomized Monte Carlo algorithm, then in order to be correct, it must satisfy the following requirements: (i) if $G$ is connected then the system outputs YES with probability $>1-\epsilon$ and (ii) if $G$ is disconnected then the system outputs NO with probability $>1-\epsilon$.

1.3 Related Work

Congest model [Pel00] lower bounds via the “bottleneck technique” that rely on communication complexity lower bounds have been shown for MST and related connectivity problems in [DS+11] and for minimum vertex cover, maximum independent set, optimal graph coloring, all pairs shortest paths, and subgraph detection in [CKP17, CK18, Fis+18]. This approach has also been used to derive BCC$(\log n)$ lower bounds in [DKO14, HP15]. Becker et al. [Bec+16] define a spectrum of congested clique models parameterized by a range parameter $r$, denoting the number of distinct messages a node can send in a round. Setting $r=1$ gives us the BCC$(b)$ model and setting $r=n$ gives us the CC$(b)$ model. They show the pair-wise set disjointness problem is sensitive to the value of $r$ in the sense that for every pair of ranges $r^{\prime}<r$, the problem can be solved provably faster in the model with range $r$ than it can in the model with range $r^{\prime}$.

Distributed lower bounds via the “edge crossing” argument have a long history in distributed computing – see [KMZ87] for an example in the context of proving message complexity lower bounds. More recent examples [KKP10, BFP15, PP17] appear in the context of proof-labeling schemes. Informally speaking, a proof-labeling scheme consists of a prover who labels the vertices of the input configuration with labels and a distributed verifier who is required to verify a predicate (e.g., do the marked edges form an MST?) in one round, using the help of the prover’s labels. The verification complexity of a proof-labeling scheme is the size of the largest message sent by the verifier. Patt-Shamir and Perry [PP17] show an $\Omega(\log n)$ lower bound on the verification complexity of MST in the broadcast congested clique model. An $\Omega(\log n)$ lower bound in the KT-0 version of BCC$(1)$ for deterministic Connectivity algorithms follows from this result. The high level idea is that if there were a faster BCC$(1)$ Connectivity algorithm, the prover could use the transcript of the algorithm at each vertex $v$ as the label at $v$. The verifier could then broadcast these transcripts and locally, at each vertex $v$, simulate the algorithm at $v$. Baruch et al. [BFP15] show that if there is a deterministic proof-labeling scheme with verification complexity $\kappa$, then there is a randomized proof-labeling scheme with one-sided error having verification complexity $O(\log\kappa)$. Combining this with the fact that MST verification has a deterministic proof-labeling scheme with $O(\log^{2}n)$ verification complexity [KKP10], leads to a randomized proof-labeling scheme with $O(\log\log n)$ verification complexity for MST [BFP15, PP17]. This needs to be contrasted with the fact that we show an $\Omega(\log n)$ lower bound for Connectivity in KT-0 BCC$(1)$ even for constant-error Monte Carlo algorithms.

There have been recent attempts to combine the edge crossing and bottleneck techniques to obtain lower bounds for triangle detection in the Congest model [Abb+17, Fis+18]. In particular, [Fis+18] provide an $\Omega(\log n)$ lower bound for deterministic algorithms solving triangle detection in the KT-1 Congest model with $1$-bit bandwidth.

2 Technical Preliminaries

Polygamous Hall’s Theorem.

Let $G=(L,R,E)$ be a bipartite graph. A $k$-matching is a subgraph consisting of a set of nodes $A\subseteq L$ where each $v\in A$ has edges to nodes in the set $nbr(v)$ such that $|nbr(v)|=k$ and $nbr(u)\cap nbr(v)=\emptyset$ for $u,v\in A$, $u\neq v$. The size of a $k$-matching is the number of connected components in the subgraph.

Theorem 2.1** (Polygamous Hall’s Theorem).**

Let $G=(L,R,E)$ be a bipartite graph. If for every $S\subseteq L$ we have $|N(S)|\geq k|S|$ then $G$ has a $k$-matching of size $|L|$.

Proof.

Make $k$ copies of each node in $L$ while keeping $R$ the same. Now for every $S\subseteq L$ we have $|N(S)|\geq|S|$ and by Hall’s marriage theorem, we have a matching in the modified bipartite graph which is a $k$-matching of size $|L|$ in the original graph. ∎

Yao’s Minimax Theorem.

The standard way to prove lower bounds on $\epsilon$-error randomized algorithms is by invoking Yao’s Minimax Theorem [Yao77]. Let $RR_{\epsilon}(P)$ denote the minimum round complexity of any $\epsilon$-error randomized algorithm that solves $P$. Let $DR_{\epsilon}^{\mu}(P)$ denote the distributional round complexity of $P$, which is the minimum deterministic round complexity of an algorithm whose input is drawn from the distribution $\mu$ (known to the algorithm) and the algorithm is allowed to make error on at most $\epsilon$ fraction of the input (weighted by $\mu$).

Theorem 2.2** (Yao’s Minimax Theorem).**

For any problem $P$, $RR_{\epsilon}(P)\geq\max_{\mu}\{DR_{\epsilon}^{\mu}(P)\}$

Yao’s Minimax Theorem reduces the problem of proving a randomized lower bound to the task of designing a “hard” distribution that produces high distributional complexity.

Lower bound for Partition.

The total number of distinct partitions on a ground set of $n$ elements is given by the $n^{th}$* Bell number* $B_{n}$. It is well known that $B_{n}=2^{\Theta(n\log n)}$. This means that the number of different possible input pairs that Alice and Bob can receive in the Partition problem is $B_{n}^{2}=2^{\Theta(n\log n)}$. Define the matrix $M^{n}$ such that $M^{n}(i,j)=1$ if $P_{i}\vee P_{j}=1$ and $M^{n}(i,j)=0$ otherwise. Note that $M^{n}$ is a $B_{n}\times B_{n}$ matrix. Theorem 2.3 shows that this matrix is non-singular.

Theorem 2.3** ([DW75, Wel10]).**

$rank(M^{n})=B_{n}$* where $B_{n}$ is the $n^{th}$ Bell number*

Therefore by Lemma 1.28 of [KN97] we get the following corollary.

Corollary 2.4**.**

The deterministic 2-party communication complexity of Partition is $\Omega(n\log n)$

Information Theory.

Let $\mu$ be a distribution over a finite set $\Omega$ and let $X$ be a random variable distributed according to $\mu$. The entropy of $X$ is defined as $H(X)=-\sum_{x\in\Omega}{\mu(x)\log\mu(x)}$ and the conditional entropy of $X$ given $Y$ is $H(X|Y)=\sum_{y}\text{Pr}[Y=y]H(X|Y=y)$ where $H(X|Y=y)$ is the entropy of the conditional distribution of $X$ given the event $\{Y=y\}$. The joint entropy of two random variables $X$ and $Y$, denoted by $H(X,Y)$, is just the entropy of their joint distribution.

The mutual information between random variables $X$ and $Y$ is $I(X;Y)=H(X)-H(X|Y)=H(Y)-H(Y|X)$ and the conditional mutual information between $X$ and $Y$ given $Z$ is $I(X;Y|Z)=H(X|Z)-H(X|Y,Z)$. See the first two chapters of [CT06] for an excellent introduction to the basics of information theory.

3 Lower Bounds in the KT-0 model

This section is devoted to proving the following theorem. As mentioned earlier, our lower bound applies to the simpler “one cycle vs two cycles” problem which we will call TwoCycle. In this problem, the input is promised to be either a single cycle or two disconnected cycles, each of length at least 3 and the goal is to distinguish between these two types of inputs.

Theorem 3.1**.**

For a sufficiently small constant $0<\epsilon\leq 1/2$, the $\epsilon$-error randomized round complexity of the TwoCycle problem in the BCC$(1)$ KT-0 model is bounded below by $\Omega(\log n)$.

Two KT-0 instances $I_{1}$ and $I_{2}$ are said to be indistinguishable after $t$ rounds of an algorithm $\mathcal{A}$ if the state of each vertex (i.e., the initial knowledge and the transcript at that vertex) after $t$ rounds is the same in both the instances. We first introduce a technical tool called indistinguishability via port-preserving crossings. This tool has been used to show distributed computing lower bounds in several settings [KMZ87, KKP10, BFP15, PP17] and we heavily borrow notation from [PP17]. For an edge $e=(v,u)$ we use the notation $e(p,q)$ to denote that $e$ is connected to port $p$ at $v$ and to port $q$ at $u$. For this notation to be unambiguous, we must think of the edge $e=(v,u)$ as a directed edge $v\rightarrow u$ even though the graph itself is undirected.

Definition 3.2** (Independent Edges [PP17]).**

Let $I$ be an instance with input graph $G=(V,E)$ and let $e_{1}=(v_{1},u_{1})$ and $e_{2}=(v_{2},u_{2})$ be two edges of $G$. The edges $e_{1}$ and $e_{2}$ are said to be independent if and only if $v_{1},u_{1},v_{2},u_{2}$ are four distinct vertices and $(v_{1},u_{2}),(v_{2},u_{1})\notin E$. A set of input graph edges is called independent if every pair of edges in the set is a pair of independent edges.

Definition 3.3** (Port-Preserving Crossing [PP17]).**

Consider an instance $I$ with input graph $G=(V,E)$. Let $e_{1}=(v_{1},u_{1})$ and $e_{2}=(v_{2},u_{2})$ be two independent edges of $G$, and let $e_{1}^{\prime}=(v_{1},u_{2})$ and $e_{2}^{\prime}=(v_{2},u_{1})$ be two corresponding network edges in $I$. Let $p_{1},p_{2},q_{1},q_{2},p_{1}^{\prime},q_{1}^{\prime},p_{2}^{\prime},q_{2}^{\prime}$ be eight ports such that $e_{1}(p_{1},q_{1}),e_{2}(p_{2},q_{2}),e_{1}^{\prime}(p_{1}^{\prime},q_{2}^{\prime}),e_{2}^{\prime}(p_{2}^{\prime},q_{1}^{\prime})$. The crossing of $e_{1}$ and $e_{2}$ in $I$, denoted by $I(e_{1},e_{2})$, is the instance obtained from $I$ by replacing $e_{1}$ and $e_{2}$ in $G$ with the edges $e_{1}^{\prime}$ and $e_{2}^{\prime}$ and rewiring the edges so that $e_{1}(p_{1}^{\prime},q_{1}^{\prime}),e_{2}(p_{2}^{\prime},q_{2}^{\prime}),e_{1}^{\prime}(p_{1},q_{2}),$ and $e_{2}^{\prime}(p_{2},q_{1})$. (See Figure 1.)

The following lemma establishes a standard connection between indistinguishability and port-preserving crossings (henceforth “crossings”) and is in fact the main motivation for defining crossings. For simplicity, we say that a node sends the character $\bot$ to denote the fact that the node remains silent. Therefore, the events of a node broadcasting a [math], a $1$, or remaining silent can be described as sending the characters $0,1,$ or $\bot$ respectively.

Lemma 3.4**.**

Let $I$ be an instance with input graph $G=(V,E)$ and let $e_{1}=(v_{1},u_{1})$ and $e_{2}=(v_{2},u_{2})$ be two independent edges of $G$. If $v_{1},v_{2}$ send the same sequence $x\in\{0,1,\bot\}^{t}$ and $u_{1},u_{2}$ send the same sequence $y\in\{0,1,\bot\}^{t}$ in the first $t$ rounds of the algorithm, then $I$ is indistinguishable from $I(e_{1},e_{2})$ after $t$ rounds.

Proof.

We will prove the lemma by induction on $t$. The initial knowledge of each vertex in $I$ and $I(e_{1},e_{2})$ is the same so the statement is true for $t=0$.

Assume that the lemma is true for some round $0\leq i\leq t$. Therefore, the characters broadcast by the vertices in round $i+1$ will be the same in both the instances. From the definition of port preserving crossing it is clear that $I$ and $I(e_{1},e_{2})$ differ only in four edges, $e_{1}$, $e_{2}$, $e_{1}^{\prime}=(v_{1},u_{2})$, and $e_{2}^{\prime}=(v_{2},u_{1})$. Therefore, all vertices except $v_{1},v_{2},u_{1}$, and $u_{2}$ will receive the same characters across all their ports in round $i+1$ in both the instances and hence will have the same state in both instances after round $i+1$.

Let the port names of the four edges in $I$ and $I(e_{1},e_{2})$ be as in Definition 3.3 and Figure 1. In $I$, the vertex $u_{1}$ will receive the characters broadcast by $v_{1},v_{2}$ through ports $q_{1},q_{1}^{\prime}$ respectively and in $I(e_{1},e_{2})$ it will receive the characters broadcast by $v_{2},v_{1}$ through ports $q_{1},q_{1}^{\prime}$ respectively. Note that $v_{1}$ and $v_{2}$ broadcast the same message in round $i+1$ since they send the same sequence $x$ in the first $t$ rounds and therefore, the state of $u_{1}$ after round $i+1$ will be the same in both instances. We can make similar arguments for $u_{2},v_{1},$ and $v_{2}$ as well. Therefore, the state of each vertex after round $i+1$ is the same in both $I$ and $I(e_{1},e_{2})$ which proves the induction step as well as the lemma. ∎

As a “warm-up”, we first sketch an easy $\Omega(\log n)$ lower bound for randomized Monte Carlo algorithms that make polynomially small error, i.e., error $\epsilon=1/n^{c}$ for constant $c>0$. By Yao’s minimax theorem (Theorem 2.2), it suffices to show a lower bound on the distributional complexity of a deterministic algorithm under a hard distribution. Consider the following hard distribution $\mu$: Let $I$ be an arbitrary instance such that the input graph $G$ of $I$ is a one-cycle on $n$ vertices. Let $S$ be an arbitrarily chosen set of exactly $\lfloor n/3\rfloor$ independent edges 333Adding an edge to $S$ invalidates at most two other edges, and therefore we can always find an independent set $S$ of size $\lfloor n/3\rfloor$. and let $I(S)$ be the set of all instances $I(e,e^{\prime})$ where $e,e^{\prime}\in S$, and therefore, $|I(S)|=\binom{\lfloor n/3\rfloor}{2}=\Theta(n^{2})$. The hard distribution $\mu$ places probability mass $1/2$ on the instance $I$ and uniformly distributes the remaining probability mass among the instances in $I(S)$. Now, given a $t$-round deterministic algorithm $\mathcal{A}$ we can assign a $2t$-character label to each edge $(v,u)$ obtained by concatenating the $t$ characters broadcast by $v$ and $u$. Here each character in the label belongs to the alphabet $\{0,1,\bot\}$. The pigeon-hole principle implies that there is a set $S^{\prime}\subseteq S$, $|S^{\prime}|\geq n/(3\cdot 3^{2t})$, of edges in $S$ with identical labels. Then by Lemma 3.4, for any $e,e^{\prime}\in S^{\prime}$, $I$ and $I(e,e^{\prime})$ are indistinguishable after $t$-rounds of $\mathcal{A}$. Since $\mathcal{A}$ cannot make an error on $I$, it makes errors on all instances $I(e,e^{\prime})$ where $e,e^{\prime}\in S^{\prime}$. Since $\mu$ assigned the probability mass 1/2 uniformly to all instances in $I(S)$, the probability that $\mathcal{A}$ makes an error is at least $|I(S^{\prime})|/(2|I(S)|)=\binom{|S^{\prime}|}{2}/\binom{\lfloor n/3\rfloor}{2}\geq\Omega(3^{-4t})$. Therefore, if $t\leq 0.001\cdot c\cdot\log_{3}n$, this error becomes $\Omega(1/n^{0.001c})$ which is much larger than $1/n^{c}$ – a contradiction, implying that $t>0.001\cdot c\cdot\log n$ and leading to the following theorem.

Theorem 3.5**.**

For any constant $c>0$, if $\epsilon\leq 1/n^{c}$ then the $\epsilon$-error randomized round complexity of the Connectivity problem in the BCC$(1)$ KT-0 model is $\Omega(c\cdot\log n)$.

Proof.

Note that since the probability mass on $I$ is so large, any algorithm with permissible error probability must output YES on $I$ and therefore, it will also output YES on all instances that are indistinguishable from $I$.

Given a $t$-round deterministic algorithm $\mathcal{A}$ we can assign a $2t$-character label to each edge $(v,u)$ where each character belongs to the alphabet $\{0,1,\bot\}$. The label is assigned such that the head $v$ sends the $i^{th}$ character of the label and the tail $u$ sends the $(t+i)^{th}$ character of the label in round $i$ for all edges. By using the pigeon hole principle, we see that there is a set $S^{\prime}\subseteq S$, $|S^{\prime}|\geq n/(3\cdot 3^{2t})$, of edges in $S$ with identical labels. By Lemma 3.4, for any $e,e^{\prime}\in S^{\prime}$, $I$ and $I(e,e^{\prime})$ are indistinguishable after $t$-rounds of $\mathcal{A}$. Therefore, any $t$ round algorithm will make an error on instances $I(e,e^{\prime})$ where $e,e^{\prime}\in S^{\prime}$ and this makes the error at least $\binom{|S^{\prime}|}{2}/\binom{\lfloor n/3\rfloor}{2}\geq\Omega(3^{-4t})$. Therefore, if $t\leq 0.001\cdot c\cdot\log_{3}n$, this error becomes $\Omega(1/n^{0.001c})$ which is much larger than $1/n^{c}$. ∎

The hard distribution $\mu$ that led to the above theorem fails to give even a super-constant round lower bound for constant error probability. This is because for any constant $\epsilon$, there is a constant $t$ such that the error probability $|I(S^{\prime})|/(2|I(S)|)$ of algorithm $\mathcal{A}$ is smaller than $\epsilon$, leading to no contradiction.

3.1 A Lower Bound for Constant Error Probability

To get around this problem, we start with the observation that a two-cycle instance $I(e,e^{\prime})$ obtained from $I$, can also be obtained by crossing edges in other one-cycle instances, i.e., $I(e,e^{\prime})=I^{\prime}(f,f^{\prime})$ for edges $f,f^{\prime}$ in an instance $I^{\prime}\not=I$. Thus, as the algorithm executes, even though $I(e,e^{\prime})$ ceases to be indistinguishable from $I$, it may continue to be indistinguishable from $I^{\prime}$. This suggests that we should be considering all one-cycle and two-cycle instances and all the edge crossings that lead from one-cycle instances to two-cycle instances. This motivates the definition below of a bipartite indistinguishability graph with all one-cycle and two-cycle instances as vertices. In the proof of Theorem 3.5, when we placed the entire probability mass on a single “star” indistinguishability graph with $I$ being the central node and instances in $I(S)$ being the leaves, we ran into trouble because the degree of $I$ in this “star” shrank too quickly with the number of rounds, $t$. If we consider the full indistinguishability graph, we have more leeway. Specifically, showing the existence of a large matching in the indistinguishability graph would be helpful since the algorithm is forced to make an error at one of the two endpoints of each matching edge. We formalize this intuition below, first with some definitions.

Let the set of distinct one-cycle and two-cycle instances be $\mathcal{V}_{1}$ and $\mathcal{V}_{2}$ respectively let $\mu$ be a probability distribution on these. Let $\mathcal{A}$ be a $t$-round deterministic KT-0 algorithm which solves the TwoCycle problem correctly on $(1-\epsilon)$ fraction of input in the support of $\mu$ (recall, $\epsilon$ is a constant). For any instance $I\in\mathcal{V}_{1}\cup\mathcal{V}_{2}$, call an edge $e=(v,u)$ in the input graph of $I$ active with respect to strings $x,y\in\{0,1,\bot\}^{t}$ iff $v$ broadcasts the sequence given by $x$ and $u$ broadcasts the sequence given by $y$ in the first $t$ rounds of the algorithm $\mathcal{A}$. We call an edge active if the strings $x,y$ are clear from the context.

Definition 3.6** (Indistinguishability Graph).**

Let $t$ be a non-negative integer and let $x,y\in\{0,1,\bot\}^{t}$ be two strings of length $t$. The indistinguishability graph with respect to messages $x$ and $y$ after $t$ rounds of algorithm $\mathcal{A}$ is a bipartite graph $\mathcal{G}^{t}_{x,y}=(\mathcal{V}_{1},\mathcal{V}_{2},\mathcal{E}^{t})$ where $\mathcal{V}_{1}$ is the set of all one-cycle instances and $\mathcal{V}_{2}$ is the set of all two-cycle instances and there is an edge $\{I_{1},I_{2}\}\in\mathcal{E}^{t}$ iff $I_{1}\in\mathcal{V}_{1}$ and $I_{2}\in\mathcal{V}_{2}$ and there exist two active independent directed edges $e_{1}=(v_{1},u_{1})$ and $e_{2}=(v_{2},u_{2})$ in the input graph of $I_{1}$ such that $I_{2}=I_{1}(e_{1},e_{2})$.

We now propose to use a rather natural hard distribution $\mu$ that assigns probability mass $1/2$ distributed uniformly among the instances in $\mathcal{V}_{1}$ and the remaining probability mass $1/2$ distributed uniformly among the instances in $\mathcal{V}_{2}$. We first prove Lemma 3.7 that plays a crucial role in our overall proof by essentially showing that every one-cycle instance has sufficiently many two-cycle neighbors in $\mathcal{G}^{t}_{x,y}$ with high degree. This in turn is used in Lemma 3.8 to prove that a Polygamous Hall’s Theorem (Theorem 2.1) condition holds for $\mathcal{G}^{t}_{x,y}$. This allows us to show that $\mathcal{G}^{t}_{x,y}$ can be packed with $|\mathcal{V}_{1}|$ “stars,” each with $\Theta(\log n)$ leaves. We need this generalized notion of a matching because as shown in Lemma 3.9, $|\mathcal{V}_{2}|=|\mathcal{V}_{1}|\cdot\Theta(\log n)$. Therefore, the probability mass assigned to an instance in $\mathcal{V}_{2}$ is $1/\Theta(\log n)$ fraction of the probability mass assigned to an instance in $\mathcal{V}_{1}$. Thus, a “star” with its central node from $\mathcal{V}_{1}$ and $\Theta(\log n)$ leaves from $\mathcal{V}_{2}$ has roughly equal probability mass assigned to the YES instance and NO instances.

Lemma 3.7**.**

Consider an arbitrary instance $I_{1}\in\mathcal{V}_{1}$ that is a vertex of $\mathcal{G}^{t}_{x,y}$. If $d\geq 1$ is the number of active edges of $I_{1}$ with respect to $x,y$ then for every $i,3\leq i\leq d/2$, $I_{1}$ has at least $d/2$ neighbors of degree $i\cdot(d-i)$.

Proof.

A two-cycle instance $I_{2}\in\mathcal{V}_{2}$ will be a neighbor of $I_{1}$ iff $I_{1}$ and $I_{2}$ form a pair of crossed instances with respect to $x,y$. Say $I_{2}=I_{1}(e,e^{\prime})$ where $e=(v,u)$ and $e^{\prime}=(v^{\prime},u^{\prime})$. Note that $I_{2}$ will have two new input graph edges $(v,u^{\prime})$ and $(u,v^{\prime})$ both of which are active and all input graph edges of $I_{1}$ except for $e,e^{\prime}$ appear in the input graph of $I_{2}$. Therefore, $I_{2}$ also has $d$ active edges with respect to $x,y$. The degree of $I_{2}$ is determined by the number of active edges either cycle, i.e., if $I_{2}$ has $i$ active edges in one cycle and $d-i$ active edges in the other cycle then its degree in $\mathcal{G}^{t}_{x,y}$ is $i\cdot(d-i)$ since we can take one active edge from either cycle and cross them to produce a unique neighbor of $I_{2}$.

For every active edge $e$ in the input graph of $I_{1}$, we can associate a unique active edge $e_{i}$ such that $I_{1}(e,e_{i})$ has $i$ active edges in one cycle and $d-i$ active edges in the other cycle. Therefore, $I_{1}$ has exactly $d$ (or $d/2$ if $i=d/2$) neighbors having degree $i(d-i)$. This argument may not hold exactly for $i=1,2$ because $e$ and $e_{i}$ as described need not form a pair of independent edges in this case. Thus, the lemma follows. ∎

Lemma 3.8**.**

For the graph $\mathcal{G}^{t}_{x,y}$, consider an arbitrary set $\mathcal{S}\subseteq\mathcal{V}_{1}$ of one-cycle instances with degree at least $1$. Let $N(\mathcal{S})$ be the neighborhood of $\mathcal{S}$ in $\mathcal{G}^{t}$. Then $|N(\mathcal{S})|\geq|\mathcal{S}|\cdot\Theta(\log d)$ where $d$ is the smallest number of active edges in any instance in $\mathcal{S}$.

Proof.

Every $I\in\mathcal{S}$ has at least $d$ active edges, therefore by Lemma 3.7, there are at least $d/2$ neighbors of $I$ having degree $i\cdot(d-i)$ for $3\leq i\leq d/2$. Thus there are at least $(d/2)\cdot|\mathcal{S}|/(i\cdot(d-i))=\Theta(|\mathcal{S}|/i)$ two-cycle instances in $N(\mathcal{S})$ having degree $i\cdot(d-i)$. Therefore, we have $|N(\mathcal{S})|\geq\sum_{i=3}^{d/2}{\Theta(|\mathcal{S}|/i)}$ $=|\mathcal{S}|\cdot\Theta(H_{d/2}-3/2)\geq|\mathcal{S}|\cdot\Theta(\log d)$, where $H_{n}$ is the $n^{th}$ harmonic number. ∎

Lemma 3.9**.**

$|\mathcal{V}_{2}|=|\mathcal{V}_{1}|\cdot\Theta(\log n)$.

Proof.

Let $\mathcal{G}=\mathcal{G}^{0}_{\lambda,\lambda}$ ($\lambda$ is the empty string) be the indistinguishability graph at round [math]. Note that in $\mathcal{G}$, every instance in $\mathcal{V}_{1}\cup\mathcal{V}_{2}$ has strictly positive degree since each instance has $n$ active edges. Therefore, we have $|\mathcal{V}_{1}|=|N(\mathcal{V}_{2})|$ and $|\mathcal{V}_{2}|=|N(\mathcal{V}_{1})|$. Therefore, by Lemma 3.8, we have $|\mathcal{V}_{2}|=|\mathcal{V}_{1}|\cdot\Omega(\log n)$. Now we show that $|\mathcal{V}_{2}|=|\mathcal{V}_{1}|\cdot O(\log n)$.

Since each instance has $n$ active edges, each one-cycle instance $I_{1}$ has degree $n(n-3)/2$ because for each input graph edge $e$ of $I_{1}$ there are $(n-3)$ active edges independent of $e$, which we can cross with to get a unique neighbor of $I_{1}$. We need to divide by a factor of two because $I_{1}(e,e^{\prime})=I_{1}(e^{\prime},e)$. And each two-cycle instance $I_{2}$ with the smaller cycle having length $i$ has degree $i\cdot(n-i)$ since we can cross any two edges in different cycles to get a neighbor of $I_{2}$.

Let $\mathcal{T}_{i}$ denote the set of two-cycle instances with the smaller cycle having length $i$ for $3\leq i\leq n/2$.

For every input graph edge $e$ in a one-cycle instance $I$, there is exactly one input graph edge $e_{i}$ such that $I(e,e_{i})\in\mathcal{T}_{i}$. Therefore, for $3\leq i<n/2$, each one cycle instance has $n$ neighbors such that the smaller cycle is of length $i$. And if $n$ is even, each one-cycle instance will have $n/2$ neighbors where both cycles have length $n/2$ instead.

We will now show that $|\mathcal{T}_{i}|\leq|\mathcal{V}_{1}|\cdot n/(i\cdot(n-i))$. To see this note that if we restrict our attention to the subgraph of $\mathcal{G}$ spanned by instances in $\mathcal{V}_{1}\cup\mathcal{T}_{i}$ then we have a bipartite graph where each instance in $\mathcal{V}_{1}$ has the same degree $n$ (or $n/2$ if $i=n/2$) and each instance in $\mathcal{T}_{i}$ has the same degree $i\cdot(n-i)$. Therefore, the total number of edges incident on $\mathcal{V}_{1}$ is $\leq|\mathcal{V}_{1}|\cdot n$ and those incident on $\mathcal{T}_{i}$ is $|T_{i}|\cdot i\cdot(n-i)$. Since the number of edges should be the same counted from either side, we get $|\mathcal{T}_{i}|\leq|\mathcal{V}_{1}|\cdot n/(i\cdot(n-i))$. Now we finish the proof of the lemma with the following calculation:

[TABLE]

∎

Proof.

(of Theorem 3.1) Consider an arbitrary one-cycle instance $I_{1}\in\mathcal{V}_{1}$ after $t=0.1\log_{3}n$ rounds of algorithm $\mathcal{A}$. Let $x,y\in\{0,1,\bot\}^{t}$ be the strings that correspond to the largest set of active edges after $t$-rounds of algorithm $\mathcal{A}$. We would like to count the size of this set of active edges. Recall that we orient each input graph edge of $I_{1}$ in a clockwise direction. Therefore, each input graph edge in $I_{1}$ can be labeled with a string of length $2t$ which denotes messages sent across it from the head and the tail (in order) across the $t$ rounds. This means that there are at least $n/3^{2t}=n^{0.8}$ input graph edges in $I_{1}$ that have the same messages sent across them. Therefore, the size of the set of active edges with respect to $x,y$ is at least $\Omega(n^{0.8})$.

By Lemma 3.8 and Theorem 2.1, we can say that there exists a $\Theta(\log n)$-matching in $\mathcal{G}^{t}_{x,y}$ of size $|\mathcal{V}_{1}|$. No matter what the algorithm $\mathcal{A}$ outputs on any one-cycle instance, it will produce the same output on the matched $O(\log n)$ two-cycle instances. By Lemma 3.9, we know that for any $I_{1}\in\mathcal{V}_{1}$ and $I_{2}\in\mathcal{V}_{2}$, $\mu(I_{1})=\mu(I_{2})\cdot\Theta(\log n)$ Therefore, each instance $I_{1}\in\mathcal{V}_{1}$ contributes to $\Theta(\mu(I_{1}))$ the error of the algorithm which means that any $t$-round BCC$(1)$ algorithm will have total error at least a constant. This implies the theorem. ∎

4 Lower Bounds in the KT-1 Model

Our lower bounds in the KT-1 model are inspired by the work of Hajnal et al. [HMT88], which is concerned with 2-party communication complexity of several graph problems, including Connectivity. In their setup [HMT88], the input graph $G=(V,E)$ is edge-partitioned among Alice and Bob in such a way that both parties know $V$ and Alice and Bob respectively know edge sets $E_{A}$ and $E_{B}$, were $(E_{A},E_{B})$ forms a partition of $E$. One simple deterministic protocol that solves Connectivity in this setup is this: Alice sends all the connected components induced by $E_{A}$ to Bob, who can determine if $G$ is connected. The worst case communication complexity of this protocol is $O(n\log n)$. Via reduction from Partition, Hajnal et al. [HMT88] show that there exists a family of input graphs such that for any equal sized edge partition, the communication complexity of Connectivity  is $\Omega(n\log n)$.

It does not seem possible to reduce from this edge-partitioned version of 2-party Connectivity to Connectivity  in the KT-1 model because KT-1 algorithms are vertex-centric and Alice and Bob may not hold all the edges they need to simulate vertices executing a KT-1 algorithm. We resolve this issue by designing a new reduction, from Partition to a vertex-partition version of 2-party Connectivity. In the Hajnal et al. [HMT88] reduction, Partition is reduced to Connectivity on a family of dense graphs. Motivated by our KT-0 lower bound for Connectivity for the TwoCycle problem, we are interested in deriving a KT-1 Connectivity lower bound for a sparse class of graphs as well. In what follows, we extend the reduction of Hajnal et al. from Partition to Connectivity in two important ways: (i) we reduce to a vertex-partitioned version of Connectivity and (ii) we reduce to a sparse special case of Connectivity that we call the MultiCycle problem, in which the input is either a single cycle or two or more cycles, each having length at least $4$.

4.1 A Special Case of the Partition Problem

In order to establish a lower bound for MultiCycle, we now consider a special case of the 2-party Partition problem, which we call TwoPartition. The input to TwoPartition consists of partitions $P_{A}$ and $P_{B}$ of $[n]$, for even $n$, such that each part in $P_{A}$ and $P_{B}$ has exactly two elements in it. We will now use a linear algebraic argument to show that there is an $\Omega(n\log n)$ deterministic lower bound on this special case of Partition also. The [math]-$1$ matrix $E^{n}$ associated with this problem is a sub-matrix of the matrix $M^{n}$ where $M^{n}(i,j)=1$ if $P_{i}\vee P_{j}=1$ and $M^{n}(i,j)=0$ otherwise (see Section 2). The matrix $E^{n}$ has dimension $r\times r$ where $r=n!/(2^{n/2}\cdot(n/2)!)$. This fact follows from a simple counting argument. In the following theorem, we show that this sub-matrix $E^{n}$ has full rank.

Lemma 4.1**.**

$rank(E^{n})=r$* where $r=n!/(2^{n/2}\cdot(n/2)!)$.*

Proof.

We will prove a more general observation – every sub-matrix $A_{S}$ of a full rank $d\times d$ matrix $A$ formed by choosing a subset $S$ of the rows and the corresponding columns has rank $s$ where $s=|S|$. In other words, for all $S$, $A_{S}$ is a full rank $s\times s$ matrix.

Let $B$ be a $d\times d$ diagonal matrix where $B(i,i)=1$ if $i\in S$ and $B(i,i)=0$ if $i\notin S$. It is easy to see that $rank(B)=|S|=s$. Using basic properties of rank, $rank(AB)\leq rank(B)\leq s$ and by Sylvester’s rank inequality 444For any two $n\times n$ matrices $A,B$, $rank(AB)\geq rank(A)+rank(B)-n$. We can prove this inequality by applying the rank-nullity theorem to the inequality $null(AB)\leq null(A)+null(B)$., $rank(AB)\geq rank(A)+rank(B)-d=d+s-d=s$.

Therefore, $rank(AB)=s$ which means that some minor of $AB$ having dimension $s$ needs to be of full rank. The only such candidate is the minor corresponding to the matrix $A_{S}$ because all other minors of dimension $s$ either have an all zero row or all zero column. Therefore, $A_{S}$ has full rank.

Now $E^{n}$ is a submatrix of $M^{n}$ where the rows and columns correspond to partitions of $[n]$ such that each part has exactly two elements in it. Therefore, the lemma follows since $M^{n}$ has full rank. ∎

By using Stirling’s approximation, it can be verified that $r=2^{\Theta(n\log n)}$. Then, by the rank bound and Lemma 1.28 of [KN97] we get the following corollary.

Corollary 4.2**.**

The deterministic 2-party communication complexity of TwoPartition is $\Omega(n\log n)$

We describe our reductions in the next two subsections. In section 4.2, we reduce the Partition (TwoPartition) problem to the vertex partitioned 2-party Connectivity (2-party MultiCycle) problem and in section 4.3, we reduce the 2-party Connectivity (2-party MultiCycle) problem to Connectivity (MultiCycle) in the KT-1 model.

4.2 Reductions from Partition and TwoPartition

Here we present two reductions, first from Partition to 2-party Connectivity and next from TwoPartition to 2-party MultiCycle. Alice is given a partition $P_{A}=(S_{1},S_{2},\dots,S_{n})$ over the ground set $[n]$ where $S_{i}$ is the $i^{th}$ part of $P_{A}$, which could possibly be empty if $P_{A}$ has fewer than $i$ parts. Similarly, Bob is given a partition $P_{B}=(S_{1}^{\prime},S_{2}^{\prime},\dots,S_{n}^{\prime})$. They construct a graph $G(P_{A},P_{B})$ as follows: Alice creates vertex sets $A=\{a_{1},\dots,a_{n}\}$ and $L=\{\ell_{1},\dots,\ell_{n}\}$ whereas Bob creates the vertex sets $R=\{r_{1},\dots,r_{n}\}$ and $B=\{b_{1},\dots,b_{n}\}$. Alice and Bob add edges $(\ell_{i},r_{i})$ for $i\in[n]$, independent of $P_{A}$ and $P_{B}$. Alice adds edges between $A$ and $L$ that induce the partition $P_{A}$ on $L$. That is, for every $S_{i}\in P_{A}$, Alice adds edges $(a_{i},\ell_{j})$ for all $j\in S_{i}$. There will be some vertices in $A$ that are not connected to any vertex, so Alice just adds an edge between these vertices and an arbitrary vertex $\ell_{*}\in L$. Bob similarly adds edges between the sets $B$ and $R$. See Figure 2.

If $P_{A}$ and $P_{B}$ are instances of TwoPartition, that is, each part of $P_{A}$ and $P_{B}$ is of size exactly two, then we can modify the construction of $G(P_{A},P_{B})$ by getting rid of the sets $A$ and $B$. Note that in this case $P_{A}=(S_{1},S_{2},\dots,S_{n/2})$ and $P_{B}=(S_{1}^{\prime},S_{2}^{\prime},\dots,S_{n/2}^{\prime})$ where each $S_{i}$ and $S_{i}^{\prime}$ has size exactly two. If $\{i,j\}\in P_{A}$ then Alice creates an edge between $\ell_{i}$ and $\ell_{j}$ and Bob does the same with $R$ for every pair in $P_{B}$. With this modified construction, each vertex in $G(P_{A},P_{B})$ has degree exactly $2$ and therefore, every connected component of $G(P_{A},P_{B})$ will be a cycle. See Figure 2.

The following theorem encapsulates a crucial property of the graph $G(P_{A},P_{B})$ which implies the correctness of our reductions.

Theorem 4.3**.**

If $P_{A}$ and $P_{B}$ are instances of Partition (or TwoPartition), then the partition induced by the connected components of $G(P_{A},P_{B})$ on the vertices in $L$ and $R$ corresponds to the partition $P_{A}\vee P_{B}$.

Proof.

Call two elements $a$ and $b$ reachable from each other if there exists a sequence of distinct elements $e_{0},e_{1},\dots e_{t},1\leq t\leq n$ such that $e_{0}=a$, $e_{t}=b$ and each pair $(e_{i},e_{i+1})$ either belongs to the same part of $P_{A}$ or the same part of $P_{B}$. Any partition in which all reachable elements are in the same part have both $P_{A}$ and $P_{B}$ as refinements.

We claim that two elements belong to the same part of $P_{A}\vee P_{B}$ if and only if they are reachable from each other. The backward direction is true because $P_{A}$ and $P_{B}$ are both refinements of $P_{A}\vee P_{B}$. The forward direction is true because if $a$ and $b$ are not reachable from each other but still belong to the same part $S$ of $P_{A}\vee P_{B}$ then we can refine the part $S$ to be $S_{a},S_{b}$ where $S_{a}$ is the set of all elements in $S$ that are reachable from $a$ and $S_{b}$ is the set of all elements in $S$ that are reachable from $b$. It is easy to see that $S_{a}$ and $S_{b}$ are disjoint. Let $P^{\prime}$ be the partition $P_{A}\vee P_{B}$ where $S$ is further refined to be $S_{a},S_{b},S\setminus(S_{a}\cup S_{b})$. Note that both $P_{A}$ and $P_{B}$ still remain refinements of the $P^{\prime}$ which contradicts the minimality of the join.

The theorem follows by observing that $i$ and $j$ are reachable from each other if and only if there is a path from $\ell_{i}$ to $\ell_{j}$ (and consequently from $r_{i}$ to $r_{j}$) in $G(P_{A},P_{B})$. ∎

4.3 Reductions from 2-party Connectivity and MultiCycle

We now show reductions from 2-party Connectivity to Connectivity in the KT-1 model and from 2-party MultiCycle to MultiCycle in the KT-1 model. Given an $r$-round KT-1 algorithm $\mathcal{A}$, Alice and Bob will simulate the algorithm with $G(P_{A},P_{B})$ as the input graph. Alice hosts vertices in $A\cup L$ and Bob hosts vertices in $B\cup R$. For $1\leq i\leq n$, the IDs of vertices $a_{i}$, $\ell_{i}$, $r_{i}$, and $b_{i}$ are $i$, $n+i$, $2n+i$, and $3n+i$ respectively. So both parties know the ID’s of all vertices as well as the ID’s of neighbors of all hosted vertices in $G(P_{A},P_{B})$ and hence, the initial knowledge of hosted vertices.

In order to simulate round $t$ of $\mathcal{A}$, Alice and Bob need to compute the states of all hosted vertices after round $t$ of $\mathcal{A}$. The state of a vertex $v$ after round $t$ depends on the initial knowledge and the transcript $\tau(v,t)$ of $v$. Assume that Alice and Bob know the states of all the vertices they host after round $t-1$. Alice and Bob send a message from $\{0,1,\bot\}^{2n}$ to each other. These messages denote the characters their hosted vertices broadcast in round $t$, in increasing order of ID. Therefore, they know the sender ID of a character from the position of the character in the message. This enables Alice and Bob to compute the transcript $\tau(v,t)$ and hence the state after round $t$ of all hosted vertices $v$.

Therefore, in simulating each round, Alice and Bob exchange exactly $O(n)$ bits with each other and the total communication complexity of the protocol is $O(rn)$. If $\mathcal{A}$ solves the Connectivity or MultiCycle problems, then using corollaries 2.4 and 4.2 respectively and Theorem 4.3, we obtain the following result.

Theorem 4.4**.**

The round complexity of a deterministic algorithm for solving the Connectivity and MultiCycle problems in the KT-1 model is $\Omega(\log n)$.

4.4 Information-theoretic Lower Bound for ConnectedComponents

Já Já [JJ84] proves a lower bound for 2-party ConnectedComponents and points out that his techniques may not work for decision problems, indicating that it might be easier to prove lower bounds for ConnectedComponents. This motivates us to consider the ConnectedComponents problem as a lower bound candidate, closely related to Connectivity, but for which we may be able to prove an $\Omega(\log n)$ lower bound in the KT-1 model, even for constant-error Monte Carlo algorithms. It turns out that we are able to prove this result by combining the reductions described in the previous section with information-theoretic techniques. We first define the 2-party problem PartitionComp which is closely related to Partition, but requires an output with a large representation. As in Partition, Alice and Bob are respectively given set partitions $P_{A}$ and $P_{B}$ of $[n]$ and at the end of the communication protocol for PartitionComp, Alice and Bob are required to output the join $P_{A}\vee P_{B}$. From Theorem 4.3, we get that if there is a $t$-round, $\epsilon$-error Monte Carlo algorithm $\mathcal{A}$ for ConnectedComponents in the KT-1 model, then there is an $\epsilon$-error Monte Carlo protocol that solves PartitionComp with communication complexity $t\cdot n$.

Consider the following distribution over inputs of PartitionComp: Alice’s input $P_{A}$ is chosen uniformly at random from the set of all partitions and Bob’s partition is fixed to be the finest partition, i.e., $P_{B}=(1)(2)(3)\dots(n)$. With $P_{B}$ fixed in this manner, $P_{A}\vee P_{B}=P_{A}$ and at the end of the protocol Bob learns $P_{A}$. Since $P_{A}$ is chosen from the uniform distribution, it’s initial entropy is high – $\Theta(n\log n)$ since the support of the distribution has size $2^{\Theta(n\log n)}$. Therefore Bob will learn a lot of information by the end of the protocol. This idea is formalized in the proof of the following theorem. This proof also has to deal with the complication that the protocol has constant error probability.

Theorem 4.5**.**

For any constant $0<\epsilon<1$, the round complexity of an $\epsilon$-error randomized Monte Carlo algorithm that solves the ConnectedComponents problem in the KT-1 version of the BCC$(1)$ model is $\Omega(\log n)$.

Proof.

Using Yao’s minimax theorem (Theorem 2.2) we can assume that all protocols are deterministic but are allowed to make an error on $\epsilon$-fraction of the input, weighted by $\mu$. Although appealing to Yao’s theorem is not necessary, it allows us to simplify the exposition. Let $\Pi$ denote the transcript of a 2-party protocol that solves PartitionComp and let $|\Pi|$ denote the length of the longest transcript produced by $\Pi$ on any input. We know that

[TABLE]

where the last equality follows from the fact that $P_{B}$ is fixed according to $\mu$. From the definition of mutual information, $I(P_{A};\Pi(P_{A},P_{B}))=H(P_{A})-H(P_{A}|\Pi(P_{A},P_{B}))$. Alice’s input $P_{A}$ is uniformly distributed among all $B_{n}=2^{\Theta(n\log n)}$ set partitions according to the hard distribution $\mu$. Therefore $H(P_{A})=\Theta(n\log n)$. Let $B$ be the set of protocol transcripts that produce an error on the input $P_{A},P_{B}$. If $\Pi(P_{A},P_{B})\notin B$ then $H(P_{A}|\Pi(P_{A},P_{B}))=0$ since the output of the protocol is $P_{A}\vee P_{B}=P_{A}$. We are guaranteed that $\text{Pr}[\Pi(P_{A},P_{B})\in B]\leq\epsilon$. Therefore, the second term can be bounded as follows.

[TABLE]

Where the last inequality follows from the fact that $H(X|Y)\leq H(X)$ for any $X,Y$. This implies $I(P_{A};\Pi(P_{A},P_{B}))=\Omega(n\log n)$ which proves that any $\epsilon$-error randomized protocol that solves the PartitionComp problem has communication complexity of $\Omega(n\log n)$. This in turn implies that $t=\Omega(\log n)$ which proves the theorem. ∎

5 Future Work

In this paper, we used various techniques to obtain better lower bounds for Connectivity in the BCC$(1)$ model. However, these bounds are still quite weak and the gap between these lower bounds and the best upper bound is substantial. The fundamental question that motivated this paper, one that is still open is this.

Question 1**.**

Can we obtain $\omega(\log n)$ round lower bounds for Connectivity in the BCC$(1)$ model or show that this is not possible by designing an algorithm running in $O(\log n)$ rounds?

Another way to ask this question is can we obtain super-constant round lower bounds in the BCC$(\log n)$ model? It is worth noting again that we have a deterministic upper bound for Connectivity of $O(\log n/\log\log n)$ [JN18] in BCC$(\log n)$, whereas our results do not imply a better than $\Omega(1)$ lower bound in BCC$(\log n)$.

A second open question, one that is more relevant to the techniques used in this paper is the following.

Question 2**.**

Can we get an $\Omega(n\log n)$ lower bound on the randomized constant-error communication complexity for the Partition and TwoPartition problems?

Using the reductions in this paper, a positive answer to this question would imply an $\Omega(\log n)$ lower bound for Connectivity in BCC$(1)$ KT-1 model even for constant-error randomized algorithms.