Congested Clique Research Articles

Exponentially Faster Shortest Paths in the Congested Clique

We present improved deterministic algorithms for approximating shortest paths in the Congested Clique model of distributed computing. We obtain poly(log log n )-round algorithms for the following problems in unweighted undirected n -vertex graphs: ( 1 + ϵ )-approximation of multi-source shortest paths (MSSP) from O (√ n ) sources. (2 + ϵ )-approximation of all pairs shortest paths (APSP). (1 + ϵ , β)-approximation of APSP where β = O (log log n / ϵ ) log log n . These bounds improve exponentially over the state-of-the-art poly-logarithmic bounds due to [Censor-Hillel et al., PODC19]. It also provides the first nearly-additive bounds for the APSP problem in sub-polynomial time. Our approach is based on distinguishing between short and long distances based on some distance threshold t = O ( β / ϵ ) where β = O (log log n / ϵ ) log log n . Handling the long distances is done by devising a new algorithm for computing a sparse (1 + ϵ , β ) emulator with O ( n log log n ) edges. For the short distances, we provide distance-sensitive variants for the distance tool-kit of [Censor-Hillel et al., PODC19]. By exploiting the fact that this tool-kit should be applied only on local balls of radius t , their round complexities get improved from poly (log n ) to poly (log t ). Finally, our deterministic solutions for these problems are based on a derandomization scheme of a novel variant of the hitting set problem, which might be of independent interest.

Proof-labeling schemes: Broadcast, unicast and in between

We study the effect of limiting the number of different messages a node can transmit simultaneously on the verification complexity of proof-labeling schemes (PLS). In a PLS, each node is given a label, and the goal is to verify, by exchanging messages over each link in each direction, that a certain global predicate is satisfied by the system configuration. We consider a single parameter r that bounds the number of distinct messages that can be sent concurrently by any node: in the case r=1, each node may only send the same message to all its neighbors (the broadcast model), in the case r≥Δ, where Δ is the largest node degree in the system, each neighbor may be sent a distinct message (the unicast model), and in general, for 1≤r≤Δ, each of the r messages is destined to a subset of the neighbors.We show that message compression linear in r is possible for verifying fundamental problems such as the agreement between edge endpoints on the edge state. Some problems, including verification of maximal matching, exhibit a large gap in complexity between r=1 and r>1. For some other important predicates, the verification complexity is insensitive to r, e.g., the question whether a subset of edges constitutes a spanning-tree. We also consider the congested clique model. We show that the crossing technique [1] for proving lower bounds on the verification complexity can be applied in the case of congested clique only if r=1. Together with a new upper bound, this allows us to determine the verification complexity of MST in the broadcast clique. Finally, we establish a general connection between the deterministic and randomized verification complexity for any given number r.

A distributed algorithm for directed minimum-weight spanning tree

In the directed minimum spanning tree problem (DMST, also called minimum weight arborescence), we are given a directed weighted graph, and a root node r. Our goal is to construct a minimum-weight directed spanning tree, rooted at r and oriented outwards. We present the first sub-quadratic DMST algorithm in the distributed \({\mathsf {CONGEST}}\) network model, where the messages exchanged between the network nodes are bounded in size. We consider three versions of the model: a network where the communication links are bidirectional but can have different weights in the two directions; a network where communication is unidirectional; and the Congested Clique model, where all nodes can communicate directly with each other. Our DMST algorithm is based on a variant of Lovász’ DMST algorithm for the PRAM model, and uses a distributed single-source shortest-path (SSSP) algorithm for directed graphs as a black box. In the bidirectional \({\mathsf {CONGEST}}\) model, our algorithm has roughly the same running time as the SSSP algorithm that is used as a black box; using the state-of-the-art SSSP algorithm due to Chechik and Mukhtar (in: Symposium on principles of distributed computing (PODC), ACM, 2020, pp 464–473), we obtain a running time of \({\widetilde{O}}(\sqrt{n}D^{1/4}+D))\) rounds for the bidirectional communication case. For the unidirectional communication model we give an \({\widetilde{O}}(n)\) algorithm, and show that it is nearly optimal. And finally, for the Congested Clique, our algorithm again matches the best known SSSP algorithm: it runs in \({\widetilde{O}}(n^{1/3})\) rounds. On the negative side, we adapt an observation of Chechik in the sequential setting to show that in all three models, the DMST problem is at least as hard as the (s, t)-shortest path problem. Thus, in terms of round complexity, distributed DMST lies between single-source shortest path and (s, t)-shortest path.

Graph Sparsification for Derandomizing Massively Parallel Computation with Low Space

The Massively Parallel Computation (MPC) model is an emerging model that distills core aspects of distributed and parallel computation, developed as a tool to solve combinatorial (typically graph) problems in systems of many machines with limited space. Recent work has focused on the regime in which machines have sublinear (in n , the number of nodes in the input graph) space, with randomized algorithms presented for the fundamental problems of Maximal Matching and Maximal Independent Set. However, there have been no prior corresponding deterministic algorithms. A major challenge underlying the sublinear space setting is that the local space of each machine might be too small to store all edges incident to a single node. This poses a considerable obstacle compared to classical models in which each node is assumed to know and have easy access to its incident edges. To overcome this barrier, we introduce a new graph sparsification technique that deterministically computes a low-degree subgraph, with the additional property that solving the problem on this subgraph provides significant progress towards solving the problem for the original input graph. Using this framework to derandomize the well-known algorithm of Luby [SICOMP’86], we obtain O (log Δ + log log n )-round deterministic MPC algorithms for solving the problems of Maximal Matching and Maximal Independent Set with O ( n ɛ ) space on each machine for any constant ɛ > 0. These algorithms also run in O (log Δ) rounds in the closely related model of CONGESTED CLIQUE, improving upon the state-of-the-art bound of O (log 2 Δ) rounds by Censor-Hillel et al. [DISC’17].

Simple, Deterministic, Constant-Round Coloring in Congested Clique and MPC

We settle the complexity of the $(\Delta+1)$-coloring and $(\Delta+1)$-list coloring problems in the \sf CONGESTED CLIQUE model by presenting a simple deterministic algorithm for both problems runn...

The role of randomness in the broadcast congested clique model

We study the role of randomness in the broadcast congested clique model. This is a message-passing model of distributed computation where the nodes of a network know their local neighborhoods and they broadcast, in synchronous rounds, messages that are visible to every other node.This works aims to separate three different settings: deterministic protocols, randomized protocols with private coins, and randomized protocols with public coins. We obtain the following results:•If more than one round is allowed, public randomness is as powerful as private randomness.•One-round public-coin algorithms can be exponentially more powerful than deterministic algorithms running in several rounds.•One-round public-coin algorithms can be exponentially more powerful than one-round private-coin algorithms.•One-round private-coin algorithms can be exponentially more powerful than one-round deterministic algorithms.

Distributed Approximation Algorithms for Steiner Tree in the CONGESTED CLIQUE

The Steiner tree problem is one of the fundamental and classical problems in combinatorial optimization. In this paper we study this problem in the CONGESTED CLIQUE model (CCM) [29] of distributed computing. For the Steiner tree problem in the CCM, we consider that each vertex of the input graph is uniquely mapped to a processor and edges are naturally mapped to the links between the corresponding processors. Regarding output, each processor should know whether the vertex assigned to it is in the solution or not and which of its incident edges are in the solution. We present two deterministic distributed approximation algorithms for the Steiner tree problem in the CCM. The first algorithm computes a Steiner tree using [Formula: see text] rounds and [Formula: see text] messages for a given connected undirected weighted graph of [Formula: see text] nodes. Note here that [Formula: see text] notation hides polylogarithmic factors in [Formula: see text]. The second one computes a Steiner tree using [Formula: see text] rounds and [Formula: see text] messages, where [Formula: see text] and [Formula: see text] are the shortest path diameter and number of edges respectively in the given input graph. Both the algorithms achieve an approximation ratio of [Formula: see text], where [Formula: see text] is the number of leaf nodes in the optimal Steiner tree. For graphs with [Formula: see text], the first algorithm exhibits better performance than the second one in terms of the round complexity. On the other hand, for graphs with [Formula: see text], the second algorithm outperforms the first one in terms of the round complexity. In fact when [Formula: see text] then the second algorithm achieves a round complexity of [Formula: see text] and message complexity of [Formula: see text]. To the best of our knowledge, this is the first work to study the Steiner tree problem in the CCM.

Fast approximate shortest paths in the congested clique

We design fast deterministic algorithms for distance computation in the Congested Clique model. Our key contributions include:A (2+epsilon )-approximation for all-pairs shortest paths in O(log ^2{n} / epsilon ) rounds on unweighted undirected graphs. With a small additional additive factor, this also applies for weighted graphs. This is the first sub-polynomial constant-factor approximation for APSP in this model.A (1+epsilon )-approximation for multi-source shortest paths from O(sqrt{n}) sources in O(log ^2{n} / epsilon ) rounds on weighted undirected graphs. This is the first sub-polynomial algorithm obtaining this approximation for a set of sources of polynomial size. Our main techniques are new distance tools that are obtained via improved algorithms for sparse matrix multiplication, which we leverage to construct efficient hopsets and shortest paths. Furthermore, our techniques extend to additional distance problems for which we improve upon the state-of-the-art, including diameter approximation, and an exact single-source shortest paths algorithm for weighted undirected graphs in tilde{O}(n^{1/6}) rounds.

Graph reconstruction in the congested clique

In this paper we study the reconstruction problem in the congested clique model. Given a class of graphs G, the problem is defined as follows: if G∉G, then every node must reject; if G∈G, then every node must end up knowing all the edges of G. The cost of an algorithm is the total number of bits received by any node through one link. It is not difficult to see that the cost of any algorithm that solves this problem is Ω(log⁡|Gn|/n), where Gn is the subclass of all n-node labeled graphs in G. We prove that the lower bound is tight and that it is possible to achieve it with only 2 rounds.

Derandomizing local distributed algorithms under bandwidth restrictions

This paper addresses the cornerstone family of local problems in distributed computing, and investigates the curious gap between randomized and deterministic solutions under bandwidth restrictions. Our main contribution is in providing tools for derandomizing solutions to local problems, when the n nodes can only send $$O(\log n)$$-bit messages in each round of communication. Our framework mostly follows by the derandomization approach of Luby (J Comput Syst Sci 47(2):250–286, 1993) combined with the power of all to all communication. Our key results are as follows: first, we show that in the congested clique model, which allows all-to-all communication, there is a deterministic maximal independent set algorithm that runs in $$O(\log ^2 {\varDelta })$$ rounds, where $${\varDelta }$$ is the maximum degree. When $${\varDelta }=O(n^{1/3})$$, the bound improves to $$O(\log {\varDelta })$$. In addition, we deterministically construct a $$(2k-1)$$-spanner with $$O(kn^{1+1/k}\log n)$$ edges in $$O(k \log n)$$ rounds in the congested clique model.

The Impact of Locality in the Broadcast Congested Clique Model

The broadcast congested clique model (BClique) is a message-passing model of distributed computation where $n$ nodes communicate with each other in synchronous rounds. First, in this paper we prove...

PODC 2019 Review

The 38th ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing (PODC 2019) was held on July 29-August 2, 2019 at the Double Tree Hilton hotel in Toronto, Canada. With three keynotes, over 40 accepted papers, over 20 accepted brief announcements, two workshops, and roughly 150 attendants, PODC 2019 constituted a composition of fascinating improvements in many areas of distributed and parallel computing. On the evening of the 31st of July, the conference banquet was held on a cruise over beautiful Lake Ontario and included the best papers award ceremony. The best paper award went to Yi-Jun Chang, and Thatchaphol Saranurak for their work titled, \Improved Distributed Expander Decomposition and Nearly Optimal Triangle Enumeration" [19]; two best student paper awards were given to Yi-Jun Chang, Manuela Fischer, and Yufan Zheng for their work titled, \The Complexity of (Δ + 1) Coloring in Congested Clique, Massively Parallel Computation, and Centralized Local Computation" [17] which was co-authored with Mohsen Gha ari, and Jara Uitto, and to Michal Dory and Dean Leitersdorf for the work on \Fast Approximate Shortest Paths in the Congested Clique" [16] which was co-authored with Keren Censor-Hillel, and Janne H. Korhonen. Congratulations to all the awardees and a special congratulations to Yi-Jun Chang for having received both awards! This review would be incomplete without mentioning perhaps one of the most notable results in the eld in recent years which was uploaded to the online archive just days before the conference gathered, and which was not presented at PODC 2019 but a ected many works presented at the conference: the work titled, ¶olylogarithmic-Time Deterministic Network Decomposition and Distributed Derandomization" [48] by Vaclav Rozhon, and Mohsen Gha ari. Throughout the entire conference there was talk regarding the implications of this work, culminating with perhaps one of the more memorable moments of PODC 2019, where Mohsen described this result during his talk on a di erent paper which he co-authored with Fabian Kuhn - Mohsen quoted from his and Kuhn's paper [31]: \we provide results that are in some sense the strongest that one can achieve, barring a major breakthrough", and on the next slide was that major breakthrough - a picture of Vaclav Rozhon along with the rst page of [48]. Congratulations to the authors on this work! We hope that this review will give readers the opportunity to experience some of PODC 2019 and potentially attend the conference in future years. Thank you to the organizers and authors for a captivating and though-provoking conference!

Distributed PageRank Computation: An Improved Theoretical Study

PageRank is a classic measure that effectively evaluates the node importance in large graphs, and has been applied in numerous applications ranging from data mining, Web algorithms, recommendation systems, load balancing, search, and identifying connectivity structures. Computing PageRank for large graphs is challenging and this has motivated the studies of distributed algorithms to compute PageRank. Previously, little works have been spent on the distributed PageRank algorithms with provably desired complexity and accuracy. Given a graph with n nodes and if we model the distributed computation model as the well-known congested clique model, the state-of-the-art algorithm takes O(√logn) communication rounds to approximate the PageRank value of each node in G, with a probability at least 1−1/n. In this paper, we present improved distributed algorithms for computing PageRank. Particularly, our algorithm performs O(log log√n) rounds (a significant improvement compared with O(√logn) rounds) to approximate the PageRank values with a probability at least 1−1/n. Moreover, under a reasonable assumption, our algorithm also reduces the edge bandwidth (i.e., the maximum communication message size that can be exchanged through an edge during a communication round) by a O(logn) factor compared with the state-of-the-art algorithm. Finally, we show that our algorithm can be adapted to efficiently compute another variant of PageRank, i.e., the batch one-hop Personalized PageRanks, in O(log logn) communication rounds.

Algebraic methods in the congested clique

In this work, we use algebraic methods for studying distance computation and subgraph detection tasks in the congested clique model. Specifically, we adapt parallel matrix multiplication implementations to the congested clique, obtaining an $O(n^{1-2/\omega})$ round matrix multiplication algorithm, where $\omega < 2.3728639$ is the exponent of matrix multiplication. In conjunction with known techniques from centralised algorithmics, this gives significant improvements over previous best upper bounds in the congested clique model. The highlight results include: -- triangle and 4-cycle counting in $O(n^{0.158})$ rounds, improving upon the $O(n^{1/3})$ triangle detection algorithm of Dolev et al. [DISC 2012], -- a $(1 + o(1))$-approximation of all-pairs shortest paths in $O(n^{0.158})$ rounds, improving upon the $\tilde{O} (n^{1/2})$-round $(2 + o(1))$-approximation algorithm of Nanongkai [STOC 2014], and -- computing the girth in $O(n^{0.158})$ rounds, which is the first non-trivial solution in this model. In addition, we present a novel constant-round combinatorial algorithm for detecting 4-cycles.

Robust reconstruction of Barabási‐Albert networks in the broadcast congested clique model

In the broadcast version of the congested clique model, nodes communicate in synchronous rounds by writing ‐bit messages on a whiteboard, which is visible to all of them. The joint input to the nodes is an undirected ‐node graph , with node receiving the list of its neighbors in . Our goal is to design a protocol at the end of which the information contained in the whiteboard is enough for reconstructing . It has already been shown that there is a one‐round protocol for reconstructing graphs with bounded degeneracy. The main drawback of that protocol is that the degeneracy of the input graph must be known a priori by the nodes. Moreover, the protocol fails when applied to graphs with degeneracy larger than . In this article, we address this issue by looking for robust reconstruction protocols, that is, protocols which always give the correct answer and work efficiently when the input is restricted to a certain class. We introduce a very simple, two‐round protocol that we call Robust‐Reconstruction. We prove that this protocol is robust for reconstructing the class of Barabási‐Albert trees with (expected) message size . Moreover, we present computational evidence suggesting that Robust‐Reconstruction also generates logarithmic size messages for arbitrary Barabási‐Albert networks. Finally, we stress the importance of the preferential attachment mechanism (used in the construction of Barabási‐Albert networks) by proving that Robust‐Reconstruction does not generate short messages for random recursive trees. © 2015 Wiley Periodicals, Inc. NETWORKS, Vol. 67(1), 82–91 2016

Lessons from the Congested Clique applied to MapReduce

The main result of this paper is a simulation algorithm which, under quite general constraints, transforms algorithms running in the Congested Clique model into algorithms running in the MapReduce model. As a case study of applying this simulation algorithm, we first present a distributed O(Δ)-coloring algorithm running on the Congested Clique in O(1) rounds, if Δ≥log2⁡n, and O(log⁡log⁡log⁡n) rounds otherwise. Applying the simulation theorem to this Congested Clique O(Δ)-coloring algorithm yields an O(1)-round O(Δ)-coloring algorithm in the MapReduce model. We apply our simulation algorithm to other Congested Clique algorithms including the 2-ruling set and metric facility location algorithms of Berns et al. (ICALP 2012).Our simulation algorithm illustrates a natural correspondence between per-node bandwidth in the Congested Clique model and memory per machine in the MapReduce model. In the Congested Clique (and more generally, any network in the CONGEST model), the major impediment to constructing fast algorithms is the O(log⁡n) restriction on message sizes. Similarly, in the MapReduce model, the combined restrictions on memory per machine and total system memory have a dominant effect on algorithm design. In showing a fairly general simulation algorithm, we highlight the similarities and differences between these models.