1 Introduction and Related Work
Consider a network of nodes, where each has a unique bit identifier, and they can communicate with each other via synchronized communication rounds. In each round, each node can send a (possibly different) bit message to each of its neighbors. The task of the nodes is to compute some function of the network (e.g., its diameter, the value of a maximum independent set, etc.), while minimizing the number of communication rounds. This model is well known as the CONGEST model, and it is one of the major models of theoretical distributed graph algorithms [21].
In recent years, our understanding of the complexity of some problems in the CONGEST model has been substantially improving, thanks to a fruitful technique for proving lower bounds via reductions to twoparty communication complexity. This technique, that was implicitly introduced by Peleg and Rubinovich [23, 22], and explicitly and formally defined by Das Sarma et al. [27, 26], was used to prove many lower bounds for fundamental graph problems, such as distance computations [1, 14, 17], minimum spanning tree [22, 12, 26], minimum cut [15, 26], minimum vertex cover [8], constructing and verifying spanners [6, 7], subgraph detection [11, 13, 16], approximate maxclique [10], hardness of distribued optimization [4], distributed random walks [20], and more (a complete list of papers is infeasible).
While the twoparty communication complexity model is already a very successful source for reductions, a natural question is whether using more players can bring us even closer to a satisfactory understanding of the CONGEST model. In [11], the authors use a reduction to the threeparty setdisjointness problem to show a lower bound for triangle detection in the CONGESTBroadcast model, where unlike in the CONGEST model, the nodes are not allowed to send different messages to different neighbors in each round, and they can only broadcast one bit message to all their neighbors in each round. This lower bound doesn’t translate to the CONGEST model (In fact, no lower bound better than round is known for triangle detection in the CONGEST model [2, 13]). Whether multiparty communication complexity is of any use to show stronger results for the CONGEST model has remained open.
In this work, we introduce a framework of reductions to multiparty communication complexity. Our framework enables us to show improved hardness results for maximum independent set in the CONGEST model. Recently, Bachrach et al.[4] showed that any algorithm that finds a approximation for maximum independent set must spend rounds. Furthermore, they showed that finding a approximation requires rounds, which is nearly tight, as any problem can be solved in rounds in the CONGEST model. Our results:
Theorem 1.
For any constant , any algorithm that finds a approximation for maximum independent set in the CONGEST model requires rounds.
Theorem 2.
For any constant , any algorithm that finds a approximation for maximum independent set in the CONGEST model requires rounds.
While our results are not necessarily tight, we hope that our technique could pave the way for more and stronger lower bounds in the CONGEST model. One important property of our technique is that it doesn’t suffer from the same limitations as the twoparty framework, on which we elaborate later. We note our results hold even against randomized algorithms that succeed with probability
, and even for constant diameter graphs. The hard instances that are used to prove Theorems 1 and 2 are weighted graphs, but we can extend our arguments for unweighted graphs as well by losing a logarithmic factor in the lower bounds (in terms of the number of rounds), as explained in Remark 1.To prove Theorems 1 and 2 we use reductions to party communication complexity where we use players. For , our constructions are similar to the ones presented in [4], and can be viewed as simplified versions of them. While we also get a minor improvement in terms of the number of rounds (and not only in terms of approximations) it is worth pointing out that the improvements we get in terms of the number of rounds are not artifacts of the multiparty construction, but rather are artifacts of the simplifications compared to [4].
The twoparty reduction technique in a nutshell: The vast majority of these reductions rely on the high communication complexity of the twoparty setdisjointness problem. In the setdisjointness problem, there are two players, Alice and Bob, who receive two input strings , where Alice receives , Bob receives , and they wish to know if their strings intersect. That is, they wish to know if there is an index , such that . It is well known that Alice and Bob must exchange bits in order to solve setdisjointness [19, 25]. A reduction to the setdisjointness problem is usually applied in the following manner. Assume that we want to prove a lower bound in the CONGEST model for deciding whether an input graph has some property (for example, can be the property of having a diameter less than ). Alice and Bob, before they start the protocol for setdisjointness, decide on a fixed graph construction , and a partition of into two graphs and , where is owned by Alice, and is owned by Bob. Then, each of the players adds some edges to their own graph based on their input string, where Alice adds edges based on , Bob adds edges based on , and the set of cut edges between and is fixed and doesn’t depend on the input strings. The construction is defined in a way such that the strings and are disjoint if and only if the graph, with the additional edges based on the input strings, has the property . Hence, in order to find whether and are disjoint, Alice and Bob can simulate a CONGEST algorithm that checks whether an input graph has the property . Simulating the CONGEST algorithm in the twoparty communication complexity model is done as follows. For messages that are sent on edges in , Alice can simulate these messages without any communication with Bob. Similarly, Bob can simulate the messages that are sent on edges in , without any communication with Alice. For the other messages, the ones that are sent on edges in the cut between and , Alice and Bob exchange messages: if there is a message from a node in to a node in , then Alice sends this message to Bob, and viceversa. The conclusion that is made in such reductions is that if there is an round algorithm for deciding in the CONGEST model, and if the number of edges on the cut betwen and is at most , then there is a protocol for solving twoparty setdisjointness that uses bits. This is because on each edge on the cut, the CONGEST algorithm sends bits in each of the rounds. Hence, since the communication complexity of setdisjointness is , we get a lower bound of rounds for any algorithm for deciding in the CONGEST model. That is, the smaller the cut, the stronger the lower bound.
CensorHillel at al.[8] showed a smallcut twoparty construction to prove a lower bound for maximum independent set, where they show that any algorithm for finding or computing the optimal value of a maximum independent set must spend rounds. An independent set in a graph is a subset of the nodes where no two nodes in the subset are neighbors. A maximum independent set in a (possibly weighted) graph is an independent set of maximum total weight, where by total we mean the sum of the weights of the nodes in the independent set. Independent sets play vital role in theoretical and practical computer science, and the problem of computing exact or approximate maximum independent set has been attracting attention recently in the CONGEST model [4, 8, 18, 5]. However, in terms of upper bounds, we are still unable to find fast algorithms that achieve approximation factors better than , where is the maximum degree of a node in the graph. If one is happy with a approximation, or a approximation, then very fast and even sublogarithmic algorithms exist [5, 18]. In terms of lower bounds, recently Bachrach et al. [4] built on the smallcut construction of [8], together with a very clever use of errorcorrecting codes, to prove nearlinear hardness for approximation, and nearquadratic hardness for approximation.
Limitations of the twoparty framework: As pointed out by [4], the twoparty framework suffers from some limitations. Especially, but not only, when trying to use it to prove hardness of approximation. For example, for the maximum independent set problem, the twoparty framework cannot show any lower bound against algorithms that achieve approximation. This is because Alice and Bob can compute the optimal solutions for maximum independent set in the graphs and , without any communication, where Alice finds the optimal solution in , and Bob finds the optimal solution in . The maximum of the two values is always at least half of the optimal solution for . Hence, by just exchanging the two values, which takes bits of communication, Alice and Bob can find a approximation for maximum independent set. Since bits can be sent in one round in the CONGEST model, no lower bound for this approximation factor can be shown by using the twoparty framework. Similarly, the two party framework suffers from a limitation when trying to show a lower bound for approximation to minimum vertex cover, where the argument for vertexcover is not trivial and was proved also in [4].
By using more players, the framework doesn’t suffer from the same limitations as in the twoparty case. For example, with respect to approximating maximum independent set, the argument above translates only to a limitation of showing a approximation. Hence, the more players we use, the less restrictive the limitations we get.
The Challenge: Perhaps the first attempt that one would try in order to extend the twoparty framework to the multiparty case is to use a reduction to the multiparty setdisjointness problem. In the multiparty set disjointness problem, there are players . Each receives a string , and they wish to know if the strings all intersect on the same index. That is, they wish to know if there is an index satisfying . However, using a reduction to the multiparty setdisjointness problem is not a simple task, and as gets larger, the task becomes more challenging. This is because in the nonintersecting case, there are many subcases of pairwise intersections, and the reduction needs to take into account all these subcases. For example, if we try to extend the reduction of [4] to the multiparty setdisjointness problem, in the nonintersecting case, for every pair , whether the strings and are intersecting or not influences the size (or weight) of the maximum independent set. Hence, for the nonintersecting case, the reduction needs to take into account all the subcases of pairwise intersections, and, the more players we have, the more subcases we get, and the more infeasible the reduction becomes.
In order to overcome this challenge, we use reductions to a certain promise pairwise disjointness problem, rather than the multiparty setdisjointness problem. In this promise pairwise disjointness problem, there are players each receiving a string , with the promise that the strings are either all intersecting in the same index, or pairwise disjoint. That is, in the nonintersecting case, for all pairs , it holds that and are disjoint. Most importantly, we don’t have many subcases of pairwise intersections in the nonintersecting case. The communication complexity of this promise pairwise disjointness problem is [9], which is large enough for our needs, and we are able to use it to prove our results.
Roadmap: In Section 2, we begin with some useful definitions and tools. In Section 3, we present our framework of reductions to the multiparty communication complexity model. The technical heart of the paper is provided in Sections 4 and 5, where we show our linear and quadratic lower bounds, respectively.
2 Preliminaries
2.1 Multiparty Communication Complexity
Our lower bounds rely on reductions to the numberinhand model of multiparty communication complexity. In the numberinhand model, there are players, each is holding an input , and they wish to compute a joint function of their inputs , where and are parameters of the model. The communication setting in the numberinhand model can be defined in various ways. In this work we use the shared blackboard model (see also, for example,[24]), where the players can exchange messages by writing them on a shared blackboard that is visible to all the players. The communication complexity in this model is formally defined as follows.
Definition 1.
[Communication Complexity  Shared Blackboard]
Let , be two integers, be a Boolean function , and be the family of protocols that compute correctly with probability at least , in the shared blackboard model. Given inputs , denote by
the transcript of a protocol on the inputs , i.e. the sequence of
bits that are written on the shared blackboard. The cost of a protocol is
The communication complexity of , denoted by , is defined to be the minimum cost over all the possible protocols that compute correctly with probability at least :
Our lower bounds for the CONGEST model are achieved via reductions to the promise pairwise disjointness function. For two strings , we say that and are disjoint if .
Definition 2.
[Promise Pairwise Disjointness]
Let , , and , with the promise that the strings are either uniquely intersecting, or pairwise disjoint. That is, either there is an satisfying , or and are disjoint for all pairs . The promise pairwise disjointness function outputs if the strings are pairwise disjoint, and if they are uniquely intersecting^{4}^{4}4Throughout the paper, for any positive integer , we denote by the set of positive integers ..
Chakrabarti et al.[9] proved that the communication complexity of the promise pairwise disjointness function in the shared blackboard model is .
Theorem 3.
[Theorem 2.5 in[9]]
Let be the promise pairwise disjointness function. It holds that .
2.2 Large Distance Codes
Our proofs use the tool of errorcorrecting codes that was used in [4]. Let us define the notion of a codemapping. Here, we use a similar definition to the one given by Arora and Barak [3] (Chapter 19, Definition 19.5, page 380, in [3]).
Definition 3.
[Codemapping]
Let be a finite set of symbols, called the alphabet. Fix three integers , and . For two strings , the distance of and , denoted by , is equal to .
A codemapping with parameters is a function , such that for every , .
Our proofs use the following Theorem that shows the existence of largedistance codes (Lemma 19.11 in [3]).
Theorem 4.
Let be an alphabet of size . There is a codemapping with parameters , where and .
One way to construct a codemapping that proves Theorem 4 is by the so called ReedSolomon code, which is a wellknown algebraic construction for errorcorrecting codes. In our proofs we don’t need the details of the construction, but only its existence.
3 MultiParty Communication Complexity Reductions
In this section we show how to prove lower bounds for the CONGEST model via reductions to the shared blackboard model of multiparty communication complexity. Our framework extends the framework of [8] for the 2party case. In [8], the authors define the notion of a family of lower bound graphs for the 2party case. In this work, we extend this notion for any arbitrary number of players.
Definition 4.
[Family of Lower Bound Graphs]
Given two integers , , a boolean function , and a graph predicate , a family of graphs is said to be a family of lower bound graphs with respect to and if there is a partition of the set of nodes for which the following properties hold:^{5}^{5}5Throughout the paper, we use the notation to emphasize that is a partition of .

Only the weight of the nodes in and the existence of edges in may depend on ;

satisfies the predicate iff .
The intuition behind the definition of a family of lower bound graphs is as follows. Given a function whose input is split among players , where receives a string , and given a family of lower bound graphs with respect to and some graph predicate . In order for the players to compute the value , they can construct the graph , where , and check whether satisfies the predicate . Due to the first condition of Definition 4, each player can construct the graph induced by the nodes in without any communication with the other players. Due to the second condition of Definition 4, satisfies the predicate if and only if . Hence, the problem of deciding whether satisfies is reduced to computing the value .
Next, we prove the following reduction theorem, which is based on a standard simulation argument. This theorem extends the reduction theorem of [8] for the 2party case (Theorem 1 in [8]). Given a family of lower bound graphs and a graph in it, we denote by the set of cut edges of . That is, .
Theorem 5.
Fix , , , and a graph predicate . If there is a family of lower bound graphs w.r.t. and , then any algorithm for deciding in the CONGEST model with success probability at least requires rounds.
Proof.
Let be a distributed algorithm in the CONGEST model that decides in rounds. We define a protocol for in the shared blackboard model, as follows. Let
be the vector of inputs of the players
, where receives the string , in the shared blackboard model. Each player constructs the part of for the nodes in . This can be done by the first condition of Definition 4, and the fact that the ’s are disjoint.The players simulate , where each player simulates the nodes in , as follows. All the messages that are sent on edges in are simulated by player , without any communication with the other players. All the other messages, the ones that are sent on edges in , are written on the shared blackboard. That is, whenever there is a message from some node in to some node in for , player writes this message on the shared blackboard, which is visible to all the other players. In particular, it is visible to who is simulating the nodes in .
After simulating the rounds of , the players know whether satisfies the predicate , and by the second condition of Definition 4, this reveals the information about . Observe that the total number of bits that are written on the blackboard are . This is because an algorithm in the CONGEST model sends at most bits on each edge in each round, and the only messages that are written on the blackboard are the ones that are sent on the edges in . Hence, the communication complexity of is at most and therefore, . ∎
Our hardness results use families of lower bound graphs with respect to the promise pairwise disjointness function and a gap predicate . We formalize such families in Definition 6. First, we formally define the notion of approximation for maximum independent set.
Definition 5.
[approximation for maximum independent set]
Let be a vertexweighted graph with weight function , and let be the value of an optimal solution for maximum independent set.^{6}^{6}6Throughout the paper, for a subset of nodes , we denote by . An independent set in is approximation for maximum independent set if .
Definition 6.
[approximate MaxIS family of lower bound graphs]
Fix . Let be a graph predicate that distinguishes between graphs of maximum independent set of weight at least , and graphs of maximum independent set of weight at most . A family of graphs is called a approximate MaxIS if it is a family of lower bound graphs with respect to the promise pairwise disjointness function and the graph predicate .
Corollary 1.
Let , be two integers. If there is a approximate MaxIS family of graphs , then any algorithm for approximation of maximum independent set in the CONGEST model with success probability at least requires rounds.
4 Linear Lower Bound
In this section we prove the following theorem.

For any constant , any algorithm that finds a approximation for maximum independent set in the CONGEST model requires rounds.
In order to prove Theorem 1, we construct a approximate family of lower bound graphs .
4.1 The family of lower bound graphs
We start by describing a fixed graph construction , and then we describe how to get from and a vector of strings the graph , which gives a family of graphs .
Our fixed graph construction contains copies of a fixed base graph . We start by describing the base graph .
Some notations.
Let be three positive integers that are to be chosen later such that , and . Let be a codemapping given by Theorem 4 with parameters , where . Observe that . Hence, we order the elements in by an arbitrary ordering, and for , we denote by the codemapping of the ’th element in .
Description of .
The set of nodes contains a clique of size , denoted by , and cliques, , each of size . For each , the nodes in are denoted by . We call the cliques the code gadget, and we denote this set of nodes by
The reason that these cliques are called the codegadget is as follows. Given a codeword , we can represent by nodes , where corresponds to the ’th position in . That is, , where is the value in the ’th position in . For any , we denote by the set of nodes that corresponds to the codeword , and we connect to all the nodes in .
This concludes the description of (see also Figure 1 for an example). More formally, the graph is defined as follows. Given a clique , we denote by the set of all the possible edges between nodes in .
Obtaining the fixed graph construction from :
Now we are ready to describe the fixed graph construction . Let . There are copies of in , denoted by . In order to distinguish between nodes in different ’s, we add a superscript for the nodes in . That is, for each , contains a clique and a codegadget, where the clique is denoted by , the codegadget is denoted by , the cliques in the codegadget are denoted by , and for any , the nodes in are denoted by . Similarly, denotes the set of nodes in that corresponds to the codeword . That is, let , we have that .
It remains to describe the connections between and , for any . For any , we add all the possible edges between and except of the natural perfect matching between and , i.e., . More formally, we add the following edges for any and any ,
See also Figure 2 for an illustration of these connections. This concludes our fixed graph construction , and we proceed to describing .
Obtaining from and :
Given . The graph is defined as follows. The sets of nodes and edges of are exactly as in . The weights of nodes in are defined as follows. Let , , and ,
All the other nodes in are of weight . That is, for any , .
This concludes the description of . Before we proceed to proving that is a family of lower bound graphs, we provide three useful properties of that are used in the proof.
Property 1.
For any , it holds that is an independent set.
Proof.
First, observe that the nodes in are independent. This is because , and there are no edges between and for any . There are also no edges between and , for any . Furthermore, for any and any , it holds that is an independent set. This is because is connected only to the nodes in . Finally, let be the codemapping of . Since for any , we have that , and , and is not connected to for any , we have that is an independent set. Hence, the union is an independent set. See also Figure 3 for an illustration. ∎
Property 2.
For any , and any , the bipartite graph contains a matching of size at least .
Proof.
Let be the codemapping of , and let the be the codemapping of . Given , observe that is connected to all the nodes in . Hence, since the distance between and is at least , there are at least positions for which , and therefore, there are at least positions for which it holds that is connected to , where is the ’th position in and is the ’th position in . ∎
Property 3.
Let , let , and let be any independent set. Let be the code mapping of , and let be the codemapping of . The number of positions for which it holds that and is at most .
Proof.
By Property 2, the bipartite graph contains a matching of size at least . Therefore, there are at least positions for which contains at most one of the nodes and . This leaves at most other positions for which can contain both and . ∎
4.2 is a approximate family of lower bound graphs
In this section we show that there is a constant for which is a approximate family of graphs. We start with a slightly weaker statement for , which is later used in the proof for .
4.2.1 Warmup:
In this section we prove the following lemma.
Lemma 1.
For , and for any constant , it holds that is a approximate family of lower bound graphs.
Claim 1.
For any , if and are not disjoint, then contains an independent set of weight at least .
Proof.
Since the sets are not disjoint, there is an for which . Therefore, the weight of each of the nodes and is . By Property 1, the set is independent, and observe that its weight is . ∎
Claim 2.
For any , if and are disjoint, then any independent set in is of weight at most .
Proof.
The proof is by the following simple case analysis.

contains at most one node of weight : In this case, the node of weight must be either in the clique or in the clique . Assume without loss of generality that this node is in . Observe that we can take at most one node of weight from . Furthermore, since each of and is a union of cliques, we cannot construct an independent set in of weight larger than , it follows that the weight of cannot be larger than .

contains two nodes of weight : This implies that contains one node of weight and another node of weight , where . Since the strings are disjoint, it must be the case that . Furthermore, since is connected to the nodes in , and is connected to the nodes in , it remains to show that . By Property 2, contains a matching of size at least , and since , this implies that . To conclude, in this case, contains nodes of weight and nodes of weight . In total, the weight of is .
Notice that cannot contain more than elements of weight since the elements of weight form two disjoint cliques. ∎
Proof of Lemma 1.
Claims 1 and 2 imply that is a family of lower bound graphs with respect to the set disjointness function and the graph predicate that distinguishes between graphs of maximum independent set at least and graphs of maximum independent set at most .
We set . Hence as desired. Since the dominating terms in the two cases are and , it follows that for any constant , is a approximate family of graphs^{7}^{7}7In fact, by slightly changing the parameters and , the claim holds for any .. ∎
4.2.2 Hardness Amplification using Players
In this section we prove the following lemma.
Lemma 2.
For any constant , there is a constant for which it holds that is a approximate family of lower bound graphs.
Claim 3.
For any positive integer , and any , if there is an for which it holds that , then contains an independent set of weight at least .
Proof.
Observe that for any , it holds that . Furthermore, by Property 1, is an independent set, and it is of weight . ∎
Before we proceed to the case in which the strings are pairwise disjoint, let us prove the following helper claim and a corollary of it.
Claim 4.
For any positive integer . Let be any distinct values in . For any independent set , if , then
Proof.
Let us start with some notations. Let be the codemapping of . Hence, we have that
Comments
There are no comments yet.