• Corpus ID: 240354833

Coloring Trees in Massively Parallel Computation

@inproceedings{Latypov2021ColoringTI,
  title={Coloring Trees in Massively Parallel Computation},
  author={Rustam Latypov and Jara Uitto},
  year={2021}
}
We present O(log log n) time 3-coloring, maximal independent set and maximal matching algorithms for trees in the Massively Parallel Computation (MPC) model. Our algorithms are deterministic, apply to arbitrary-degree trees and work in the low-space MPC model, where local memory is O(nδ) for δ ∈ (0, 1) and global memory is O(m). Our main result is the 3-coloring algorithm, which contrasts the randomized, state-of-the-art 4-coloring algorithm of Ghaffari, Grunau and Jin [DISC’20]. The maximal… 
1 Citations

Figures from this paper

Brief Announcement: Memory Efficient Massively Parallel Algorithms for LCL Problems on Trees

TLDR
This work presents a general method that solves most locally checkable labeling (LCL) problems exponentially faster in the low-space MPC model than in the LOCAL message passing model and shows that all solvable LCL problems on trees can be solved in O(log n) time.

References

SHOWING 1-10 OF 25 REFERENCES

Improved MPC Algorithms for MIS, Matching, and Coloring on Trees and Beyond

We present $O(\log\log n)$ round scalable Massively Parallel Computation algorithms for maximal independent set and maximal matching, in trees and more generally graphs of bounded arboricity, as well

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

We introduce a method for sparsifying distributed algorithms and exhibit how it leads to improvements that go past known barriers in two algorithmic settings of large-scale graph processing:

Massively Parallel Computation of Matching and MIS in Sparse Graphs

TLDR
This work considers maximal matching and maximal independent set problems in the MPC model, and a degree reduction technique is used that reduces these problems in graphs with arboricity λ to the corresponding problems inGraphs with maximum degree poly(λ, log n) in O(log2log n) rounds, giving rise to O(√ log λ ⋅ loglog λ + log 2 log n)-round algorithms.

A Time Hierarchy Theorem for the LOCAL Model

  • Yi-Jun ChangSeth Pettie
  • Computer Science, Mathematics
    2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS)
  • 2017
TLDR
It is proved that any randomized algorithm that solves an LCL problem in sublogarithmic time can be sped up to run in O(T_{LLL}) time, which is the complexity of the distributed Lovasz local lemma problem, currently known to be Ω( log log n) and 2^{O(sqrt{log log n})} on bounded degree graphs.

Round compression for parallel matching algorithms

TLDR
The above O(logn) round complexity bound is broken even in the case of slightly sublinear memory per machine, and the improvement here is almost exponential: the best MPC round complexity matches what one can already get in the PRAM model, without the need to take advantage of the extra local computation power.

Conditional Hardness Results for Massively Parallel Computation from Distributed Lower Bounds

We present the first conditional hardness results for massively parallel algorithms for some central graph problems including (approximating) maximum matching, vertex cover, maximal independent set,

Distributive graph algorithms Global solutions from local data

  • N. Linial
  • Computer Science, Mathematics
    28th Annual Symposium on Foundations of Computer Science (sfcs 1987)
  • 1987
TLDR
A maximal independent set in an n-cycle cannot be found faster than Ω(log* n) and this is optimal by [CV]; the d-regular tree of radius r cannot be colored with fewer than √d colors in time 2r / 3.

Parallel Tree Contraction Part 1: Fundamentals

TLDR
This paper introduces parallel tree contraction: a new bottom-up technique for constructing parallel algorithms on trees that only require O(1ogn) time and O(n/logn) processors on a Q-sided randomized PRAM or O( n) processor on a deterministic PRAM.

Minimum-Weight Spanning Tree Construction in O(log log n) Communication Rounds

TLDR
A distributed algorithm is presented which constructs a minimum-weight spanning tree in O(log log n) communication rounds, where in each round any process can send a message to every other process.

Skew in parallel query processing

TLDR
A tight connection is established between the fractional edge packing of the query and the amount of communication in two cases, where the data is skewed and the heavy hitters and their frequencies are known.