Sparsifying Distributed Algorithms with Ramifications in Massively Parallel Computation and Centralized Local Computation

Ghaffari, Mohsen; Uitto, Jara

doi:10.1137/1.9781611975482.99

Cited by 71 publications

(105 citation statements)

References 30 publications

(32 reference statements)

Supporting

Mentioning

104

Contrasting

Order By: Relevance

“…2 Corollary 1.2 exponentially improves over this bound. 2 We comment that although it is unclaimed, a recent algorithm of Ghaffari and Uitto [21] can also be simulated in the congested clique model leading to an O( √ log ∆) round algorithm. Corollary 1.3.…”

Section: Resultsmentioning

confidence: 99%

Exponentially Faster Massively Parallel Maximal Matching

Behnezhad

Hajiaghayi

Harris

2019

2019 IEEE 60th Annual Symposium on Foundations of Computer Science (FOCS)

View full text Add to dashboard Cite

The study of approximate matching in the Massively Parallel Computations (MPC) model has recently seen a burst of breakthroughs. Despite this progress, however, we still have a far more limited understanding of maximal matching which is one of the central problems of parallel and distributed computing. All known MPC algorithms for maximal matching either take polylogarithmic time which is considered inefficient, or require a strictly super-linear space of n 1+Ω(1) per machine.In this work, we close this gap by providing a novel analysis of an extremely simple algorithm a variant of which was conjectured to work by Czumaj et al. [STOC'18]. The algorithm edge-samples the graph, randomly partitions the vertices, and finds a random greedy maximal matching within each partition. We show that this algorithm drastically reduces the vertex degrees. This, among some other results, leads to an O(log log ∆) round algorithm for maximal matching with O(n) space (or even mildly sublinear in n using standard techniques).As an immediate corollary, we get a 2 approximate minimum vertex cover in essentially the same rounds and space. This is the best possible approximation factor under standard assumptions, culminating a long line of research. It also leads to an improved O(log log ∆) round algorithm for 1 + ε approximate matching. All these results can also be implemented in the congested clique model within the same number of rounds. * A preliminary version of this paper is

show abstract

Section: Resultsmentioning

confidence: 99%

Exponentially Faster Massively Parallel Maximal Matching

Behnezhad

Hajiaghayi

Harris

2019

2019 IEEE 60th Annual Symposium on Foundations of Computer Science (FOCS)

View full text Add to dashboard Cite

show abstract

“…In addition to the LCA results we pointed to above, close to our work are [RTVX11, ARVX12, LRY17, Gha16, GU19] who also study the worst-case oracle behavior. In particular, [GU19] showed that there exists an oracle that given an arbitrary chosen vertex v outputs whether v is in some fixed maximal independent set or not by performing d O(log log d) · poly log n queries. When this oracle is applied to the line graph, then it reports whether a given edge is in a fixed maximal matching or not.…”

Section: Related Workmentioning

confidence: 99%

“…Recently, [GU19] showed that there exists an oracle that given an arbitrary chosen vertex v outputs whether v is in some fixed maximal independent set or not by performing d O(log log d) · poly log n queries, which improves on the prior work obtaining d O(poly log d) · poly log n complexity [RTVX11, ARVX12, LRY17,Gha16]. When this oracle is applied to the line graph, then it reports whether a given edge is in a fixed maximal matching or not.…”

Section: Related Workmentioning

confidence: 99%

Space Efficient Approximation to Maximum Matching Size from Uniform Edge Samples

Kapralov¹,

Mitrović²,

Norouzi-Fard³

et al. 2020

Proceedings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms

View full text Add to dashboard Cite

Given a source of iid samples of edges of an input graph G with n vertices and m edges, how many samples does one need to compute a constant factor approximation to the maximum matching size in G? Moreover, is it possible to obtain such an estimate in a small amount of space? We show that, on the one hand, this problem cannot be solved using a nontrivially sublinear (in m) number of samples: m 1−o(1) samples are needed. On the other hand, a surprisingly space efficient algorithm for processing the samples exists: O(log 2 n) bits of space suffice to compute an estimate.Our main technical tool is a new peeling type algorithm for matching that we simulate using a recursive sampling process that crucially ensures that local neighborhood information from 'dense' regions of the graph is provided at appropriately higher sampling rates. We show that a delicate balance between exploration depth and sampling rate allows our simulation to not lose precision over a logarithmic number of levels of recursion and achieve a constant factor approximation. The previous best result on matching size estimation from random samples was a log O(1) n approximation [Kapralov et al'14], which completely avoided such delicate trade-offs due to the approximation factor being much larger than exploration depth.Our algorithm also yields a constant factor approximate local computation algorithm (LCA) for matching with O(d log n) exploration starting from any vertex. Previous approaches were based on local simulations of randomized greedy, which take O(d) time in expectation over the starting vertex or edge (Yoshida et al'09, Onak et al'12), and could not achieve a better than d 2 runtime. Interestingly, we also show that unlike our algorithm, the local simulation of randomized greedy that is the basis of the most efficient prior results does take Ω(d 2 )O(d log n) time for a worst case edge even for d = exp(Θ( √ log n)).Remark 4. Note that here L(w) is a random variable independently sampled from the distribution of L(w), similarly to L a in Eq. (11).Remark 5. Here U (E) denotes the uniform distribution over E. Also we denote by v ∈ e the fact that e is adjacent to v, where v is a vertex and e is an edge. In this case we denote the other endpoint of e by e\v. We use this notation heavily throughout the analysis. ones where q is not in the middle, will be very simple.Case 2: r ≤ p ≤ q. Then,On the other hand, if r = ,by Fact 3 since ≤ 1/2.Case 5: p ≤ q ≤ r. We consider two subcases.(a.) p ≤ 4 . Then q cannot be greater than 8 . Indeed this would mean by Fact 4 thatwhich is a contradiction. Similarly, r cannot be greater than 16 . Indeed this would mean by Fact 4 that D KL (q r) > D KL (8 16 ) ≥ 2 , which is also a contradiction. Ultaminately, r ≤ 16 , so D KL (p r) ≤ D KL (0 16 ) ≤ 32by Fact 3 since 16 ≤ 1/2.

show abstract

“…In a follow-up work, [BBD + 19] devise MIS and matching algorithms in uniformly sparse graphs in O(log 2 log n) rounds. In independent concurrent works, Ghaffari and Uitto [GU19] and Onak [Ona18] provide algorithms for the problems of maximal independent set and matching in general graphs in O( √ log n) rounds. In [CFG + 18], Chang et al develop an O( √ log log n)round low-memory MPC algorithm for (∆ + 1)-list coloring.…”

Section: Low-memory Mpc Model For Graph Problemsmentioning

confidence: 99%

Breaking the Linear-Memory Barrier in $$\mathsf {MPC}$$: Fast $$\mathsf {MIS}$$ on Trees with Strongly Sublinear Memory

Brandt

Fischer

Uitto

2019

Structural Information and Communication Complexity

Self Cite

View full text Add to dashboard Cite

Recently, studying fundamental graph problems in the Massively Parallel Computation (MPC) framework, inspired by the MapReduce paradigm, has gained a lot of attention. An assumption common to a vast majority of approaches is to allow Ω(n) memory per machine, where n is the number of nodes in the graph and Ω hides polylogarithmic factors. However, as pointed out by Karloff et al. [SODA'10] and Czumaj et al. [STOC'18], it might be unrealistic for a single machine to have linear or only slightly sublinear memory.In this paper, we thus study a more practical variant of the MPC model which only requires substantially sublinear or even subpolynomial memory per machine. In contrast to the linear-memory MPC model and also to streaming algorithms, in this low-memory MPC setting, a single machine will only see a small number of nodes in the graph. We introduce a new and strikingly simple technique to cope with this imposed locality.In particular, we show that the Maximal Independent Set (MIS) problem can be solved efficiently, that is, in O(log 3 log n) rounds, when the input graph is a tree. This constitutes an almost exponential speed-up over the low-memory MPC algorithm in O( √ log n)-algorithm in a concurrent work by Ghaffari and Uitto [SODA'19] and substantially reduces the local memory from Ω(n) required by the recent O(log log n)-round MIS algorithm of Ghaffari et al. [PODC'18] to n ε for any ε > 0, without incurring a significant loss in the round complexity. Moreover, it demonstrates how to make use of the all-to-all communication in the MPC model to almost exponentially improve on the corresponding bound in the LOCAL and PRAM models by Lenzen and Wattenhofer [PODC'11].

show abstract

Sparsifying Distributed Algorithms with Ramifications in Massively Parallel Computation and Centralized Local Computation

Cited by 71 publications

References 30 publications

Exponentially Faster Massively Parallel Maximal Matching

Exponentially Faster Massively Parallel Maximal Matching

Space Efficient Approximation to Maximum Matching Size from Uniform Edge Samples

Breaking the Linear-Memory Barrier in $$\mathsf {MPC}$$: Fast $$\mathsf {MIS}$$ on Trees with Strongly Sublinear Memory

Contact Info

Product

Resources

About