# Lower bounds for maximal matchings and maximal independent sets

2019 IEEE 60TH ANNUAL SYMPOSIUM ON FOUNDATIONS OF COMPUTER SCIENCE (FOCS 2019), pp. 481.0-497, 2019.

EI

Weibo:

Abstract:

There are distributed graph algorithms for finding maximal matchings and maximal independent sets in O(Delta + log* n) communication rounds; here n is the number of nodes and Delta is the maximum degree. The lower bound by Linial (1987, 1992) shows that the dependency on n is optimal: these problems cannot be solved in o(log* n) rounds ev...More

Code:

Data:

Introduction

- There are four classic problems that have been studied extensively in distributed graph algorithms since the very beginning of the field in the 1980s [17]: maximal independent set (MIS), maximal matching (MM), vertex coloring with ∆ + 1 colors, and edge coloring with 2∆ − 1 colors; here ∆ is the maximum degree of the graph.
- It turns out there is a matching lower bound: no algorithm solves this problem in o(∆) rounds in the same model [21].
- Bipartite maximal matching can be solved in O(∆) rounds in ∆-regular two-colored graphs, and the running time is independent of the number of nodes.

Highlights

- There are four classic problems that have been studied extensively in distributed graph algorithms since the very beginning of the field in the 1980s [17]: maximal independent set (MIS), maximal matching (MM), vertex coloring with ∆ + 1 colors, and edge coloring with 2∆ − 1 colors; here ∆ is the maximum degree of the graph
- We summarize the state of the art in Table 1 and Figure 1; see e.g. Alon et al [1], Luby [28, 29], Israeli and Itai [22], Hanckowiak et al [19, 20], and Barenboim et al [6, 8] for more prior work on maximal matchings and maximal independent sets
- It is interesting to compare MIS and MM with the classical distributed coloring problems: vertex coloring with ∆ + 1 colors and edge coloring with 2∆ − 1 colors [5]
- We applied three steps of local postprocessing to obtain algorithm A4; note that A4 is a black algorithm with the running time T − 1, as all postprocessing steps can be done without communication

Results

- There is no deterministic algorithm that finds an O( ∆)-matching in o( ∆) rounds in the port-numbering model in 2-colored graphs.
- There is no deterministic algorithm that finds a maximal matching in o(∆) rounds in the port-numbering model in 2-colored graphs.
- There is no deterministic algorithm that finds a maximal matching in o(∆ + log n/ log log n) rounds in the port-numbering model in 2-colored graphs.
- There exists a white randomized algorithm that solves Π∆(x + 1, y + x) in T − 1 rounds in trees, with local error probability at most q = 5∆p ∆+1 .
- Assume that there exists a white randomized algorithm that solves Π∆(x, y) in T rounds in trees with local error probability p, for ∆ ≥ x + y + T (x + 1 + (T − 1)/2).
- There is no white randomized algorithm that solves Π∆(x, y), for x, y ≤ ∆/8 and ∆ ≥ 8, in 0 rounds in trees with local error probability p ≤ 1/∆∆.
- Corollary 20, the authors obtain a white randomized algorithm A that solves Π∆(x , y ) in 0 rounds with local error probability p , where x
- There is no randomized distributed algorithm that finds a maximal matching in o log log n log log log n rounds with probability at least 1 − 1/n.

Conclusion

- There is no randomized distributed algorithm that finds a maximal independent set in o log log n log log log n rounds with probability at least 1 − 1/n.
- Recall the bound from Theorem 24: there is no randomized distributed algorithm that finds a maximal matching in o(∆ + log log n/ log log log n) rounds.
- There exists a white algorithm that solves Π∆(x + 1, y + x) in T − 1 rounds in trees

Summary

- There are four classic problems that have been studied extensively in distributed graph algorithms since the very beginning of the field in the 1980s [17]: maximal independent set (MIS), maximal matching (MM), vertex coloring with ∆ + 1 colors, and edge coloring with 2∆ − 1 colors; here ∆ is the maximum degree of the graph.
- It turns out there is a matching lower bound: no algorithm solves this problem in o(∆) rounds in the same model [21].
- Bipartite maximal matching can be solved in O(∆) rounds in ∆-regular two-colored graphs, and the running time is independent of the number of nodes.
- There is no deterministic algorithm that finds an O( ∆)-matching in o( ∆) rounds in the port-numbering model in 2-colored graphs.
- There is no deterministic algorithm that finds a maximal matching in o(∆) rounds in the port-numbering model in 2-colored graphs.
- There is no deterministic algorithm that finds a maximal matching in o(∆ + log n/ log log n) rounds in the port-numbering model in 2-colored graphs.
- There exists a white randomized algorithm that solves Π∆(x + 1, y + x) in T − 1 rounds in trees, with local error probability at most q = 5∆p ∆+1 .
- Assume that there exists a white randomized algorithm that solves Π∆(x, y) in T rounds in trees with local error probability p, for ∆ ≥ x + y + T (x + 1 + (T − 1)/2).
- There is no white randomized algorithm that solves Π∆(x, y), for x, y ≤ ∆/8 and ∆ ≥ 8, in 0 rounds in trees with local error probability p ≤ 1/∆∆.
- Corollary 20, the authors obtain a white randomized algorithm A that solves Π∆(x , y ) in 0 rounds with local error probability p , where x
- There is no randomized distributed algorithm that finds a maximal matching in o log log n log log log n rounds with probability at least 1 − 1/n.
- There is no randomized distributed algorithm that finds a maximal independent set in o log log n log log log n rounds with probability at least 1 − 1/n.
- Recall the bound from Theorem 24: there is no randomized distributed algorithm that finds a maximal matching in o(∆ + log log n/ log log log n) rounds.
- There exists a white algorithm that solves Π∆(x + 1, y + x) in T − 1 rounds in trees

- Table1: Efficient algorithms for MM and MIS

Related work

- MIS and MM. For MIS and MM, as well as for other classical symmetry-breaking problems, there are three major families of algorithms:

• Deterministic algorithms for a small ∆, with a complexity of the form f (∆) + O(log∗ n). • Deterministic algorithms for a large ∆, with superlogarithmic complexities as a function of n. • Randomized algorithms for a large ∆, with sublogarithmic complexities as a function of n.

We summarize the state of the art in Table 1 and Figure 1; see e.g. Alon et al [1], Luby [28, 29], Israeli and Itai [22], Hanckowiak et al [19, 20], and Barenboim et al [6, 8] for more prior work on maximal matchings and maximal independent sets.

Previously, it was not known if any of these algorithms are optimal. In essence, there have been only two lower bound results:

• Linial [26, 27] and Naor [30] show that there is no deterministic or randomized algorithm for MM or MIS that runs in o(log∗ n) rounds, even if we have ∆ = 2.

• Kuhn et al [23, 24, 25] show that there is no deterministic or randomized algorithm for MM or MIS that runs in o log ∆/ log log ∆ + log n/ log log n rounds.

Hence, for example, when we look at the fastest MM algorithms, dependency on n in O(∆ + log∗ n) is optimal, and dependency on ∆ in O(log ∆ + log3 log n) is near-optimal. However, could we get the best of the both worlds and solve MM or MIS in e.g. O(log ∆ + log∗ n) rounds?

Funding

- This work was supported in part by the Academy of Finland, Grants 285721 and 314888

Reference

- [13] Barenboim et al. [6, 8], Fischer [13]
- [7] Panconesi and Srinivasan
- [32] Ghaffari [16]
- 2. If there are at least x + y + 1 edges with a label in { POX, MPOX }, then there has to be at least one edge with a label in { X, MX }. Otherwise we could choose Di so that A outputs P on x + y + 1 edges, and there is no M or X. But all words of B∆(x, y) with at least x + y + 1 copies of P contain also at least one M or X.
- 1. There are at most x + y copies of POX on edges incident to u. We also know that there are at most x + 1 copies of labels { MX, MOX, MPOX }. Hence there have to be at least ∆ − (x + y) − (x + 1) = d − x − 1 copies of labels { X, OX }. We proceed as follows:
- 2. There are more than x + y copies of POX. Then we know that there is at least one copy of { X, MX }. We first proceed as follows:
- 2. We have a neighborhood in which the output of A at v matches Pd Oy Xx. Then by a similar reasoning:
- 2. Otherwise u is not incident to any edge of M. In this case pick arbitrarily k − 1 incident edges, label them with an X, and label all other incident edges with a P.
- 1. Node v is incident to at least one edge of M: All edges in M are labeled with M or X and all edges not in M are labeled with P, O, or X. We have got at least one edge incident to v labeled with M or X, at most k − 1 additional incident edges labeled with M or X, and everything else in [POX], which forms a word in [MX][POX]∆−k [MPOX]k−1.
- 2. Node v is not incident to an edge of M: Then by definition all white neighbors u of v were incident to at least one edge of M, and hence all incident edges are labeled with O or X, which forms a word in
- 2. We apply the automatic speedup simulation framework of [9] to obtain a problem Π1 that is exactly one round faster to solve than Π0. Then simplify Π1 as much as possible without losing this property. It turns out that Π1 is an edge labeling problem with 4 labels.
- 3. Repeat the same process to obtain problem Π2, which is an edge labeling problem with 6 labels.
- 4. At this point we can see that the structure of problems Π0, Π1, and Π2 is vaguely similar, but the set of labels is rapidly expanding and this also makes the problem description much more difficult to comprehend.
- 6. Many such identifications result in a problem Π2 that can be shown to be trivial (e.g. we can construct a problem that solves it in 0 or 1 round). However, by greedily exploring possible identifications we can find a way to map 6 output labels to 4 output labels such that the resulting problem Π2 still seems to be almost as hard to solve as the maximal matching problem.
- 7. At this point we have obtained the following problems: Π0 with 3 labels, Π1 with 4 labels, and Π2 also with 4 labels. For Π0 we had labels {M, P, O} with a simple interpretation. The next step is to try to rename the labels of Π1 and Π2 so that they would also use the familiar labels {M, P, O} plus some additional extra label X. It turns out that there is a way to rename the labels so that both Π1 and Π2 have some vague resemblance to the original formulation of (1). Here a helpful guidance was to consider posets similar to (3) and (4) that visualize some parts of the problem structure, and try to find a labeling that preserves the structure of the poset.
- 2. For each white node, the labels of the incident edges always form a word in W. 3. For each black node, the labels of the incident edges form a word in B with probability at least 1 − p.
- [1] Noga Alon, Laszlo Babai, and Alon Itai. A fast and simple randomized parallel algorithm for the maximal independent set problem. Journal of Algorithms, 7(4):567–583, 1986. doi:10.1016/01966774(86)90019-2.
- [2] MattiAstrand and Jukka Suomela. Fast distributed approximation algorithms for vertex cover and set cover in anonymous networks. In Proc. 22nd ACM Symposium on Parallelism in Algorithms and Architectures (SPAA 2010), pages 294–302. ACM Press, 2010. doi:10.1145/1810479.1810533.
- [3] Alkida Balliu, Juho Hirvonen, Dennis Olivetti, and Jukka Suomela. Hardness of minimal symmetry breaking in distributed computing, 2018. URL http://arxiv.org/abs/1811.01643.
- [4] Leonid Barenboim. Deterministic (∆+1)-Coloring in Sublinear (in ∆) Time in Static, Dynamic, and Faulty Networks. Journal of the ACM, 63(5):1–22, 2016. doi:10.1145/2979675.
- [5] Leonid Barenboim and Michael Elkin. Distributed Graph Coloring: Fundamentals and Recent Developments, volume 4. 2013. doi:10.2200/S00520ED1V01Y201307DCT011.
- [6] Leonid Barenboim, Michael Elkin, Seth Pettie, and Johannes Schneider. The Locality of Distributed Symmetry Breaking. In Proc. 53rd Annual Symposium on Foundations of Computer Science (FOCS 2012), pages 321–330. IEEE, 2012. doi:10.1109/FOCS.2012.60.
- [7] Leonid Barenboim, Michael Elkin, and Fabian Kuhn. Distributed (∆+1)-Coloring in Linear (in ∆) Time. SIAM Journal on Computing, 43(1):72–95, 2014. doi:10.1137/12088848X.
- [8] Leonid Barenboim, Michael Elkin, Seth Pettie, and Johannes Schneider. The Locality of Distributed Symmetry Breaking. Journal of the ACM, 63(3):1–45, 2016. doi:10.1145/2903137.
- [9] Sebastian Brandt. An Automatic Speedup Theorem for Distributed Problems, 2018.
- [10] Sebastian Brandt, Orr Fischer, Juho Hirvonen, Barbara Keller, Tuomo Lempiainen, Joel Rybicki, Jukka Suomela, and Jara Uitto. A lower bound for the distributed Lovasz local lemma. In Proc. 48th ACM Symposium on Theory of Computing (STOC 2016), pages 479–488. ACM Press, 2016. doi:10.1145/2897518.2897570.
- [11] Yi-Jun Chang, Tsvi Kopelowitz, and Seth Pettie. An Exponential Separation between Randomized and Deterministic Complexity in the LOCAL Model. In Proc. 57th IEEE Symposium on Foundations of Computer Science (FOCS 2016), pages 615–624. IEEE, 2016. doi:10.1109/FOCS.2016.72.
- [12] Yi-Jun Chang, Qizheng He, Wenzheng Li, Seth Pettie, and Jara Uitto. The Complexity of Distributed Edge Coloring with Small Palettes. In Proc. 29th ACM-SIAM Symposium on Discrete Algorithms (SODA 2018), pages 2633–2652. Society for Industrial and Applied Mathematics, 2018. doi:10.1137/1.9781611975031.168.
- [13] Manuela Fischer. Improved Deterministic Distributed Matching via Rounding. In Proc. 31st International Symposium on Distributed Computing (DISC 2017), pages 17:1–17:15, 2017. doi:10.4230/LIPIcs.DISC.2017.17.
- [14] Pierre Fraigniaud, Marc Heinrich, and Adrian Kosowski. Local Conflict Coloring. In 2016 IEEE 57th Annual Symposium on Foundations of Computer Science (FOCS), pages 625–634. IEEE, 2016. doi:10.1109/FOCS.2016.73.
- [15] Cyril Gavoille, Ralf Klasing, Adrian Kosowski, Lukasz Kuszner, and Alfredo Navarra. On the complexity of distributed graph coloring with local minimality constraints. Networks, 54(1): 12–19, 2009. doi:10.1002/net.20293.
- [16] Mohsen Ghaffari. An Improved Distributed Algorithm for Maximal Independent Set. In Proc. 27th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2016), pages 270–277, Philadelphia, PA, 2016. Society for Industrial and Applied Mathematics. doi:10.1137/1.9781611974331.ch20.
- [17] Mohsen Ghaffari. LOCAL Algorithms: The Chasm Between Deterministic and Randomized. In 6th Workshop on Advances in Distributed Graph Algorithms (ADGA 2017), 2017. URL http://adga.hiit.fi/2017/ghaffari.pdf.
- [18] Mika Goos, Juho Hirvonen, and Jukka Suomela. Linear-in-∆ lower bounds in the LOCAL model. Distributed Computing, 30(5):325–338, 2017. doi:10.1007/s00446-015-0245-8.
- [19] Michal Hanckowiak, Michal Karonski, and Alessandro Panconesi. On the Distributed Complexity of Computing Maximal Matchings. In Proc. 9th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 1998), pages 219–225. ACM/SIAM, 1998.
- [20] Michal Hanckowiak, Michal Karonski, and Alessandro Panconesi. On the Distributed Complexity of Computing Maximal Matchings. SIAM Journal on Discrete Mathematics, 15(1):41–57, 2001. doi:10.1137/S0895480100373121.
- [21] Juho Hirvonen and Jukka Suomela. Distributed maximal matching: greedy is optimal. In Proc. 31st Annual ACM SIGACT-SIGOPS Symposium on Principles of Distributed Computing (PODC 2012), pages 165–174. ACM Press, 2012. doi:10.1145/2332432.2332464.
- [22] Amos Israeli and A. Itai. A fast and simple randomized parallel algorithm for maximal matching. Information Processing Letters, 22(2):77–80, 1986. doi:10.1016/0020-0190(86)90144-4.
- [23] Fabian Kuhn, Thomas Moscibroda, and Roger Wattenhofer. What cannot be computed locally! In Proc. 23rd Annual ACM Symposium on Principles of Distributed Computing (PODC 2004), page 300, New York, New York, USA, 2004. ACM Press. doi:10.1145/1011767.1011811.
- [24] Fabian Kuhn, Thomas Moscibroda, and Roger Wattenhofer. The price of being near-sighted. In Proc. 17th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2006), pages 980–989, New York, New York, USA, 2006. ACM Press. doi:10.1145/1109557.1109666.
- [25] Fabian Kuhn, Thomas Moscibroda, and Roger Wattenhofer. Local Computation: Lower and Upper Bounds. Journal of the ACM, 63(2):1–44, 2016. doi:10.1145/2742012.
- [26] Nathan Linial. Distributive graph algorithms Global solutions from local data. In Proc. 28th Annual Symposium on Foundations of Computer Science (FOCS 1987), pages 331–335. IEEE, 1987. doi:10.1109/SFCS.1987.20.
- [27] Nathan Linial. Locality in Distributed Graph Algorithms. SIAM Journal on Computing, 21(1): 193–201, 1992. doi:10.1137/0221015.
- [28] Michael Luby. A simple parallel algorithm for the maximal independent set problem. In Proc. 17th Annual ACM Symposium on Theory of Computing (STOC 1985), pages 1–10, New York, New York, USA, 1985. ACM Press. doi:10.1145/22145.22146.
- [29] Michael Luby. A Simple Parallel Algorithm for the Maximal Independent Set Problem. SIAM Journal on Computing, 15(4):1036–1053, 1986. doi:10.1137/0215074.
- [30] Moni Naor. A lower bound on probabilistic algorithms for distributive ring coloring. SIAM Journal on Discrete Mathematics, 4(3):409–412, 1991. doi:10.1137/0404036.
- [31] Alessandro Panconesi and Romeo Rizzi. Some simple distributed algorithms for sparse networks. Distributed Computing, 14(2):97–100, 2001. doi:10.1007/PL00008932.
- [32] Alessandro Panconesi and Aravind Srinivasan. On the Complexity of Distributed Network Decomposition. Journal of Algorithms, 20(2):356–374, 1996. doi:10.1006/jagm.1996.0017.
- [33] David Peleg. Distributed Computing: A Locality-Sensitive Approach. Society for Industrial and Applied Mathematics, 2000. doi:10.1137/1.9780898719772.
- [34] Jukka Suomela. Lower Bounds for Local Algorithms. In 3rd Workshop on Advances in Distributed Graph Algorithms (ADGA 2014), 2014. URL http://adga2014.hiit.fi/jukka.pdf.

Full Text

Best Paper

Best Paper of FOCS, 2019

Tags

Comments