New Lower Bounds for the CONGEST Model. Seri Khoury

Transcription

1 New Lower Bounds for the CONGEST Model Seri Khoury

2

3 New Lower Bounds for the CONGEST Model Research Thesis Submitted in partial fulfillment of the requirements for the degree of Master of Science in Computer Science Seri Khoury Submitted to the Senate of the Technion Israel Institute of Technology Tamuz 5778 Haifa July 2018

4

5 This research was carried out under the supervision of Prof. Keren Censor-Hillel, in the Faculty of Computer Science. Some results in this thesis have been published as articles by the author and research collaborators during the course of the author s masters research period, the most up-to-date versions of which being: Amir Abboud, Keren Censor-Hillel, and Seri Khoury. Near-Linear Lower Bounds for Distributed Distance Computations, Even in Sparse Networks. In Distributed Computing - 30th International Symposium, DISC 2016, pages Keren Censor-Hillel, Seri Khoury, and Ami Paz. Quadratic and Near-Quadratic Lower Bounds for the CONGEST Model. In Distributed Computing - 30th International Symposium, DISC 2017, pages Amir Abboud, Keren Censor-Hillel, Seri Khoury, and Christoph Lenzen. Fooling Views: A New Lower Bound Technique for Distributed Computations under Congestion. CoRR abs/ (2017) Acknowledgements I would like to thank professor Keren Censor-Hillel for her support and guidance. Prof. Censor- Hillel has a huge impact on my research and academic perspectives. I feel that her guidance pushed me a few steps forward towards reaching my limits, and I am fortunate to work under her supervision. The generous financial help of the Technion is gratefully acknowledged.

6

7 Contents Abstract 1 Abbreviations and Notations 3 1 Introduction First Part: the Two Party Communication Complexity Framework First Contribution: Lower Bounds for Diameter and Radius Second Contribution: Near-Quadratic Lower Bounds Second Part: Fooling Views - A New Lower Bound for Triangle Detection Prior Lower Bound Techniques and Their Limits Our Contribution Additional Related work 17 3 Preliminaries Computational Model Basic Definitions Lower Bound Graphs Part I: Communication Complexity Reductions The Bit-Gadget Construction Exact Diameter (3/2 ε)-approximation of the Diameter Radius Minimum Vertex Cover Graph Coloring Part : Fooling Views, A New Lower Bound Technique A Bandwidth Lower Bound for One round Triangle Membership A Round Lower Bound for Triangle Detection with B = Fooling sets of triangles Triangles and 6-Cycles Conclusions 49

8

9 Abstract In this thesis we study the Congest model of distributed computing. We focus on proving lower bounds for solving fundamental graph problems for this model. In the first part of this thesis, we investigate the framework of reductions from two-party communication problems, which is a well known technique for proving lower bounds for distributed computing. We present a new gadget for this framework which we refer to as the bit-gadget. The contribution of the bit-gadget is twofold. First, developing careful sparse graph constructions with small cuts extends known techniques to show a near-linear lower bound for computing the diameter, a result previously known only for dense graphs. Moreover, the sparseness of the construction plays a crucial role in applying it to approximations of various distance computation problems, drastically improving over what can be obtained when using dense graphs. Second, small cuts are essential for proving super-linear lower bounds, none of which were known prior to this work. In fact, they allow us to show near-quadratic lower bounds for several problems, such as exact minimum vertex cover or maximum independent set, as well as for coloring a graph with its chromatic number. All of the above are optimal up to logarithmic factors. Unfortunately, the two-party communication framework is provably incapable of providing any lower bounds for some fundamental graph problems, such as triangle detection and finding a maximal independent set. Nevertheless, in the second part of this thesis we study a new technique, which we refer to as the Fooling Views technique. We use this technique together with extremal graph combinatorics to prove the first lower bound for triangle detection for the Congest model. 1

10 2

11 Abbreviations and Notations n : the number of nodes in a graph m : the number of edges in a graph dist(u, v) : the distance between two nodes, u and v, in a network D : the diameter of a network LOCAL : a distributed computational model with unbounded message size CONGEST : a distributed computational model with a message size bounded by O(log n) 3

12 4

13 List of Figures 4.1 The bit-gadget construction Diameter lower bound construction Diameter approximation lower bound construction Radius lower bound Lower bound graph for minimum vertex cover Lower bound graph for 3-coloring A failed attempt to color A 1 without using c A coloring of A 1 with a 1 1 colored c Part of the 3-coloring lower bound graph for k = A failed attempt to color only a 0 1 and b1 1 by c A valid coloring with a 1 1 and b1 1 colored c A coloring of a lower bound graph Triangle membership lower bound The structures for proving the lower bound

14 6

15 Chapter 1 Introduction Consider the following communication model: there is a synchronized communication network which consists of n nodes, each having a unique identifier of an O(log n) bits. Each node is assumed to be computationally unbounded. At the beginning, each node knows its own identifier and the identifiers of its neighbors in the network. In each communication round, every node may send an O(B)-bit message to each of its neighbors. The goal of the nodes is to compute some function of the network while minimizing the number of communication rounds. This model is known as the Congest(B) model of distributed computing, and it was mostly studied in two particular cases: the case in which B = log n, which is known as the Congest model, and the case in which B =, which is known as the Local model [85]. Our goal in this thesis is to understand the complexity of fundamental graph problems in the Congest(B) model. It is well-known and easily proven that many graph problems are global for distributed computing, in the sense that solving them necessitates communication throughout the network. This implies tight Θ(D) complexities, where D is the diameter of the network, for global problems in the Local model. Since each node is allowed to send an unbounded message to each of its neighbors in each round in the Local model, it is possible to learn the entire topology in D rounds. Therefore, since each node is assumed to be computationally unbounded, any problem can be solved in at most D rounds in the Local model. Global problems are widely studied in the Congest model. The trivial complexity of learning the entire topology in the Congest model is O(m), where m is the number of edges of the communication graph, and since m can be as large as Θ(n 2 ), one of the most basic questions for a global problem is how fast in terms of n it can be solved in the Congest model. Some global problems admit fast O(D)-round solutions in the Congest model, such as constructing a breadth-first search tree [85]. Some others have complexities of Θ(D + n), such as constructing a minimum spanning tree, and various approximation and verification problems [42, 47, 56, 86, 87, 91]. Some problems are yet harder, with complexities that are nearlinear in n [2, 42, 49, 67, 86]. For some problems, no O(n) solutions are known and they are candidates to being even harder than the ones with linear-in-n complexities. In this thesis, we focus on proving lower bounds for the Congest(B) model. We study two techniques for proving lower bounds. The first is known as the framework of reductions from the two-party communication model. We show a new gadget for this framework that allows us to prove stronger lower bounds. Using this new gadget, we show a near-linear lower bound for 7

16 computing the exact diameter or radius in sparse networks in the Congest model. This lower bound holds also against (3/2 ɛ)-approximation algorithms, and also against randomization. Furthermore, the new gadget allows us to show near-quadratic lower bounds for computing the size of a minimum vertex cover and for computing the chromatic number of a graph. These are the first super-linear lower bounds for the Congest model, and they hold against randomization as well. The framework of reductions from the two-party communication model, our new gadget, and the results using this technique are elaborated in Section 1.1. While the framework of reductions from the two-party communication model is very useful and mostly used to prove lower bounds for global problem in the Congest model, it is provably incapable of providing any lower bounds for some fundamental local graph problems 1. An intriguing example is the triangle detection problem, which can be easily solved even in a single round in the Local model, but no lower bound was previously known for the Congest model, not even for the Congest(1) model, in which each node is allowed to send a single bit to each of its neighbors in each round. Nevertheless, in the second part of this thesis, we study a new technique which we refer to as the Fooling Views technique, and we use it together with extremal graph combinatorics to prove the first lower bound for triangle detection in the Congest(1) model. Furthermore, we show an optimal bandwidth lower bound for any single round algorithm for solving triangle membership. The Fooling Views Technique, and our lower bounds for triangle detection and membership are elaborated in Section First Part: the Two Party Communication Complexity Framework In the first part of this thesis we provide lower bounds for the standard Congest model of distributed computing, which corresponds to the Congest(log n) model. Many lower bounds for the Congest model rely on reductions from two-party communication problems (see, e.g., [29, 36, 37, 42, 49, 76, 77, 87, 91]). In this setting, two players, Alice and Bob, are given inputs of K bits and need to compute a single output bit according to some given function of their inputs. The standard framework for reducing a two-party communication problem of computing a function f to deciding a graph predicate P in the Congest model is as follows. Given an instance (x, y) of the two-party problem f, a graph is constructed such that the value of P on it can be used to determine the value of f on (x, y). Some of the graph edges are fixed, while the existence of some other edges depends on the inputs of Alice and Bob. Then, given an algorithm ALG for solving P in the Congest model, the vertices of the graph are split into two sets, V A and V B, and Alice simulates ALG over V A while Bob simulates ALG over V B. The only communication required between Alice and Bob in order to carry out this simulation is the content of messages sent in each direction over the edges of the cut C = E(V A, V B ). Using this technique for a two-party problem f on K bits with communication complexity CC(f, K) and a graph with a 1 In this thesis, we say that a problem is local if it can be solved in at most a poly-logarithmic number of rounds in the Local model. 8

17 cut C, it can be proven that the complexity of ALG is at least Ω(CC(f, K)/ C log n) in the Congest model. Thus, the cost of the reduction depends on two parameters of the graph construction, which are (i) the size of the input, K, and (ii) the size of the cut, C. All previously known constructions are both dense and have large cuts, which causes them to suffer from two limitations. The first limitation is that lower bounds for global approximation tasks, such as approximating the diameter of the graph, which are typically obtained through stretching edges in the construction into paths by adding new nodes, must pay a significant decrease in the size of the input compared to the number of nodes because of their density. Together with their large cuts, this causes such lower bounds to stay well below linear. For example, the graph construction for the lower bound for computing the diameter [42] has K = Θ(n 2 ) and C = Θ(n), which gives an almost linear lower bound of Ω(n/ log n) using the set-disjointness problem whose communication complexity is known to be Θ(K) [61]. However, because the construction is dense, although the resulting graph construction for computing a (3/2 ɛ)-approximation of the diameter [42] has a smaller cut of C = Θ( n), this comes at the price of supporting a smaller input size, of K = Θ(n), which gives a lower bound that is roughly a square-root of n. The second limitation is that large, say, linear cuts can inherently provide only linear lower bounds at best. However, tasks such as computing an exact minimum vertex cover seem to be much harder for the Congest model, despite the inability of previous constructions to prove this. In this thesis, we present the bit-gadget technique for constructing graphs with small cuts that allow obtaining strong lower bounds for the Congest model. Bit-gadgets are inspired by constructions that are used for proving conditional lower bounds for the sequential setting [4, 7, 26, 32, 89], whose power is in allowing a logarithmic-size cut. Our constructions allow bringing a lower bound for approximate diameter up to a near-optimal near-linear complexity. Furthermore, they allow us to obtain the first lower bound for computing the exact radius, solving an open question by [49]. Finally, the bit-gadget technique allows us to prove the first near-quadratic lower bounds for two natural graph problems, computing the size of a minimum vertex cover, and computing the chromatic number of a graph. These lower bounds are near-optimal since any problem in the Congest model admits a naive O(m) solution. Notably, these are the first super-linear lower bounds for this model First Contribution: Lower Bounds for Diameter and Radius Frischknecht et al. [42] showed that the diameter is surprisingly hard to compute: Ω(n) rounds are needed even in networks with constant diameter. This lower bound is nearly tight, due to an O(n) upper bound by Peleg et al. [86] and Holzer and Wattenhofer [49] and Lenzen and Peleg [67]. Naturally, approximate solutions are a desired relaxation, and were indeed addressed in several cornerstone studies [42, 47, 49, 67, 86], bringing us even closer to a satisfactory understanding of the time complexity of computing the diameter in the Congest model. Here we answer several central questions that remained elusive. 9

18 Sparse Graphs. The graphs constructed by Frischknecht et al. [42] have Θ(n 2 ) edges and constant diameter, and require any distributed algorithm for computing their diameter to spend Ω(n) rounds. Almost all large networks of practical interest are very sparse [69], e.g., the Internet in 2012 had 4 billion nodes and 128 billion edges [75]. The only known lower bound for computing the diameter of a sparse network is obtained by a simple modification to the construction of [42] which yields a much weaker bound of Ω( n). Our first result is to rule out the possibility that the Ω(n) bound can be beaten significantly in sparse networks. Theorem 1.1. Any ( algorithm ) for computing the exact diameter, even of a network of Θ(n log n) edges, requires Ω n rounds. log 2 n Our sparse construction and the proof of Theorem 1.1 appears in Section 4.2. We remark that, as in [42], our lower bound holds even for networks with constant diameter and even against randomized algorithms. We say that a graph on n nodes is sparse if it has O(n log n) edges. Due to simple transformations, e.g., adding dummy nodes, our lower bound for computing the diameter also holds for the more strict definition of sparse graphs as having O(n) edges, up to a loss of a log factor. Approximation Algorithms. An important question is whether one can bypass this nearlinear barrier if we settle for knowing only an approximation to the diameter. An α-approximation algorithm to the diameter returns a value ˆD such that D ˆD α D, where D is the true diameter of the network. From [42] we know that Ω( n + D) rounds are needed, even for computing a (3/2 ε)-approximation to the diameter, for any constant ε > 0. Holzer et al. [47] showed that a 3/2-approximation can be computed in O( n log n + D) rounds. This raises the question of whether there is a sharp threshold at a 3/2-approximation factor, or whether a (3/2 ɛ)-approximation can also be obtained in a sub-linear number of rounds. Progress towards answering this question was made by Holzer and Wattenhofer [49] who showed that any algorithm that needs to decide whether the diameter is 2 or 3 has to spend Ω(n) rounds. However, as the authors point out, their lower bound is not robust and does not rule out the possibility of a (3/2 ε)-approximation when the diameter is larger than 2, or an algorithm that is allowed an additive +1 error in addition to a multiplicative (3/2 ε) error. Furthermore, when the diameter is 2 or 3 as in their construction, any (3/2 ε)-approximation must return the exact diameter. Hence, to explain why we cannot save time by settling for a (3/2 ε)-approximation, we need a more general construction. As mentioned earlier, perhaps the main difficulty in extending the lower bound constructions of Frischknecht et al. [42] and Holzer and Wattenhofer [49] in order to resolve these gaps was that their original graphs are dense. A natural way to go from a lower bound construction for exact algorithms to a lower bound for approximations is to subdivide each edge into a path; roughly speaking, replacing each edge by a t-path transform the problem from distinguishing D = 2 from D = 3 to distinguishing D = 2t from D = 3t. When applied to dense graphs, this transformation blows up the number of nodes quadratically, resulting in an Ω( n) lower bound [42]. The sparseness of our new construction allows us to tighten the bounds and negatively resolve the above question. In particular, we show a Ω(n) lower bound for computing 10

19 a (3/2 ε)-approximation to the diameter, even if a constant additive approximation factor is also allowed. Theorem 1.2. For all constant 0 < ε < 1/2, any algorithm for computing ( a (3/2 ) ε)- approximation to the diameter, even of a network of Θ(n log n) edges, requires Ω n rounds. log 3 n The proof of Theorem 1.2 appears in Section 4.3. Radius. In many scenarios we want one special node to be able to efficiently send information to all other nodes. In this case, we would like this node to be the one that is closest to every other node, i.e. the center of the graph. The radius of the graph is the largest distance from the center, and it captures the number of rounds needed for the center node to transfer a message to another node in the network. While radius and diameter are closely related, the previous lower bounds for diameter do not transfer to radius and it was conceivable that the radius of the graph could be computed much faster. Obtaining a non-trivial lower bound for radius has been stated as an open problem in [49]. A third advantage of our technique is that it extends to computing the radius, for which we show that the same strong near-linear barriers above hold. Theorem 1.3. Any ( algorithm ) for computing the exact radius, even of a network of Θ(n log n) edges, requires Ω n rounds. log 2 n The proof of Theorem 1.3 appears in Section 4.4. This part of this thesis is based on our paper Near-Linear Lower Bounds for Distributed Distance Computations, Even in Sparse Networks. In this paper, we show near-linear lower bounds for more distance computation problems, such as computing exact or approximate all eccentricities, computing an approximation to the radius, and spanners verification [2] Second Contribution: Near-Quadratic Lower Bounds Our new bit gadget allows us to obtain the first near-quadratic lower bounds for the Congest model. Observe that high lower bounds for the Congest model may be obtained rather artificially, by forcing large inputs and outputs that must be exchanged, e.g., having each node learn its t-neighborhood for some value of t. However, we emphasize that the problems for which we show near-queadratic lower bounds can be reduced to simple decision problems, where each node needs to output a single bit. Specifically, using the bit-gadget we obtain a graph construction with a small cut that leads to the following lower bounds. Theorem 1.4. Any distributed algorithm for computing a minimum vertex cover or for deciding whether there is a vertex cover of a given size requires Ω(n 2 / log 2 n) rounds. The proof of Theorem 1.4 appears in Section 4.5. This directly applies also to computing an exact maximum independent set, as the latter is the complement of an exact minimum vertex cover. This lower bound is in stark contrast to the recent O(log / log log ) 2 -round algorithm of [17] for obtaining a (2 + ɛ)-approximation to the minimum vertex cover. 2 Where is the maximum degree in the network. 11

20 An additional super-linear lower bound that we achieve using the bit-gadget is for coloring, as follows. Theorem 1.5. Any algorithm that colors a χ-colorable graph G in χ colors or computes χ(g) requires Ω(n 2 / log 2 n) rounds. The proof of Theorem 1.5 appears in Section 4.6. This part of this thesis is based on our paper Quadratic and Near-Quadratic Lower Bounds in the CONGEST Model. In this paper, we show that quadratic lower bounds are not limited for NP hard problems, as we show quadratic lower bounds for two additional problems that are in P, finding a weighted cycle of a given length, and identical subgraph detection [30]. 1.2 Second Part: Fooling Views - A New Lower Bound for Triangle Detection In the second part of this thesis we focus on the following problem: given a network of n nodes, how many rounds does it take for the nodes to learn whether there is a triangle in the network? This problem is known as the triangle detection problem. Its complexity is poorly understood. In the naive protocol, each node sends its neighborhood to every neighbor. This takes a single round in the Local model and O(n) rounds in Congest. A clever randomized protocol of Izumi and Le Gall [51] provides a solution with O(n 2/3 (log n) 2/3 ) rounds in Congest, and this is essentially all we know about the problem. Before our work, it could not be ruled out that the problem can be solved in O(1) rounds, or even a single round, even with a bandwidth of B = 1! Open Question 1. What is the round complexity of triangle detection in the Congest model of distributed computing? Triangle detection is an extensively studied problem in most models of computation. In the centralized setting, the best known algorithm involves taking the cube of the adjacency matrix of the graph. It runs in O(n ) time and was found using a complex computer program [63, 94]. If one wishes to avoid the impractical matrix multiplication, the problem can be solved in O(n 3 / log 4 n) time [14, 31, 97]. Other works have designed algorithms for sparse graphs [10], for real-world graphs (e.g. [92]), for listing all the triangles [22, 50], for approximately counting their number [55], for weighted variants (e.g. [33]), and much more (an exhaustive list is infeasible). Moreover, conjectures about the time complexity of triangle detection and of its variants [1, 5, 6, 46, 96] are among the cornerstones of fine-grained complexity (see [95]). Other highly non-trivial algorithms were designed for it in settings such as: distributed models [27,28,35,36,41,51,52], quantum computing [20,25,62,64 66,73,93], and Map-Reduce [8,90]. It is truly remarkable that such a basic problem has lead to so much research. From a technical perspective, Open Question 1 is one of the best illustrations of the lack and necessity of new techniques for proving lower bounds in distributed computing. In this work, we present a novel lower bound technique, providing a separation between the Local and Congest(B) models for a problem for which previous techniques are provably incapable of doing so. 12

21 1.2.1 Prior Lower Bound Techniques and Their Limits To date, there are essentially two techniques for deriving lower bounds for distributed graph algorithms. The first is the indistinguishability technique of Linial [71], which is the main source for lower bounds in the Local model, where the message size is unrestricted. This technique argues that any r-round algorithm, regardless of message size, can be seen as a function that maps the r-hop neighborhood of a node to its output. Here, the topology of the graph is labeled by the unique O(log n)-bit node identifiers and any other input provided to the nodes; for randomized algorithms, we simply give each node an infinite string of unbiased random bits as part of the input. This technique has resulted in a large number of locality lower bounds, e.g. [24, 60, 70, 71, 78]. For these problems, it is a long-standing open question whether higher lower bounds can be found in the Congest(B) model, see e.g. [81]. Note that part of its appeal is that one can entirely forget about the algorithm: for instance, a 2-round coloring algorithm is just interpreted as a function assigning a color to each possible 2-neighborhood, and a correct algorithm must assign distinct colors to any pair of neighborhoods that may belong to adjacent nodes in any feasible input graph; more generally, this gives rise to the so-called r-neighborhood graph, and showing that r rounds are insufficient for coloring with c colors equates to showing that the chromatic number of the r-neighborhood graph is larger than c. Unfortunately, as this technique does not take bandwidth restrictions into account, it cannot show any separation between the Local and Congest(B) models. Triangle detection is possibly one of the most extreme examples for this, as it can be solved in a single round in Local but seems to require n Ω(1) rounds in Congest(log n). The second tool available for generating distributed lower bounds is the 2-party communication complexity framework that is discussed in Section 1.1. As discussed by Drucker et al., this technique is provably incapable of providing any lower bound for triangle detection. This is because no matter how we divide the nodes of the graph among the two players, one of them will know about the triangle. One may, in principle, hope for lower bounds based on multi-party communication complexity or information complexity, but to date no such result is known. With a clever usage of Rusza-Szemerdi graphs, Drucker et al. were also able to prove a strong n 1 o(1) lower bound for triangle detection [36], under the restriction that each node sends the same message to all of its neighbors in each round (in a broadcast fashion). More specifically, they show that a deterministic protocol in the Clique-Broadcast model (and therefore also Congest-Broadcast) requires Ω(n/e log n ) rounds, and that (essentially) the same lower bound holds for randomized protocols under the Strong Exponential Time Hypothesis, a popular conjecture about the time complexity of k-sat. Unfortunately, even under such conjectures, we do not know how to get any non-trivial lower bound in the standard Congest(B) model. Finally, it is worth pointing out a subtlety about the statement that 2-player communication complexity cannot provide any lower bound for triangle detection. This statement is fully accurate only under the assumption that nodes initially know the identifiers of their neighbors, as this renders it trivial to infer from the joint view of two neighbors whether they participate in a triangle. This assumption is known as KT 1, where KT i means Knowledge of Topology up to distance i (excluding edges with both endpoints in distance i), as was first defined in [13]. The 13

22 difference between KT 0, in which a node knows only its own identifier, and KT 1, in which a node knows also the identifiers of its neighbors, has been a focus of abundant studies, in particular concerning the message complexity of distributed algorithms (see, e.g., [13, 38, 54, 80, 84] and references therein). Note that acquiring knowledge on the neighbors identifiers requires no more than sending O(log n) bits over each edge, so the distinction between KT 0 and KT 1 is insubstantial for the round complexity in Congest(B) for B Ω(log n); KT 1 is therefore the default assumption throughout wide parts of the literature. However, in KT 0 a lower bound of Ω( log n B ) on the round complexity of triangle detection follows from a simple counting argument. As, ultimately, the goal is to show lower bounds of ω(log n), we consider KT 1 in this thesis Our Contribution In this thesis, we introduce fooling views, a technique for proving lower bounds for distributed algorithms with congestion. We are able to show the first non-trivial round complexity lower bounds on triangle detection in KT 1, separating the Local and Congest(B) models: 1. Triangle membership 3 in one round requires B c log n for a constant c > 0 (Section 5.1). 2. If B = 1, triangle detection requires Ω(log n) rounds, even if = 2, and even if the size of the network is constant and n is the size of the namespace (Section 5.2). We stress that we do not view our main contribution as the bounds themselves: while the bandwidth lower bound for single-round algorithms is tight, it hardly comes as a surprise that such algorithms need to communicate the entire neighborhood. Additionally, we do not believe that with 1-bit messages, extremely fast triangle detection is possible. Rather, we present a novel technique that enables to separate the two models, which is infeasible with prior lower bound techniques. We hope this to be a crucial step towards resolving the large gap between lower and upper bounds, which in contrast to other models is not justified by, e.g., conditional hardness results. The basic idea of fooling views is that they combine reasoning about locality with bandwidth restrictions. Framing this in terms of neighborhood graphs, this would mean to label neighborhoods by the information nodes have initially and the communication the algorithm performs over the edges incident to a node. However, this communication depends on the algorithm and the communication received in earlier rounds, enforcing more challenging inductive reasoning to prove multi-round lower bounds. To capture the intuition for our technique for B = 1, think about a node that receives the same messages from its neighbors regardless of whether it participates in a triangle or not as a fooled node. Intuitively, in a triangle {u, w, v} of a given network, if one of the nodes u, v and w is able to detect the triangle after t rounds of communication, then it may simply inform the other two nodes about the triangle during round number t + 1. Thus, it is crucial to maintain a perpetual state of confusion for all nodes involved in the triangle. However, if the task is to detect whether a specific triple of IDs is connected by a triangle or not, then the nodes can solve this by simply exchanging only one bit of communication. 3 In the triangle membership problem, every node must indicate whether it participates in a triangle. 14

23 Accordingly, our goal is to keep a large subset of the namespace fooled as long as possible. To this end, think of a triangle {u, v, w} for which none of u, v and w is able to detect the triangle as a fooled triangle. Our main idea is to show that if there are many fooled triangles after t rounds, then there are many triangles among them that are fooled after t + 1 rounds as well. In order to express this intuition, one of our ingredients in the proof is the following extremal combinatorics result by Paul Erdös [39]. One of our ingredients in proof for lower bound for triangle detection is the following extremal combinatorics result by Paul Erdös [39]. Theorem 1.6 ( [39], Theorem 1). Any k-uniform hypergraph of n nodes which contains at least n k l1 k edges, must contain a complete k-partite k-uniform hypergraph such that each part of it is of size l. Using this theorem of Erdös, we are able to show that if there are many fooled triangles after t rounds, then there is a set of nodes such that each triple in the set is a fooled triangle after t + 1 rounds. Blending counting and indistinguishability arguments with this theorem, we can derive our lower bound for multi-round algorithms. Our Ω(log n) bound serves as a proof of concept that our technique has the power to break through the bounds of previous techniques by demonstrating that this is indeed possible. Note that purely information-theoretic reasoning runs into the obstacle that in the KT 1 model, Θ(log n) bits have already crossed each edge before the algorithm starts. Accordingly, we argue that our approach represents a qualitative improvement over existing techniques. Proving lower bounds higher than log n requires new ideas, but we are hopeful that combining our technique with a more sophisticated analysis will lead to much higher lower bounds, both for triangle detection and for other non-global problems discussed above. Follow Up Work. In a follow-up work [40], after the appearance of our work online [3], the authors take our techniques a step further and show that our bandwidth lower bound applies also for randomized algorithms and also for triangle detection (though with a logarithmic factor decrease) and that our fooling views technique together with Theorem 1.6 can be exploited even to show a logarithmic lower bound for the 1-Bit setting. 15

24 16

25 Chapter 2 Additional Related work Diameter: It is known that a 3/2-approximation for the diameter can be computed in a sublinear number of rounds: Holzer and Wattenhofer [49] showed a O(n 3/4 + D)-round algorithm and Peleg et al. [86] obtained an incomparable O(D n log n) bound. These bounds were later improved by Lenzen and Peleg [67] to O( n log n + D), and finally Holzer et al. [47] reduce the bound to O( n log n + D). Minimum Vertex Cover: A classical problem in graph theory is finding a minimum vertex cover (MVC). In distributed computing, the time complexity of approximating MVC has been addressed in several cornerstone studies [11, 12, 17, 18, 43 45, 53, 58 60, 82, 88]. Observe that finding a minimum size vertex cover is equivalent to finding a maximum size independent set. However, these problems are not equivalent in an approximation-preserving way. Distributed approximation algorithms for maximum independent set were studied in [16,23,34,68]. Edge-crossings. The basic topology components for our lower bound in Section 5.2 are triangles and 6-cycles. The main hardness that we show for a node in deciding whether it participates in a triangle or not comes from not knowing the neighbors of its neighbor. That is, a node is unable to distinguish between two triangles and one 6-cycle, because only difference between these two cases is a single edge crossing, which are two node-disjoint edges for which we swap the endpoints from {w, x}, {w, x } to {w, x }, {w, x}. Edge crossings have previously aided the construction of lower bounds, such as lower bounds for message complexity of broadcast [13] or of symmetry breaking [80], as well as lower bounds for proof-labeling schemes [19]. The Congest(1) model. While we view our results for the Congest(1) model more as a proof of concept for our technique rather than as a bound that attempts to capture the true complexity, this model has been attracting interest by itself in previous work. It has been shown in [74] that the cornerstone O(log n)-round algorithms for maximal independent set [9, 72] can be made to work even with a bandwidth of B = 1, and this problem was studied also in, e.g., [15, 57]. Using the standard framework of reduction from 2-party communication complexity, a Ω( n) lower bound for the number of rounds required for 4-cycle detection can be directly deduced from [36]. In fact, all lower bounds obtained using this framework are with respect to 17

26 the bandwidth B, and therefore imply lower bounds also for the case of B = 1. Extremal Combinatorics. Extremal combinatorics serves as a powerful tool for proving lower bounds in many areas of theoretical computer science. In the context of distributed computing, Naor and Stockmeyer [79] used a Ramsey-type theorem similar to Theorem 1.6 to show that for any algorithm for solving an LCL 1 problem in the Local model that runs in a constant number of rounds, there is an algorithm that is order invariant for solving the same problem that runs in the same number of rounds. 1 Locally Checkable Labeling (LCL) problems are problems in which the legality of the output can be verified by looking at the output of the immediate neighborhood (e.g., coloring). 18

27 Chapter 3 Preliminaries 3.1 Computational Model The Congest(B) model [85]: In the Congest(B) model, the nodes of an undirected connected graph G = (V, E) of size V = n communicate over the graph edges in synchronous rounds. In each round, each node can send messages of O(B) bits to each of its neighbors. The complexity measure of a distributed algorithm in this model is the number of rounds the algorithm needs in order to complete. Each node is assumed to have a unique id in {1,..., n}. At the beginning of an execution of an algorithm, each node knows its own id and the ids of its neighbors. As our goal is to understand the complexity of fundamental graph problems in terms of communication rounds, each node is also assumed to be computationally unbounded. 3.2 Basic Definitions The distance between two nodes u, v in the graph, denoted d(u, v), is the minimum number of hops in a path between them in an unweighted graph. The eccentricity of a node u is the maximum distance between u and any other node in the network. The diameter D of the graph is the maximum eccentricity of the network, which also equals to the maximum distance between two nodes in it. The radius of the graph is the minimum eccentricity of a node in the network. A vertex cover of a graph is a set U V such that for each edge e E we have e U. A minimum vertex cover is a vertex cover of minimum cardinality. An independent set U V is a set of nodes for which u, v U = (u, v) / E. A maximum independent set is an independent set of maximum cardinality. A (proper) c-coloring of a graph is a function f : V {1,..., c} such that (u, v) E = f(u) f(v). The chromatic number χ of a graph is the minimum c such that a c-coloring of the graph exists. In this thesis we discuss six problems: computing an exact or approximate diameter, computing the exact radius, computing the size of a minimum vertex cover, computing the chromatic number of a graph, triangle membership, and triangle detection. the last two problems are defined as follows. 19

28 Definition [Triangle Membership]. In the triangle membership problem, each node needs to output a single bit indicating whether it is a part of a triangle. Definition [Triangle Detection]. In the triangle detection problem, each node needs to output a single bit. In case there is a triangle in the network, at least one node needs to output the value 1, and otherwise, all the nodes need to output the value Lower Bound Graphs Our lower bounds via reductions from the two-party communication complexity framework are formally defined as follows. Definition (Family of Lower Bound Graphs) Fix an integer K, { a function f : {0, 1} K {0, 1} K {TRUE, FALSE} and a graph predicate P. A family of graphs G x,y = (V, E x,y ) x, y {0, 1} K} with a partition V = V A V B is said to be a family of lower bound graphs for the Congest model w.r.t. f and P if the following properties hold: 1. Only the existence or the weight of edges in V A V A may depend on x; 2. Only the existence or the weight of edges in V B V B may depend on y; 3. G x,y satisfies the predicate P iff f(x, y) = TRUE. We use the following theorem, which is standard in the context of communication complexitybased lower bounds for the Congest model (see, e.g. [2, 36, 42, 48]). Its proof is by a standard simulation argument. Theorem 3.1. Fix a function f : {0, 1} K {0, 1} K {TRUE, FALSE} and a predicate P. If there is a family {G x,y } of lower bound graphs for the Congest model w.r.t f and P with C = E(V A, V B ) then any algorithm for deciding P in the Congest model requires Ω(CC(f, K)/ C log n) rounds, where CC(f, K) is the communication complexity of f on inputs of size K. Proof. Let ALG be a distributed algorithm in the Congest model that decides P in T rounds. Given inputs x, y {0, 1} K to Alice and Bob, respectively, Alice constructs the part of G x,y for the nodes in V A and Bob does so for the nodes in V B. This can be done by items 1 and 2 in Definition 3.3.1, and since V A and V B are disjoint. Alice and Bob simulate ALG by exchanging the messages that are sent during the algorithm between nodes of V A and nodes of V B in either direction, while the messages within each set of nodes are simulated locally by the corresponding player without any communication. Since item 3 in Definition also holds, we have that Alice and Bob correctly output f(x, y) based on the output of ALG. For each edge in the cut, Alice and Bob exchange O(log n) bits per round. Since there are T rounds and C edges in the cut, the number of bits exchanged in this protocol for computing f is O(T C log n). The lower bounds for T now follows directly from the lower bounds for CC(f, K). 20

29 In Section 4, for each decision problem addressed, we describe a fixed graph construction G = (V, E) with a partition V = V A V B, which we then generalize to a family of graphs { G x,y = (V, E x,y ) x, y {0, 1} K}. We then show that {G x,y } is a family lower bound graphs w.r.t. to some communication complexity problem f and the required predicate P. By Theorem 3.1 and the known lower bounds for the two-party communication problem f, we deduce a lower bound for any algorithm for deciding P in the Congest model. We use n for the number of nodes, K for the size of the input strings. 21

30 22

31 Chapter 4 Part I: Communication Complexity Reductions In this chapter we present our lower bounds via reductions from communication complexity. Section 4.1 contains the bit-gadget a small cut construction which is used multiple times in the rest of this section. Sections 4.2 and 4.3 contain our lower bounds for computing the exact or approximate diameter. Section 4.5 contains out near-quadratic lower bound for computing the size of a minimum vertex cover. 4.1 The Bit-Gadget Construction The main technical novelty in our lower bounds comes from the ability to encode large communication complexity problems in graphs with small cuts. To this end, we use the following construction (see Figure 4.1). Fix an integer k which is a power of 2, and start with two sets of nodes k nodes each, A = {a i i {0,..., k 1}} and B = {b i i {0,..., k 1}}. For each set S {A, B}, add two corresponding sets of log k nodes each, denoted F S = {fs h h {0..., log k 1}} and T S = {t h S h {0,..., log k 1}}. The latter are called the bit-nodes and they constitute the bit-gadget. Connect the nodes of each set S {A, B} to their corresponding bit-nodes according to their indices, as follows. Let s i be a node in a set S {A, B}, i.e., s {a, b} and i {0,..., k 1}, and let i h denote the h-th bit in the binary representation of i. For such s i, define bin(s i ) = { f h S i h = 0 } { t h S i h = 1 }, and connect s i by an edge to each of the nodes in bin(s i ). Finally, connect the bit-nodes: for each h {0,..., log k 1} connect f h A to th B and th A to f h B. Set V A = A F A T A and V B = V \ V A. In the next sections, we augment the above construction with fixed nodes and edges, and then add some more edges according to the input strings, in order to create a family of graphs with some desired properties. 4.2 Exact Diameter Our goal in this section is to prove the following theorem. 23

32 F A T A F B T B f 0 A t 0 A f 0 B t 0 B f 1 A t 1 A f 1 B t 1 B A a 0 a 1 a 2 a k 1 b 0 b 1 b 2 b k 1 B Figure 4.1: The bit-gadget construction F A T A F B T B f 0 A t 0 A f 0 B t 0 B A a 0 b k 1 B c A c A c B c B Figure 4.2: Diameter lower bound construction. 24

33 Theorem 4.1. Any ( algorithm ) for computing the exact diameter, even of a network of Θ(n log n) edges, requires Ω n rounds. log 2 n In order to prove Theorem 4.1, we describe a family of lower bound graphs with respect to the set-disjointness function and the predicate P that says that the graph has diameter at least 5. We start by describing the fixed graph construction and then define the family of lower bound graphs and analyze its relevant properties. The fixed graph construction: Start with the graph G and partition (V A, V B ) described in Section 4.1, and add two nodes c A, c A to V A, and another two nodes c B, c B to V B (see Figure 4.2). For each set S {A, B}, connect all nodes in S to the center c S, all the bit-nodes F S T S to c S, and the two centers c S, c S to one other. Finally, connect c A to c B. Adding edges corresponding to the strings x and y: Given two binary strings x, y {0, 1} k, augment the graph defined above with additional edges, which defines G x,y. For each i {0,..., k 1}, if x[i] = 0 then add an edge between the nodes a i and c A, and if y[i] = 0 then add an edge between b i and c B. To prove Lemma 4.2.3, we first point out several properties of the graph G x,y. Claim For every i, j {0,..., k 1}, if i j then d(a i, b j ) 3. Proof. Since i j, there is h {0,..., log k 1} such that i h j h. If i h = 1 and j h = 0, then the 3-path (a i, t h A, f h B, bj ) connects the desired nodes; otherwise, i h = 0 and j h = 1, and the 3-path (a i, f h A, th B, bj ) connects the nodes. Claim For every u, v such that (u, v) / (A B) (B A), it holds that d(u, v) 4. Proof. Observe that every node in V \ (A B) is connected to c A or to c B, and these two nodes are neighbors. Thus, the distance between every two nodes in V \ (A B) is at most 3. The claim follows from this, and from the fact that any node in A and any node in B are connected to a node in V \ (A B). The following lemma is the main ingredient in proving that {G x,y } is a family of lower bound graphs. Lemma The diameter of G x,y is at least 5 if and only if x and y are not disjoint. Proof. Assume that the sets are disjoint, i.e., for every i {0,..., k 1} either x[i] = 0 or y[i] = 0. We show that for every u, v V it holds that d(u, v) 4. Consider the following cases: 1. (u, v) / (A B) (B A): By Claim 4.2.2, d(u, v) u = a i A and v = b j B (or vice versa) for i j: Claim implies d(u, v) u = a i, v = b i (or vice versa) for some i: By the assumption, either x[i] = 0 or y[i] = 0, and assume the former without loss of generality, implying that a i is connected by an edge to c A. Thus, the path (a i, c A, c B, c B, b i ) exists in the graph, and d(a i, b i ) 4. 25

34 For the other direction, assume that the two sets are not disjoint, i.e., there is some i {0,..., k 1} for which x[i] = y[i] = 1. In this case, a i is not connected by an edge to c A and b i is not connected by an edge to c B. Note that V A, V B are disjoint, a i belongs to V A and b i to V B, so any path between a i and b i must go through an edge connecting a node from V A and a node from V B. Fix a shortest path from a i to b i, and consider the following cases, distinguished by the first edge in the path crossing from V A to V B : 1. The path uses the edge ( c A, c B ): Since a i is not connected by an edge to c A, and b i is not connected to c B, we have d(a i, c A ) 2 and d(b i, c B ) 2, so the length of the path is at least The path uses an edge (fa h, th B ) with f A h / bin(ai ), or an edge (t h A, f B h) with th A / bin(ai ): For the first case, note that a i and t h A are not connected by an edge, and they do not even have a common neighbor. Thus, d(a i, t h A ) 3, and d(ai, b i ) 5. The case of (t h A, f B h) with t h A / bin(ai ) is analogous. 3. The path uses an edge (fa h, th B ) with f A h bin(ai ), or an edge (t h A, f B h) with th A bin(ai ): The definitions of bin(a i ) and bin(b i ) immediately imply t h B / bin(bi ) for the first case, or fb h / bin(bi ) for the second. The rest of the argument is the same as the previous: d(t h B, bi ) 3 or d(fb h, bi ) 3, both implying d(a i, b i ) 5. Thus, any path between a i and b i must have length at least 5. Having constructed a family of lower bound graphs, we are now ready to prove Theorem 4.1. Proof. Theorem 4.1 To complete the proof of Theorem 4.1, note that n Θ(k), and thus K = x = y = Θ(n). Furthermore, the only edges in the cut E(V A, V B ) are the edges between nodes in F A T A and nodes in F B T B, and the edge ( c A, c B ). Thus, in total, there are Θ(log n) edges in the cut E(V A, V B ). Since Lemma shows that {G x,y } is a family of lower bound graphs, we can apply Theorem 3.1 and deduce that any algorithm in the Congest model for deciding whether a given graph has a diameter at least 5 requires at least Ω(k/ log n) = Ω(n/ log n) rounds. Finally, observe that the number of edges in the construction is O(n log n). 4.3 (3/2 ε)-approximation of the Diameter In this section we show how to modify our sparse construction presented in the previous section in order to achieve a near-linear lower bound even for computing a (3/2 ε)-approximation of the diameter. Theorem 4.2. For all constant 0 < ε < 1/2, any algorithm for computing ( a (3/2 ) ε)- approximation to the diameter, even of a network of Θ(n log n) edges, requires Ω n rounds. log 3 n As in the proof of Theorem 4.1, we show that there is a family of lower bound graphs with respect to the set-disjointness function and the predicate P that says that the graph has a diameter of length at least D, where D is an integer that may depend on n. Note that, unlike the case of proving a lower bound for computing the exact diameter, here we need to construct a 26