Beyond Alice and Bob: Improved Inapproximability for Maximum Independent Set in CONGEST

03/16/2020
by   Yuval Efron, et al.
0

By far the most fruitful technique for showing lower bounds for the CONGEST model is reductions to two-party communication complexity. This technique has yielded nearly tight results for various fundamental problems such as distance computations, minimum spanning tree, minimum vertex cover, and more. In this work, we take this technique a step further, and we introduce a framework of reductions to t-party communication complexity, for every t≥ 2. Our framework enables us to show improved hardness results for maximum independent set. Recently, Bachrach et al.[PODC 2019] used the two-party framework to show hardness of approximation for maximum independent set. They show that finding a (5/6+ϵ)-approximation requires Ω(n/log^6 n) rounds, and finding a (7/8+ϵ)-approximation requires Ω(n^2/log^7 n) rounds, in the CONGEST model where n in the number of nodes in the network. We improve the results of Bachrach et al. by using reductions to multi-party communication complexity. Our results: (1) Any algorithm that finds a (1/2+ϵ)-approximation for maximum independent set in the CONGEST model requires Ω(n/log^3 n) rounds. (2) Any algorithm that finds a (3/4+ϵ)-approximation for maximum independent set in the CONGEST model requires Ω(n^2/log^3 n) rounds.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

06/27/2019

Improved Distributed Approximation to Maximum Independent Set

We present improved results for approximating Maximum Independent Set ()...
05/24/2019

Hardness of Distributed Optimization

This paper studies lower bounds for fundamental optimization problems in...
05/21/2020

A Massively Parallel Algorithm for Minimum Weight Vertex Cover

We present a massively parallel algorithm, with near-linear memory per m...
10/30/2019

Improved Local Computation Algorithm for Set Cover via Sparsification

We design a Local Computation Algorithm (LCA) for the set cover problem....
05/11/2018

Distributed Minimum Vertex Coloring and Maximum Independent Set in Chordal Graphs

We give deterministic distributed (1+ϵ)-approximation algorithms for Min...
05/13/2019

Computing Maximum Matchings in Temporal Graphs

We study the computational complexity of finding maximum-cardinality tem...
03/20/2021

Round and Communication Balanced Protocols for Oblivious Evaluation of Finite State Machines

We propose protocols for obliviously evaluating finite-state machines, i...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

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 two-party 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 max-clique [10], hardness of distribued optimization [4], distributed random walks [20], and more (a complete list of papers is infeasible).

While the two-party 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 three-party set-disjointness problem to show a lower bound for triangle detection in the CONGEST-Broadcast 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 multi-party 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 multi-party 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 two-party 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 multi-party construction, but rather are artifacts of the simplifications compared to [4].


The two-party reduction technique in a nutshell: The vast majority of these reductions rely on the high communication complexity of the two-party set-disjointness problem. In the set-disjointness 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 set-disjointness [19, 25]. A reduction to the set-disjointness 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 set-disjointness, 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 two-party 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 vice-versa. 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 two-party set-disjointness 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 set-disjointness 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.

Censor-Hillel at al.[8] showed a small-cut two-party 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 sub-logarithmic algorithms exist [5, 18]. In terms of lower bounds, recently Bachrach et al. [4] built on the small-cut construction of [8], together with a very clever use of error-correcting codes, to prove near-linear hardness for -approximation, and near-quadratic hardness for -approximation.


Limitations of the two-party framework: As pointed out by [4], the two-party 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 two-party 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 two-party 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 vertex-cover 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 two-party 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 two-party framework to the multi-party case is to use a reduction to the multi-party set-disjointness problem. In the multi-party 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 multi-party set-disjointness problem is not a simple task, and as gets larger, the task becomes more challenging. This is because in the non-intersecting case, there are many sub-cases of pairwise intersections, and the reduction needs to take into account all these sub-cases. For example, if we try to extend the reduction of [4] to the multi-party set-disjointness problem, in the non-intersecting 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 non-intersecting case, the reduction needs to take into account all the sub-cases of pairwise intersections, and, the more players we have, the more sub-cases 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 multi-party set-disjointness 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 non-intersecting case, for all pairs , it holds that and are disjoint. Most importantly, we don’t have many sub-cases of pairwise intersections in the non-intersecting 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.


Road-map: In Section 2, we begin with some useful definitions and tools. In Section 3, we present our framework of reductions to the multi-party 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 Multi-party Communication Complexity

Our lower bounds rely on reductions to the number-in-hand model of multi-party communication complexity. In the number-in-hand 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 number-in-hand 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 intersecting444Throughout 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 error-correcting codes that was used in [4]. Let us define the notion of a code-mapping. 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.

[Code-mapping]
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 code-mapping with parameters is a function , such that for every , .

Our proofs use the following Theorem that shows the existence of large-distance codes (Lemma 19.11 in  [3]).

Theorem 4.

Let be an alphabet of size . There is a code-mapping with parameters , where and .

One way to construct a code-mapping that proves Theorem 4 is by the so called Reed-Solomon code, which is a well-known algebraic construction for error-correcting codes. In our proofs we don’t need the details of the construction, but only its existence.

3 Multi-Party 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 multi-party communication complexity. Our framework extends the framework of [8] for the 2-party case. In [8], the authors define the notion of a family of lower bound graphs for the 2-party 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:555Throughout the paper, we use the notation to emphasize that is a partition of .

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

  2. 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 2-party 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 vertex-weighted graph with weight function , and let be the value of an optimal solution for maximum independent set.666Throughout 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 .

The following corollary follows from Theorems 3 and 5.

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 code-mapping 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 code-mapping 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 code-gadget is as follows. Given a code-word , 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 code-word , 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 .

Figure 1: An example of the base graph , where , . is a clique of nodes, and there are cliques , and , each of size . In this example, we assume that the code-mapping of , , and therefore, in connected to all the nodes in , except of the nodes in . The other edges between are omitted in this figure, for clarity.
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 code-gadget, where the clique is denoted by , the code-gadget is denoted by , the cliques in the code-gadget are denoted by , and for any , the nodes in are denoted by . Similarly, denotes the set of nodes in that corresponds to the code-word . 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 ,

Figure 2: An illustration for the connections between and . In this example, . Observe that for any , is connected to all the nodes in except of .

See also Figure 2 for an illustration of these connections. This concludes our fixed graph construction , and we proceed to describing .

Figure 3: Here, we have an illustration for a 3 players construction, where , and . Observe that for any , is connected by a dashed edge to . This dashed edge represents all the connections between and , as illustrated in Figure 2. Observe that is an independent set.
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 code-mapping 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 code-mapping of , and let the be the code-mapping 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 code-mapping 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 Warm-up:

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.

For the rest of this subsection, we assume that . Lemma 1 is a corollary of Claims 1 and 2.

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.

  1. 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 .

  2. 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 graphs777In 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.

Lemma 2 follows from Claims 3 and 5.

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 code-mapping of . Hence, we have that