Lower bounds for maximal matchings and maximal independent sets

TL;DR

This paper establishes tight lower bounds for the round complexity of distributed algorithms solving maximal matchings and independent sets, matching the known upper bounds and resolving a long-standing open problem regarding their dependence on maximum degree.

Contribution

It proves that existing upper bounds are optimal by providing matching lower bounds, especially clarifying the dependency on maximum degree in distributed algorithms.

Findings

Lower bounds match upper bounds for maximal matchings and independent sets.

Dependency on maximum degree $\Delta$ is proven to be tight.

Improves prior lower bounds as a function of $n$.

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 even if $\Delta = 2$. However, the dependency on $\Delta$ is a long-standing open question, and there is currently an exponential gap between the upper and lower bounds. We prove that the upper bounds are tight. We show that any algorithm that finds a maximal matching or maximal independent set with probability at least $1-1/n$ requires $\Omega(\min\{\Delta,\log \log n / \log \log \log n\})$ rounds in the LOCAL model of distributed computing. As a corollary, it follows that any deterministic algorithm that finds a maximal matching or maximal independent set requires $\Omega(\min\{\Delta, \log n / \log \log n\})$ rounds; this is an improvement over prior lower bounds also as a function of $n$.

Figures

Tables

Table 1. Table 1. Efficient algorithms for MM and MIS.

Problem	$\Delta$	Randomness	Complexity	Reference
MM	small	deterministic	$O\left(\Delta +{\log }^{\ast }n\right)$	Panconesi and Rizzi (2001)
	large	deterministic	$O\left({\log }^2\Delta \cdot \log n\right)$	Fischer (2017)
	large	randomized	$O\left(\log \Delta +{\log }^3\log n\right)$	Fischer (2017); Barenboim et al. (2012, 2016)
MIS	small	deterministic	$O\left(\Delta +{\log }^{\ast }n\right)$	Barenboim et al. (2014)
	large	deterministic	$O\left({\log }^{7}n\right)$	Rozhoň and Ghaffari (2020)
	large	randomized	$O\left(\log \Delta +{\log }^7\log n\right)$	Rozhoň and Ghaffari (2020)

Equations

$$\Omega\biggl{(}\min\biggl{\{}\frac{\log\Delta}{\log\log\Delta},\sqrt{\frac{\log n}{\log\log n}}\biggr{\}}\biggr{)}$$

$$W$$

$$B$$

$$W_{\Delta }(x,y)$$

$$B_{\Delta }(x,y)$$

$$\mathsf{M}$$

$$\{\mathsf{X}\}$$

$$\{\mathsf{M}\},\{\mathsf{M},\mathsf{X}\}$$

$$\{\mathsf{O}\},\{\mathsf{O},\mathsf{X}\}$$

$$\{\mathsf{M},\mathsf{O}\},\{\mathsf{M},\mathsf{O},\mathsf{X}\}$$

$$\{\mathsf{P}\},\{\mathsf{P},\mathsf{O}\},\{\mathsf{P},\mathsf{X}\},\{\mathsf{P},\mathsf{O},\mathsf{X}\}$$

$$\{\mathsf{M},\mathsf{P}\},\{\mathsf{M},\mathsf{P},\mathsf{O}\},\{\mathsf{M},\mathsf{P},\mathsf{X}\},\{\mathsf{M},\mathsf{P},\mathsf{O},\mathsf{X}\}$$

$${\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu}}$$

$$\cdot$$

$$\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu}\mapsto\mathsf{M},\quad\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\mapsto\mathsf{P},\quad\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\mapsto\mathsf{O},\quad\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\mapsto\mathsf{X}.$$

$$\begin{split}W^{*}={}&[\mathsf{M}\mathsf{X}]\mspace{1.0mu}[\mathsf{P}\mathsf{O}\mathsf{X}]^{d-1+y}\mspace{1.0mu}[\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}]^{x}\bigm{|}[\mathsf{O}\mathsf{X}]^{d}\mspace{1.0mu}[\mathsf{P}\mathsf{O}\mathsf{X}]^{y}\mspace{1.0mu}[\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}]^{x}\\ ={}&\Bigl{(}[\mathsf{M}\mathsf{X}]\mspace{1.0mu}[\mathsf{P}\mathsf{O}\mathsf{X}]^{d-1}\bigm{|}[\mathsf{O}\mathsf{X}]^{d}\Bigr{)}\mspace{1.0mu}[\mathsf{P}\mathsf{O}\mathsf{X}]^{y}\mspace{1.0mu}[\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}]^{x}.\end{split}$$

$$\begin{split}B^{*}&=\mathsf{P}^{d-x-1}\mspace{1.0mu}\mathsf{O}^{x+y}\mspace{1.0mu}\mathsf{X}^{x+1}\bigm{|}\mathsf{M}\mspace{1.0mu}\mathsf{O}^{d+y-2}\mspace{1.0mu}\mathsf{X}^{x+1}\\ &=\Bigl{(}\mathsf{M}\mspace{1.0mu}\mathsf{O}^{d-x-2}\bigm{|}\mathsf{P}^{d-x-1}\bigr{)}\mspace{1.0mu}\mathsf{O}^{x+y}\mspace{1.0mu}\mathsf{X}^{x+1}.\end{split}$$

$$\Pi^{\prime}_{\Delta}(x+1,y+x)=\big{(}B_{\Delta}(x+1,y+x),\,W_{\Delta}(x+1,y+x)\bigr{)},$$

$$x^{\prime }$$

$$y^{\prime }$$

$$[\mathsf{MX}]\text{mspace}1.0mu[\mathsf{POX}{]}^{\Delta -k}\text{mspace}1.0mu[\mathsf{MPOX}{]}^{k-1}.$$

$$[\mathsf{OX}{]}^{\Delta -k+1}\text{mspace}1.0mu[\mathsf{MPOX}{]}^{k-1}.\text{qed}$$

$$U(u)$$

$$V(v)$$

$$D(u,v)$$

$$U=U(u),V_i=V(v_i),D_i=D(u,v_i).$$

$$\Pr_{D(u,v)}\bigl{[}\text{$A$ labels $\{u,v\}$ with $x$}\bigm{|}U(u)\bigr{]}\geq\alpha.$$

$$x^{\prime }$$

$$y^{\prime }$$

$$p^{\prime }$$

$$p_i\le (5\Delta {)}^2{p}^{1/(\Delta +1{)}^i}.$$

$$\begin{split}p_{i+1}&\leq 5\Delta\cdot p_{i}^{1/(\Delta+1)}\\ &\leq 5\Delta\cdot\bigl{(}(5\Delta)^{2}p^{1/(\Delta+1)^{i}}\bigr{)}^{1/(\Delta+1)}\\ &\leq(5\Delta)^{2}\cdot p^{1/(\Delta+1)^{i+1}}.\qed\end{split}$$

$$\frac{1}{(2\Delta {)}^{x+2}}\ge \frac{1}{(2\Delta {)}^{\Delta /8+2}}\ge \frac{1}{{\Delta }^{\Delta }}.$$

$$\frac{1}{2^{\Delta }}\cdot \frac{1}{{\Delta }^{x+y+1}}\ge \frac{1}{2^{\Delta }}\cdot \frac{1}{{\Delta }^{\Delta /4+1}}\ge \frac{1}{{\Delta }^{\Delta }}.\text{qed}$$

$$x^{\prime }$$

$$y^{\prime }$$

$$p^{\prime }$$

Full text

We prove that the upper bounds are tight. We show that any algorithm that finds a maximal matching or maximal independent set with probability at least $1-1/n$ requires $\Omega(\min\{\Delta,\log\log n/\log\log\log n\})$ rounds in the LOCAL model of distributed computing. As a corollary, it follows that any deterministic algorithm that finds a maximal matching or maximal independent set requires $\Omega(\min\{\Delta,\log n/\log\log n\})$ rounds; this is an improvement over prior lower bounds also as a function of $n$.

Maximal matching, maximal independent set, distributed graph algorithms, lower bounds

††ccs: Theory of computation Distributed computing models††ccs: Theory of computation Complexity classes

1. 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 (Ghaffari, 2017): maximal independent set (MIS), maximal matching (MM), vertex coloring with $\Delta+1$ colors, and edge coloring with $2\Delta-1$ colors; here $\Delta$ is the maximum degree of the graph. All of these problems are trivial to solve with a greedy centralized algorithm, but their distributed computational complexity has remained an open question.

In this work, we resolve the distributed complexity of MIS and MM in the region $\Delta\ll\log\log n$. In this region, for the LOCAL model (Linial, 1992; Peleg, 2000) of distributed computing, the fastest known algorithms for these problems are:

• •

MM is possible in $O(\Delta+\log^{*}n)$ rounds (Panconesi and Rizzi, 2001).

• •

MIS is possible in $O(\Delta+\log^{*}n)$ rounds (Barenboim et al., 2014).

Nowadays we know how to find a vertex or edge coloring with $O(\Delta)$ colors in $o(\Delta)+O(\log^{*}n)$ rounds (Fraigniaud et al., 2016; Barenboim, 2016). Hence the current algorithms for both MIS and MM are conceptually very simple: color the vertices or edges with $O(\Delta)$ colors, and then construct an independent set or matching by going through all color classes one by one (first select all nodes or edges of color 1, then select the nodes or edges of color 2 that are not adjacent to previously selected nodes or edges, then do the same for color 3, etc.). The second part is responsible for the $O(\Delta)$ term in the running time, and previously we had no idea if this is necessary.

1.1. Prior work

Already in the 1990s we had a complete understanding of the term $\log^{*}n$:

• •

MM is not possible in $f(\Delta)+o(\log^{*}n)$ rounds for any $f$ (Linial, 1987, 1992; Naor, 1991).

• •

MIS is not possible in $f(\Delta)+o(\log^{*}n)$ rounds for any $f$ (Linial, 1987, 1992; Naor, 1991).

Here the upper bounds are deterministic and the lower bounds hold also for randomized algorithms.

However, we have had no lower bounds that would exclude the existence of algorithms of complexity $o(\Delta)+O(\log^{*}n)$ for either of these problems (Barenboim and Elkin, 2013; Suomela, 2014). For regular graphs we have not even been able to exclude the possibility of solving both of these problems in time $O(\log^{*}n)$, while for the general case the best lower bound as a function of $\Delta$ was $\Omega(\log\Delta/\log\log\Delta)$ (Kuhn et al., 2004, 2006, 2016; Coupette and Lenzen, 2021).

1.2. Contributions

We close the gap and prove that the current upper bounds are tight. There is no algorithm of complexity $o(\Delta)+O(\log^{*}n)$ for MM or MIS. More precisely, our main result is:

Any algorithm that solves MM or MIS with probability at least $1-1/n$ requires

\displaystyle\Omega\Bigl{(}\min\Bigl{\{}\Delta,\frac{\log\log n}{\log\log\log n}\Bigr{\}}\Bigr{)} rounds in the LOCAL model.

Any deterministic algorithm that solves MM or MIS requires

\displaystyle\Omega\Bigl{(}\min\Bigl{\{}\Delta,\frac{\log n}{\log\log n}\Bigr{\}}\Bigr{)} rounds in the LOCAL model.

As corollaries, we have a new separation and a new equivalence in the $\Delta\ll\log\log n$ region (see Section 2.2):

• •

MM and MIS are strictly harder than $(\Delta+1)$-vertex coloring and $(2\Delta-1)$-edge coloring.

• •

MM and MIS are exactly as hard as greedy coloring.

1.3. Plan

We will present a simpler version of our new linear-in-$\Delta$ lower bound in Section 3. There we will introduce a restricted setting of distributed computing—deterministic algorithms in the port-numbering model—and explain the key ideas using that. In Section 4 we will then see how to extend the result to randomized and deterministic algorithms in the usual LOCAL model of computing.

2. Related work

2.1. 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 suitable for small $\Delta$, with a complexity of the form $f(\Delta)+O(\log^{*}n)$.

• •

Deterministic algorithms suitable also for large $\Delta$, with superlogarithmic complexities as a function of $n$.

• •

Randomized algorithms suitable also for large $\Delta$, with at most logarithmic 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. (1986), Luby (1985, 1986), Israeli and Itai (1986), Panconesi and Srinivasan (1996), Hanckowiak et al. (2001, 1998), Barenboim et al. (2012, 2016), and Ghaffari (2016) for more prior work on maximal matchings and maximal independent sets. The listed upper bounds for MIS by Rozhoň and Ghaffari (Rozhoň and Ghaffari, 2020) were obtained after the preliminary conference version of our work.

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

• •

Linial (1987, 1992) and Naor (1991) show that any deterministic or randomized algorithm for MM or MIS requires $\Omega(\log^{*}n)$ rounds, even if we have $\Delta=2$.

• •

Kuhn et al. (2004, 2006, 2016) show that any deterministic or randomized algorithm for MM or MIS requires

[TABLE]

rounds.

Hence, for example, when we look at the fastest MM algorithms, dependency on $n$ in $O(\Delta+\log^{*}n)$ is optimal, and dependency on $\Delta$ in $O(\log\Delta+\log^{3}\log n)$ is near-optimal. However, could we get the best of both worlds and solve MM or MIS in e.g. $O(\log\Delta+\log^{*}n)$ rounds?

In this work we show that the answer is no. There is no algorithm that runs in time $o(\Delta)+O(\log^{*}n)$. The current upper bounds for the case of a small $\Delta$ are optimal. Moreover, our work shows there is not much room for improvement in the dependency on $n$ in the algorithm by Fischer (2017), either.

With this result we resolve Open Problem 11.6 in the manuscript of Barenboim and Elkin (2013), and present a proof for the conjecture of Göös et al. (2017).

2.2. Coloring

It is interesting to compare MIS and MM with the classical distributed coloring problems: vertex coloring with $\Delta+1$ colors and edge coloring with $2\Delta-1$ colors (Barenboim and Elkin, 2013). As recently as in 2014, the fastest algorithms for all of these problems in the “small $\Delta$” region had the same complexity as MIS and MM, $O(\Delta+\log^{*}n)$ rounds (Barenboim et al., 2014). However, in 2015 the paths diverged: Barenboim (2016) and Fraigniaud et al. (2016) have presented algorithms for graph coloring in $o(\Delta)+O(\log^{*}n)$ rounds, and hence we now know that coloring is strictly easier than MM or MIS in the small $\Delta$ region.

The only known lower bound for $(\Delta+1)$-vertex coloring and $(2\Delta-1)$-edge coloring is $\Omega(\log^{*}n)$ (Linial, 1987, 1992; Naor, 1991); better lower bounds are known only for coloring algorithms of a certain form, called locally-iterative algorithms (Szegedy and Vishwanathan, 1993; Kuhn and Wattenhofer, 2006).

However, there is a variant of $(\Delta+1)$-vertex coloring that is closely related to MIS: greedy coloring (Gavoille et al., 2009). Greedy coloring is trivially at least as hard as MIS, as color class $1$ in any greedy coloring gives an MIS. On the other hand, greedy coloring is possible in time $O(\Delta+\log^{*}n)$, as we can turn an $O(\Delta)$-vertex coloring into a greedy coloring in $O(\Delta)$ rounds (and this was actually already known to be tight). Now our work shows that greedy coloring is exactly as hard as MIS. In a sense this is counterintuitive: finding just color class $1$ of a greedy coloring is already asymptotically as hard as finding the entire greedy coloring.

2.3. Restricted lower bounds

While no linear-in-$\Delta$ lower bounds for MM or MIS were known previously for the usual LOCAL model of distributed computing, there was a tight bound for a toy model of distributed computing: deterministic algorithms in the edge coloring model. Here we are given a proper edge coloring of the graph with $\Delta+1$ colors, the nodes are anonymous, and the nodes can use the edge colors to refer to their neighbors. In this setting there is a trivial algorithm that finds an MM in $O(\Delta)$ rounds: go through color classes one by one and greedily add edges that are not adjacent to anything added so far. It turns out there is a matching lower bound: no algorithm solves this problem in $o(\Delta)$ rounds in the same model (Hirvonen and Suomela, 2012).

The same technique was later used to study maximal fractional matchings in the LOCAL model of computing. This is a problem that can be solved in $O(\Delta)$ rounds (independent of $n$) in the usual LOCAL model (Åstrand and Suomela, 2010), and there was a matching lower bound that shows that the same problem cannot be solved in $o(\Delta)$ rounds (independent of $n$) in the same model (Göös et al., 2017).

While these lower bounds were seen as a promising indicator that there might be a linear-in-$\Delta$ lower bound in a more general setting, the previous techniques turned out to be a dead end. In particular, they did not tell anything nontrivial about the complexity of MM or MIS in the usual LOCAL model. Now we know that an entirely different kind of approach was needed—even though the present work shares some coauthors with (Hirvonen and Suomela, 2012; Göös et al., 2017), the techniques of the present work are entirely unrelated to those.

2.4. Speedup simulation technique

The technique that we use in this work is based on speedup simulation, a.k.a., round elimination. In essence, the idea is that we assume we have an algorithm $A$ that solves a problem $\Pi$ in $T$ rounds, and then we construct a new algorithm $A^{\prime}$ that solves another problem $\Pi^{\prime}$ in $T^{\prime}\leq T-1$ rounds. A node in algorithm $A^{\prime}$ gathers its radius-$T^{\prime}$ neighborhood, considers all possible ways of extending it to a radius-$T$ neighborhood, simulates $A$ for each such extension, and then uses the output of $A$ to choose its own output. Now if we can iterate the speedup step for $k$ times (without reaching a trivial problem), we know that the original problem requires at least $k$ rounds to solve.

This approach was first used by Linial (1987, 1992) and Naor (1991) to prove that graph coloring in cycles requires $\Omega(\log^{*}n)$ rounds. This was more recently used to prove lower bounds for sinkless orientations, algorithmic Lovász local lemma, and $\Delta$-coloring (Brandt et al., 2016; Chang et al., 2018), as well as to prove lower bounds for weak coloring (Brandt, 2019; Balliu et al., 2019b).

In principle, the approach can be used with any locally checkable graph problem, in a mechanical manner (Brandt, 2019). However, if one starts with a natural problem $\Pi$ (e.g. MIS, MM, or graph coloring) and applies the speedup simulation in a mechanical manner, the end result is typically a problem $\Pi^{\prime}$ that does not have any natural interpretation or simple description, and it gets quickly exponentially worse. The key technical challenge that the present work overcomes is the construction of a sequence of nontrivial problems $\Pi_{1},\Pi_{2},\dotsc$ such that each of them has a relatively simple description and we can nevertheless apply speedup simulation for any consecutive pair of them. Note that the simplicity of the descriptions is crucial in two ways: it allows us to prove the desired relation between the complexities of any two subsequent problems in the sequence, and it enables us to show that the problems indeed cannot be solved in [math] rounds.

The formalism that we use is closely related to (Brandt, 2019)—in essence, we generalize the formalism from graphs to hypergraphs, then represent the hypergraph as a bipartite graph, and we arrive at the formalism that we use in the present work to study maximal matchings in bipartite graphs.

3. Lower bound in the port-numbering model

Consider the following setting: We have a $\Delta$-regular bipartite graph; the nodes in one part are white and in the other part black. Each node has a port numbering for the incident edges; the endpoints of the edges incident to a node are numbered in some arbitrary order with $1,2,\dotsc,\Delta$. See Figure 2 for an illustration.

The graph represents the topology of a communication network: each node is a computer, and each edge is a communication link. Initially each computer only knows its own color (black or white) and the number of ports ($\Delta$); the computers are otherwise identical. Computation proceeds in synchronous communication rounds—in each round, each node can send an arbitrary message to each of its neighbors, then receive a message from each of its neighbors, and update its own state. After some $T$ communication rounds, all nodes have to stop and announce their own part of the solution; here $T$ is the running time of the algorithm.

We are interested in algorithms for finding a maximal matching; eventually each node has to know whether it is matched and in which port. There is a very simple algorithm that solves this in $T=O(\Delta)$ rounds (Hanckowiak et al., 1998): In iteration $i=1,2,\dotsc,\Delta$, unmatched white nodes send a proposal to their port number $i$, and black nodes accept the first proposal that they receive, breaking ties using port numbers. See Figure 3 for an example.

Hence bipartite maximal matching can be solved in $O(\Delta)$ rounds in $\Delta$-regular two-colored graphs, and the running time is independent of the number of nodes. Surprisingly, nobody has been able to tell if this algorithm is optimal, or anywhere close to optimal. There are no algorithms that break the linear-in-$\Delta$ barrier (without introducing some dependency on $n$ in the running time), and there are no nontrivial lower bounds—we have not been able to exclude even the possibility of solving maximal matchings in this setting in e.g. $10$ rounds, independently of $\Delta$ and $n$. If we look at a bit more general setting of graphs of degree at most $\Delta$ (instead of $\Delta$-regular graphs), there is a lower bound of $\Omega(\log\Delta/\log\log\Delta)$ (Kuhn et al., 2004, 2006, 2016), but there is still an exponential gap between the upper and the lower bound.

In this section we show that the trivial proposal algorithm is indeed optimal: there is no algorithm that finds a maximal matching in $o(\Delta)$ rounds in this setting. We will later extend the result to more interesting models of computing, but for now we will stick to the case of deterministic algorithms in the port-numbering model, as it is sufficient to explain all key ideas.

3.1. Lower bound idea

Our plan is to prove a lower bound using a speedup simulation argument (Linial, 1987, 1992; Naor, 1991; Brandt et al., 2016; Chang et al., 2018; Brandt, 2019; Balliu et al., 2019a). The idea is to define a sequence of graph problems $\Pi_{1},\Pi_{2},\dotsc,\Pi_{k}$ such that if we have an algorithm $A_{i}$ that solves $\Pi_{i}$ in $T_{i}$ rounds, we can construct an algorithm $A_{i+1}$ that solves $\Pi_{i+1}$ strictly faster, in $T_{i+1}\leq T_{i}-1$ rounds (unless $T_{i}=0$, in which case we would get that $T_{i+1}=0$). Put otherwise, we show that solving $\Pi_{i}$ takes at least one round more than solving $\Pi_{i+1}$. Then if we can additionally show that $\Pi_{k}$ is still a nontrivial problem that cannot be solved in zero rounds, we know that the complexity of $\Pi_{1}$ is at least $k$ rounds.

Now we would like to let $\Pi_{1}$ be the maximal matching problem, and identify a suitable sequence of relaxations of the maximal matching problem. A promising candidate might be, e.g., the following problem that we call here a $k$-matching for brevity.

Definition 3.0 ($k$-matching).

Given a graph $G=(V,E)$, a set of edges $M\subseteq E$ is a $k$-matching if

1. (1)

every node is incident to at most $k$ edges of $M$, 2. (2)

if a node is not incident to any edge of $M$, then all of its neighbors are incident to at least one edge of $M$.

Note that with this definition, a $1$-matching is exactly the same thing as a maximal matching. Also it seems that finding a $k$-matching is easier for larger values of $k$. For example, we could modify the proposal algorithm so that in each iteration white nodes send $k$ proposals in parallel, and stop as soon as at least one is accepted, and this way find a $k$-matching in $O(\Delta/k)$ rounds.

We could try to define $\Pi_{i}$ as the problem of finding an $i$-matching. Then, we could try to prove that, given an algorithm for finding an $i$-matching, we can construct a strictly faster algorithm for finding an $(i+1)$-matching. Unfortunately, a direct attack along these lines does not seem to work, but this serves nevertheless as a useful guidance that will point us in the right direction.

3.2. Formalism and notation

We will first make the setting as simple and localized as possible. It will be convenient to study graph problems that are of the following form—we call these edge labeling problems:

1. (1)

The task is to label the edges of the bipartite graph with symbols from some alphabet $\Sigma$. 2. (2)

A problem specification is a pair $\Pi=(W,B)$, where $W$ is the set of feasible labelings of the edges incident to a white node, and $B$ is the set of feasible labelings for the edges incident to a black node.

In these problems, the feasibility of a solution does not depend on the port numbering. Hence each member of $W$ and $B$ is a multiset that contains $\Delta$ elements from alphabet $\Sigma$. For example, if we have $\Sigma=\{0,1\}$ and $\Delta=3$, then W=\bigl{\{}\{0,0,0\},\{0,0,1\}\bigr{\}} indicates that a white node is happy (that is, the labeling of its incident edges is correct according to $W$) if it is incident to exactly [math] or $1$ edges with label $1$.

However, for brevity we will here represent multisets as words, and write e.g. W=\bigl{\{}0\mspace{1.0mu}0\mspace{1.0mu}0,0\mspace{1.0mu}0\mspace{1.0mu}1\bigr{\}}. We emphasize that the order of the elements does not matter here, and we could equally well write e.g. W=\bigl{\{}0\mspace{1.0mu}0\mspace{1.0mu}0,0\mspace{1.0mu}1\mspace{1.0mu}0\bigr{\}}. Now that $W$ and $B$ are languages over alphabet $\Sigma$, we can conveniently use regular expressions to represent them. When $x_{1},x_{2},\dotsc,x_{k}\in\Sigma$ are symbols of the alphabet, we use the shorthand notation $[x_{1}x_{2}\dotsc x_{k}]=(x_{1}|x_{2}|\dotso|x_{k})$. With this notation, we can represent the above example concisely as $W=0\mspace{1.0mu}0\mspace{1.0mu}0\mid 0\mspace{1.0mu}0\mspace{1.0mu}1$, or $W=0\mspace{1.0mu}0\mspace{1.0mu}[01]$, or even $W=0^{2}\mspace{1.0mu}[01]$.

3.2.1. Example: encoding maximal matchings

The most natural way to encode maximal matchings would be to use e.g. labels [math] and $1$ on the edges, with $1$ to indicate an edge in the matching. However, this is not compatible with the above formalism: we would have to have $0^{\Delta}\in W$ and $0^{\Delta}\in B$ to allow for unmatched nodes, but then we would also permit a trivial all-[math] solution. To correctly capture the notion of maximality, we will use three labels, $\Sigma=\{\mathsf{M},\mathsf{P},\mathsf{O}\}$, with the following rules:

[TABLE]

For a matched white node, one edge is labeled with an $\mathsf{M}$ (matched) and all other edges are labeled with an $\mathsf{O}$ (other). However, for an unmatched white node, all incident edges have to be labeled with a $\mathsf{P}$ (pointer); the intuition is that $\mathsf{P}$ points to a matched black neighbor. The rules for the black nodes ensure that pointers do not point to unmatched black nodes (a $\mathsf{P}$ implies exactly one $\mathsf{M}$), and that black nodes are unmatched only if all white neighbors are matched (all incident edges labeled with $\mathsf{O}$s). See Figure 4 for an illustration.

3.2.2. White and black algorithms

Let $\Pi=(W,B)$ be an edge labeling problem. We say that $A$ is a white algorithm that solves $\Pi$ if in $A$ each white node outputs a labeling of its incident edges, and such a labeling forms a feasible solution to $\Pi$. Black nodes produce an empty output.

Conversely, in a black algorithm, each black node outputs the labels of its incident edges, and white nodes produce an empty output. See Figure 4 for illustrations. Note that a black algorithm can be easily turned into a white algorithm if we use one additional communication round, and vice versa.

3.2.3. Infinite trees vs. finite regular graphs

It will be convenient to first present the proof for the case of infinite $\Delta$-regular trees. In essence, we will show that any algorithm $A$ that finds a maximal matching in $T=o(\Delta)$ rounds will fail around some node $u$ in some infinite $\Delta$-regular tree $G$ (for some specific port numbering), where failing around node $u$ means that the labels assigned to the edges incident to $u$ form a configuration that is not allowed by the problem. Then it is also easy to construct a finite $\Delta$-regular graph $G^{\prime}$ such that the radius-$(T+1)$ neighborhood of $u$ in $G$ (including the port numbering) is isomorphic to the radius-$(T+1)$ neighborhood of some node $u^{\prime}$ in $G^{\prime}$, and therefore $A$ will also fail around $u^{\prime}$ in $G^{\prime}$.

3.3. Parametrized problem family

We will now introduce a parametrized family of problems $\Pi_{\Delta}(x,y)$, where $x+y\leq\Delta$. The problem is defined so that $\Pi_{\Delta}(0,0)$ is equivalent to maximal matchings (1) and the problem becomes easier when we increase $x$ or $y$. We will use the alphabet $\Sigma=\{\mathsf{M},\mathsf{P},\mathsf{O},\mathsf{X}\}$, where $\mathsf{M}$, $\mathsf{P}$, and $\mathsf{O}$ have a role similar to maximal matchings and $\mathsf{X}$ acts as a wildcard. We define \Pi_{\Delta}(x,y)=\bigl{(}W_{\Delta}(x,y),\allowbreak B_{\Delta}(x,y)\bigr{)}, where

[TABLE]

where $d=\Delta-x-y$.

The following partial order represents the “strength” of the symbols from the perspective of black nodes:

[TABLE]

The interpretation is that from the perspective of $B_{\Delta}(x,y)$, symbol $\mathsf{X}$ is feasible wherever $\mathsf{M}$ or $\mathsf{O}$ is feasible, and $\mathsf{O}$ is feasible wherever $\mathsf{P}$ is feasible. Hence, we say that $\mathsf{X}$ is stronger than $\mathsf{M}$, $\mathsf{O}$, and $\mathsf{P}$, and that $\mathsf{O}$ is stronger than $\mathsf{P}$. Furthermore, all relations are strict in the sense that e.g. replacing an $\mathsf{X}$ with an $\mathsf{M}$ may lead to a word not in $B_{\Delta}(x,y)$.

Here are three examples of problems in family $\Pi_{\Delta}(\cdot,\cdot)$, with some intuition (from the perspective of a white algorithm):

• •

$\Pi_{\Delta}(0,0)$: Maximal matching. Note that we cannot use symbol $\mathsf{X}$ at all, as it does not appear in $W_{\Delta}(0,0)$.

• •

$\Pi_{\Delta}(0,1)$: Unmatched white nodes will use $\mathsf{O}$ instead of $\mathsf{P}$ once—note that by (3) this is always feasible for the black node at the other end of the edge. Unmatched black nodes can accept $\mathsf{P}$ instead of $\mathsf{O}$ once.

• •

$\Pi_{\Delta}(1,0)$: All white nodes will use $\mathsf{X}$ instead of $\mathsf{P}$ or $\mathsf{O}$ once—again, this is always feasible. All black nodes can accept anything from one port.

In essence, $\Pi_{\Delta}(0,y)$ resembles a problem in which we can violate maximality, while in $\Pi_{\Delta}(x,0)$ we can violate the packing constraints.

3.4. Speedup simulation

Assume that $A$ is a white algorithm that solves $\Pi_{\Delta}(x,y)$ in $T\geq 1$ rounds in trees, for a sufficiently large $\Delta$. Throughout this section, let $d=\Delta-x-y$, and assume that $\Delta\geq 2x+y+1$. We are going to proceed as follows. First, we construct a black algorithm $A_{1}$ that runs in $T-1$ rounds and works as follows. Given a $T-1$-radius neighborhood $U$, it extends $U$ into a $T$-radius neighborhood around a white node in all possible ways, then it simulates $A$ in all the obtained neighborhoods, and finally, for each incident edge, it outputs the set of the outputs given by $A$. On each edge, the output of algorithm $A_{1}$ is a set, and there are $15$ possible sets that could appear (namely all non-empty subsets of the output label set for $\Pi_{\Delta}(x,y)$). As our goal is to obtain a problem sequence where each problem is from the family $\Pi_{\Delta}(\cdot,\cdot)$, we need to reduce the number of labels back to $4$. We start by reducing the number of possible outputs to $6$, by defining a new algorithm $A_{2}$ that first executes $A_{1}$ and then maps the aforementioned sets to labels, such that different sets could be mapped to the same label. We could try to exactly characterize the problem solved by $A_{2}$, by listing the constraints defined over a set of $6$ labels that an output of $A_{2}$ satisfies. Instead, we are going to simplify the output of $A_{2}$, and reduce the number of labels from $6$ to $4$ by identifying some labels, which yields some algorithm $A_{3}$. Finally, we are going to define algorithm $A_{4}$, that does nothing else than executing $A_{3}$ and then renaming the obtained labels, and we are going to show that $A_{4}$ solves $\Pi_{\Delta}(x+1,y+x)$, but in a graph where the role of black and white nodes is reversed. For a more intuitive explanation of this approach, please see Section  3.8.

3.4.1. Algorithm $A_{1}$

We will first construct a black algorithm $A_{1}$ that runs in time $T-1$, as follows:

Each black node $u$ gathers its radius-$(T-1)$ neighborhood $U$; see Figure 5. Let the white neighbors of $u$ be $v_{1},v_{2},\dotsc,v_{\Delta}$. Let $V_{i}$ be the radius-$T$ neighborhood of $v_{i}$, and let $D_{i}=V_{i}\setminus U$ be the part of $V_{i}$ that $u$ does not see.

For each $i$, go through all possible inputs that one can assign to $D_{i}$; here the only unknown part is the port numbering that we have in the region $D_{i}$. Then simulate $A$ for each possible input and see how $A$ labels the edge $e_{i}=\{u,v_{i}\}$. Let $S_{i}$ be the set of labels that $A$ assigns to edge $e_{i}$ for some input $D_{i}$.

Algorithm $A_{1}$ labels edge $e_{i}$ with set $S_{i}$.

3.4.2. Algorithm $A_{2}$

Now since the output alphabet of $A$ is $\Sigma=\{\mathsf{M},\mathsf{P},\mathsf{O},\mathsf{X}\}$, the new output alphabet of $A_{1}$ consists of its 15 nonempty subsets. We construct another black algorithm $A_{2}$ with alphabet \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\allowbreak\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\allowbreak\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu},\allowbreak\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\allowbreak\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\} that simulates $A_{1}$ and then maps the output of $A_{1}$ as follows (see Figure 6 for an example):

[TABLE]

Here the intuition is that we first make each set maximal w.r.t. (3): for example, whenever we have a set with a $\mathsf{P}$, we also add an $\mathsf{O}$, and whenever we have a set with an $\mathsf{O}$, we also add an $\mathsf{X}$. This results in only six maximal sets, and then we replace e.g. the maximal set $\{\mathsf{M},\mathsf{O},\mathsf{X}\}$ with the label \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}.

3.4.3. Output of $A_{2}$

Let us analyze the output of $A_{2}$ for a black node. Fix a black node $u$ and its neighborhood $U$. The key property is that regions $D_{1},D_{2},\dotsc$ in Figure 5 do not overlap—hence if there is some input for $D_{1}$ that makes $v_{1}$ output some label $L_{1}$, and another input for $D_{2}$ that makes $v_{2}$ output some label $L_{2}$, we can also construct an input in which $v_{1}$ outputs $L_{1}$ and at the same time $v_{2}$ outputs $L_{2}$. We make the following observations:

1. (1)

There can be at most $x+1$ edges incident to $u$ with a label in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}. If there were $x+2$ such edges, say $e_{1},e_{2},\dotsc,e_{x+2}$, then it means we could fix $D_{1}$ such that $A$ outputs $\mathsf{M}$ for $e_{1}$, and simultaneously fix $D_{2}$ such that $A$ outputs $\mathsf{M}$ for $e_{2}$, etc. But this would violate the property that $A$ solves $\Pi_{\Delta}(x,y)$, as all words of $B_{\Delta}(x,y)$ contain at most $x+1$ copies of $\mathsf{M}$. 2. (2)

If there are at least $x+y+1$ edges with a label in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}, then there has to be at least one edge with a label in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu}\}. Otherwise we could choose $D_{i}$ so that $A$ outputs $\mathsf{P}$ on $x+y+1$ edges, and there is no $\mathsf{M}$ or $\mathsf{X}$. But all words of $B_{\Delta}(x,y)$ with at least $x+y+1$ copies of $\mathsf{P}$ contain also at least one $\mathsf{M}$ or $\mathsf{X}$.

3.4.4. Algorithm $A_{3}$

We construct yet another black algorithm $A_{3}$ that modifies the output of $A_{2}$ so that we replace labels only with larger labels according to the following partial order, which represents subset inclusion:

[TABLE]

There are two cases:

1. (1)

There are at most $x+y$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} on edges incident to $u$. We also know that there are at most $x+1$ copies of labels \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}. Hence there have to be at least $\Delta-{(x+y)}-{(x+1)}=d-x-1$ copies of labels \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}. We proceed as follows:

• •

Replace all of \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}.

• •

Replace some of \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} so that the total number of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} is exactly $x+1$.

• •

Replace some of the remaining \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} so that the total number of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} is exactly $x+y$.

• •

Replace all of the remaining \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu}.

We are now left with exactly $x+1$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}, exactly $x+y$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}, and exactly $d-x-1$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu}. 2. (2)

There are more than $x+y$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}. Then we know that there is at least one copy of \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu}\}. We first proceed as follows:

• •

Replace all \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} and all \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}.

• •

If needed, replace one \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu} so that there is at least one copy of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu}.

• •

Replace all remaining copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}.

At this point we have at least one \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu} and all other labels are in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}. Furthermore, as we originally had at most $x+1$ copies of \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}, and we created at most one new label in this set, we have now got at most $x+2$ copies of \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}. Hence we have got at least $d+y-2$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}. We continue:

• •

Replace some of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} so that the total number of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu} is exactly $1$.

• •

Replace some of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} with \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} so that the total number of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} is exactly $d+y-2$ and hence the total number of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} is $x+1$.

Note that we have completely eliminated labels \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{X}}}\mspace{2.0mu} and \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} and we are left with the following four labels:

[TABLE]

3.4.5. Algorithm $A_{4}$

Finally, we construct an algorithm $A_{4}$ that maps the output of $A_{3}$ as follows:

[TABLE]

Note that after this mapping, poset (5) restricted to $\{\mathsf{M},\mathsf{P},\mathsf{O},\mathsf{X}\}$ is the same as poset (3). One may have expected \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu} to be renamed to $\mathsf{O}$ and \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu} to be renamed to $\mathsf{P}$, but we did the opposite. Let us discuss the intuition behind this choice by taking maximal matching as an example. In this problem, $\mathsf{P}$ is used by white notes (that are active) to certify that all black neighbors (that are passive) are matched. Similarly, we can see label $\mathsf{O}$ as a label that can be used by black nodes to certify that they have white matched neighbors. Hence, we can see both $\mathsf{P}$ and $\mathsf{O}$ as pointers. The renaming that we use allows us to see $\mathsf{P}$ as the pointer of the active side and $\mathsf{O}$ as the pointer of the passive side, even if the role of active and passive swapped.

3.4.6. Output of $A_{4}$

Let us analyze the output of $A_{4}$ for a white node $v$. The key observation is that the output of $A$ is contained in the sets that $A_{1}$ outputs. More precisely, algorithm $A_{1}$ outputs sets based on its $T-1$-radius neighborhood, and if there is an extension of this neighborhood such that algorithm $A$, executed on the extended neighborhood, outputs some label on the edge corresponding to this extension, then this output label is contained in the set given by $A_{1}$ on this edge. Since all the possible outputs of $A$ are in $(\mathsf{M}\mspace{1.0mu}\mathsf{O}^{d-1}|\mathsf{P}^{d})\mspace{1.0mu}\mathsf{O}^{y}\mspace{1.0mu}\mathsf{X}^{x}$, there are two cases:

1. (1)

We have a neighborhood in which the output of $A$ at $v$ matches $\mathsf{M}\mspace{1.0mu}\mathsf{O}^{d-1+y}\mspace{1.0mu}\mathsf{X}^{x}$. Then:

• •

There is at least one edge incident to $v$ such that the output of $A_{1}$ contains an $\mathsf{M}$. Therefore the output of $A_{2}$ on this edge is in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}. As we followed (4), the output of $A_{3}$ for this edge is also in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}. After remapping, the output of $A_{4}$ for this edge is in $\{\mathsf{M},\mathsf{X}\}$.

• •

There are at least $d-1+y$ edges incident to $v$ such that the output of $A_{1}$ contains an $\mathsf{O}$. By a similar argument, the output of $A_{3}$ for each of these edges is in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\}, and the output of $A_{4}$ is hence in $\{\mathsf{P},\mathsf{O},\mathsf{X}\}$. 2. (2)

We have a neighborhood in which the output of $A$ at $v$ matches $\mathsf{P}^{d}\mspace{1.0mu}\mathsf{O}^{y}\mspace{1.0mu}\mathsf{X}^{x}$. Then by a similar reasoning:

• •

We have $d$ edges incident to $v$ such that the output of $A_{3}$ is in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\} and hence the output of $A_{4}$ is in $\{\mathsf{O},\mathsf{X}\}$.

• •

We have $y$ edges incident to $v$ such that the output of $A_{3}$ is in \{\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu},\mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}\} and hence the output of $A_{4}$ is in $\{\mathsf{P},\mathsf{O},\mathsf{X}\}$.

Hence the neighborhood of a white node in $A_{4}$ satisfies

[TABLE]

By construction, the output of a black node in $A_{3}$ follows one of these patterns:

1. (1)

$x+1$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}, $x+y$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}, and $d-x-1$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{O}\mathsf{X}}}\mspace{2.0mu}. 2. (2)

$1$ copy of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{X}}}\mspace{2.0mu}, $d+y-2$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}, and $x+1$ copies of \mspace{2.0mu}{\color[rgb]{.75,.75,.75}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.75,.75}\pgfsys@color@gray@stroke{.75}\pgfsys@color@gray@fill{.75}\boxed{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}\scriptstyle\mathsf{M}\mathsf{P}\mathsf{O}\mathsf{X}}}\mspace{2.0mu}.

Hence after remapping, the output of a black node in $A_{4}$ satisfies

[TABLE]

Hence $A_{4}$ solves $\Pi^{*}=(W^{*},B^{*})$. Now observe that $W^{*}=B_{\Delta}(x,y)$ and $B^{*}=W_{\Delta}(x+1,y+x)$.

Furthermore, observe that $B_{\Delta}(x,y)\subseteq B_{\Delta}(x+1,y+x)$. Hence $A_{4}$ also solves the problem

[TABLE]

which is otherwise exactly the same as $\Pi_{\Delta}(x+1,y+x)$, but the roles of the black and white nodes are reversed.

3.4.7. Conclusion

We started with the assumption that $A$ is a white algorithm that solves $\Pi_{\Delta}(x,y)$ in $T$ rounds. We constructed a black algorithm $A_{1}$ that runs in $T-1$ rounds. Then we applied three steps of local postprocessing to obtain algorithm $A_{4}$; note that $A_{4}$ is also a black algorithm with the running time $T-1$, as all postprocessing steps can be done without communication. We observed that $A_{4}$ solves $\Pi^{\prime}_{\Delta}(x+1,y+x)$.

Now if there is a black algorithm that solves $\Pi^{\prime}_{\Delta}(x+1,y+x)$ in $T-1$ rounds, we can reverse the roles of the colors and obtain a white algorithm that solves $\Pi_{\Delta}(x+1,y+x)$ in $T-1$ rounds. We have the following lemma:

Lemma 3.2.

Assume that there exists a white algorithm that solves $\Pi_{\Delta}(x,y)$ in $T\geq 1$ rounds in trees, for $\Delta\geq 2x+y+1$. Then there exists a white algorithm that solves $\Pi_{\Delta}(x+1,y+x)$ in $T-1$ rounds in trees.

By a repeated application of Lemma 3.2, we obtain the following corollary:

Corollary 3.3.

Assume that there exists a white algorithm that solves $\Pi_{\Delta}(x,y)$ in $T$ rounds in trees, for $\Delta\geq x+y+T(x+1+(T-1)/2)$. Then there is a white algorithm that solves $\Pi_{\Delta}(x^{\prime},y^{\prime})$ in [math] rounds in trees for

[TABLE]

3.5. Base case

Now to make use of Corollary 3.3, it is sufficient to show that there are problems in the family $\Pi_{\Delta}(x,y)$ that cannot be solved with [math]-round white algorithms:

Lemma 3.4.

There is no white algorithm that solves $\Pi_{\Delta}(x,y)$ in [math] rounds in trees when $\Delta\geq x+y+2$.

Proof.

Since by increasing $x$ and $y$ the problem does not get harder, it is enough to prove the statement for $\Delta=x+y+2$. As we are looking at deterministic algorithms in the port-numbering model, in a [math]-round white algorithm all white nodes produce the same output. By definition, the output has to be a permutation of some word $w\in W_{\Delta}(x,y)$. Now there are only two possibilities:

1. (1)

$w=\mathsf{M}\mspace{1.0mu}\mathsf{O}^{y+1}\mspace{1.0mu}\mathsf{X}^{x}$: There is some port $p$ that is labeled with $\mathsf{M}$. Now consider a black node $u$ such that for all white neighbors $v$ of $u$, port $p$ of $v$ is connected to $u$. Then all $\Delta=x+y+2$ edges incident to $u$ are labeled with an $\mathsf{M}$. However, by definition of $B_{\Delta}(x,y)$, at most $x+1$ edges incident to a black node can be labeled with an $\mathsf{M}$. 2. (2)

$w=\mathsf{P}^{2}\mspace{1.0mu}\mathsf{O}^{y}\mspace{1.0mu}\mathsf{X}^{x}$: By a similar reasoning, we can find a black node $u$ such that all $\Delta=x+y+2$ edges incident to $u$ are labeled with a $\mathsf{P}$. However, at most $x+y+1$ edges incident to a black node can be labeled with a $\mathsf{P}$. ∎

3.6. Amplifying through $k$-matchings

A straightforward application of Corollary 3.3 and Lemma 3.4 already gives a new lower bound—it just is not tight yet:

Theorem 3.5.

Any deterministic algorithm that finds a maximal matching in the port-numbering model in $2$-colored graphs requires $\Omega(\sqrt{\Delta})$ rounds.

Proof.

Any algorithm that runs in $T$ rounds implies a white algorithm that runs in $O(T)$ rounds, and naturally a general algorithm also has to solve the problem correctly in trees. Let us assume for a contradiction that for any constant $c>0$ and any positive integer $\Delta_{0}$ there exists $\Delta>\Delta_{0}$ such that there exists a white deterministic algorithm that finds a maximal matching in the port numbering model in $2$-colored graphs in less than $c\sqrt{\Delta}$ rounds.

Recall that $\Pi_{\Delta}(0,0)$ is equal to the maximal matching problem. If we could solve it with a white algorithm in less than $c\sqrt{\Delta}$ rounds, then by Corollary 3.3 we could also solve $\Pi_{\Delta}(x^{\prime},y^{\prime})$ in [math] rounds, where $x^{\prime}=c\sqrt{\Delta}$ and $y^{\prime}=c\sqrt{\Delta}(c\sqrt{\Delta}-1)/2$. For small enough $c$ and large enough $\Delta_{0}$, $x^{\prime}+y^{\prime}+2=c\sqrt{\Delta}+c\sqrt{\Delta}(c\sqrt{\Delta}-1)/2\leq\Delta$, which contradicts Lemma 3.4. ∎

However, we can easily amplify this and get a linear-in-$\Delta$ lower bound. Recall $k$-matchings from Definition 3.1. We make the following observation:

Lemma 3.6.

If there is an algorithm that finds a $k$-matching in $T$ rounds, there is also a white algorithm that solves $\Pi_{\Delta}(k-1,0)$ in $T+O(1)$ rounds.

Proof.

Consider a $k$-matching $M$, and consider a white node $u$.

1. (1)

If $u$ is incident to at least one edge of $M$, then pick arbitrarily one $e\in M$ incident to $u$ and label $e$ with an $\mathsf{M}$. Label all other edges $\{u,v\}\in M\setminus\{e\}$ with an $\mathsf{X}$; note that this results in at most $k-1$ incident edges with an $\mathsf{X}$. Then label all other edges $\{u,v\}\notin M$ with $\mathsf{O}$ or $\mathsf{X}$ such that the total number of incident edges with an $\mathsf{X}$ is exactly $k-1$. 2. (2)

Otherwise $u$ is not incident to any edge of $M$. In this case pick arbitrarily $k-1$ incident edges, label them with an $\mathsf{X}$, and label all other incident edges with a $\mathsf{P}$.

At this point by construction white nodes satisfy $W_{\Delta}(k-1,0)$. It remains to be checked that black nodes satisfy $B_{\Delta}(k-1,0)$; to this end, consider a black node $v$. There are two cases:

1. (1)

Node $v$ is incident to at least one edge of $M$: All edges in $M$ are labeled with $\mathsf{M}$ or $\mathsf{X}$ and all edges not in $M$ are labeled with $\mathsf{P}$, $\mathsf{O}$, or $\mathsf{X}$. We have got at least one edge incident to $v$ labeled with $\mathsf{M}$ or $\mathsf{X}$, at most $k-1$ additional incident edges labeled with $\mathsf{M}$ or $\mathsf{X}$, and everything else in $[\mathsf{P}\mathsf{O}\mathsf{X}]$, which forms a word in

[TABLE] 2. (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 $\mathsf{O}$ or $\mathsf{X}$, which forms a word in

[TABLE]

Now the same reasoning as Theorem 3.5 gives the following result:

Theorem 3.7.

Any deterministic algorithm that finds an $O(\sqrt{\Delta})$-matching in the port-numbering model in $2$-colored graphs requires $\Omega(\sqrt{\Delta})$ rounds.

Proof.

For a contradiction, assume that the theorem statement is not true, which, by Lemma 3.6, implies that there is a $T$-round algorithm that solves $\Pi_{\Delta}(x,y)$, for $x=O(\sqrt{\Delta})$, $y=0$, and $T=o(\sqrt{\Delta})$. By Corollary 3.3, this implies that there is a [math]-round algorithm for $\Pi_{\Delta}(x^{\prime},y^{\prime})$, where $x^{\prime}=O(\sqrt{\Delta})$ and $y^{\prime}=o(\Delta)$. Note that, for $\Delta$ large enough, $\Delta-x^{\prime}-y^{\prime}$ is much larger than $2$. But by Lemma 3.4, since $\Delta\geq x^{\prime}+y^{\prime}+2$, $\Pi_{\Delta}(x^{\prime},y^{\prime})$ cannot be solved in [math] rounds, and hence we reached a contradiction. ∎

Now it turns out that Theorem 3.7 is tight, and we can use it to prove a tight lower bound for maximal matchings:

Theorem 3.8.

Any deterministic algorithm that finds a maximal matching in the port-numbering model in $2$-colored graphs requires $\Omega(\Delta)$ rounds.

Proof.

Assume that $A$ is an algorithm that finds a maximal matching in $f(\Delta)=o(\Delta)$ rounds. We use $A$ to construct algorithm $A^{\prime}$ that finds an $O(\sqrt{\Delta})$-matching in $o(\sqrt{\Delta})$ rounds; then we can apply Theorem 3.7 to see that $A$ cannot exist.

Algorithm $A^{\prime}$ constructs a new virtual graph $G^{\prime}$ by splitting each node $u$ of $G$ arbitrarily in $O(\sqrt{\Delta})$ mininodes $u_{1},u_{2},\dotsc$, each of degree $O(\sqrt{\Delta})$; see Figure 7. Then $A^{\prime}$ simulates $A$ in graph $G^{\prime}$ to find a maximal matching $M^{\prime}$ of $G^{\prime}$. Now $M^{\prime}$ defines an $O(\sqrt{\Delta})$-matching $M$ in the original graph $G$. To see this, note that each mininode is incident to at most one edge of $M^{\prime}$, and hence each original node is incident to $O(\sqrt{\Delta})$ edges of $M$. Furthermore, if a node $u$ is not incident to any edge of $M$, then all neighbors of each mininode are matched in $M^{\prime}$, and hence all original neighbors of $u$ are incident to at least one edge of $M$.

To conclude the proof, note that the maximum degree of the virtual graph $G^{\prime}$ is $\Delta^{\prime}=O(\sqrt{\Delta})$, and hence the simulation of $A$ in $G^{\prime}$ completes in $f(\Delta^{\prime})=o(\sqrt{\Delta})$ rounds. ∎

3.7. Bounds for finite graphs

We now prove the existence of a certain family of graphs, that will be later used to apply the ideas explained in Section 3.2.3.

Lemma 3.9.

There exists a constant $c>0$ such that for any $n$ large enough and any $\Delta$ satisfying that at least one of $n$ and $\Delta$ is even and $2\leq\Delta<n/10$, there exists a $\Delta$-regular connected graph $G=(V,E)$ where $|V|=n$ that contains a node $v\in V$ such that the radius-$t$ neighborhood of $v$ is isomorphic to a $\Delta$-regular tree, for some $t\geq c\log_{\Delta}n$.

Proof.

For $\Delta=2$ the statement follows by considering a cycle of $n$ nodes, so in the following we assume $\Delta>2$. A $\Delta$-regular balanced tree of depth $t$ contains $f_{\Delta}(t)=(\Delta(\Delta-1)^{t}-2)/(\Delta-2)$ nodes. We choose the maximal $t$ such that $n-f_{\Delta}(t)-(\Delta-1)^{t}>\Delta$. Note that we always have $t\geq 1$, as $n>10\Delta$ and $\Delta+f_{\Delta}(1)+(\Delta-1)^{1}=3\Delta$. We build a $\Delta$-regular balanced tree $T$ of depth $t$. Tree $T$ has $\Delta(\Delta-1)^{t-1}$ leaves of degree 1, and all the other nodes are of degree $\Delta$. Finally we turn $T$ into a $\Delta$-regular graph: we add $(\Delta-1)^{t}$ new nodes, called bottom nodes, and connect those nodes with the leaves; each bottom node is connected to $\Delta$ distinct leaf nodes, and each leaf node is connected to distinct $\Delta-1$ bottom nodes.

So far we have got $f_{\Delta}(t)+(\Delta-1)^{t}$ nodes in graph $T$; we are still missing $N=n-f_{\Delta}(t)-(\Delta-1)^{t}>\Delta$ nodes. Notice that if $\Delta$ is odd, $f_{\Delta}(t)$ and $(\Delta-1)^{t}$ are even, meaning that $N$ is even. We now use the fact that for any $\Delta\geq 2$ and $N>\Delta$ such that one of them is even, a $\Delta$-regular connected graph $H$ of size $N$ always exists: arrange the $N$ nodes in a cycle; if $\Delta$ is even, node $i$ is connected to its $\Delta/2$ predecessors and successors; if $\Delta$ is odd, $N$ is even and you can also connect $i$ to the node diametrically opposed.

So far we have got two connected components, $T$ and $H$, both of them $\Delta$-regular graphs with $n$ nodes in total. In order to connect $T$ and $H$, we pick an arbitrary edge $\{u,v\}$ of $H$ and an arbitrary edge $\{w,x\}$ adjacent to a bottom node $x$ of $T$. We remove such edges and add the edges $\{u,w\}$ and $\{v,x\}$.

The obtained graph $G$ contains exactly $n$ nodes, it is $\Delta$-regular, and the $t$-radius ball around the node corresponding to the root of $T$ is a $\Delta$-regular tree. Moreover, we can notice that $t=\Omega(\log_{\Delta}f_{\Delta}(t))$. By the choice of $t$, we have $f_{\Delta}(t)-(\Delta-1)^{t}<n-\Delta<f_{\Delta}(t+1)-(\Delta-1)^{t+1}$, hence $t=\Omega(\log_{\Delta}n)$. ∎

Lemma 3.10.

There exists a constant $c>0$ such that for any $n$ and $\Delta$ large enough satisfying that at least one of $n$ and $\Delta$ is even and $\Delta<n/10$, any deterministic algorithm that finds a maximal matching in $\Delta$-regular $2$-colored graphs of $n$ nodes requires at least $c\min\{\Delta,\log_{\Delta}n\}$ rounds in the port-numbering model.

Proof.

We can apply the idea explained in Section 3.2.3 to convert the lower bound of Theorem 3.8, presented for infinite $\Delta$-regular trees, into a lower bound for $\Delta$-regular graphs containing $n$ nodes.

Let us assume for a contradiction that for any constant $c>0$ and any positive integers $n_{0}$ and $\Delta_{0}$ there exist $n>n_{0}$ and $\Delta>\Delta_{0}$ satisfying $\Delta<n/10$ such that there is a deterministic algorithm that finds a maximal matching in $\Delta$-regular $2$-colored graphs of $n$ nodes in less than $c\min\{\Delta,\log_{\Delta}n\}$ rounds.

We fix $c$ to be the minimum of $0.1$, the constant $c$ of Lemma 3.9, and the constant hidden in the $\Omega$-notation of Theorem 3.8. We will later fix $n_{0}$ and $\Delta_{0}$ to be large enough constants.

We run this algorithm on an infinite $\Delta$-regular tree, by claiming that the number of nodes is $n$. Since the running time of the algorithm is less than $c\log_{\Delta}n$, the algorithm sees at most $\Delta^{c\log_{\Delta}n}=n^{c}<n$ nodes, and hence does not detect that we lied about the size of the graph. Since $T$ is also less than $c\Delta$, by Theorem 3.8 the algorithm must fail in some neighborhood, if $\Delta$ is large enough. We fix $\Delta_{0}$ to make $\Delta$ satisfy such a requirement.

Now, we fix $n_{0}$ large enough and apply Lemma 3.9 to construct a $\Delta$-regular graph of $n$ nodes containing a node with the same neighborhood in which the algorithm failed, and the algorithm must fail in such a graph as well, a contradiction. ∎

Note that $\Delta$ and $\log_{\Delta}n$ become roughly the same by setting $\Delta\approx\log n/\log\log n$. Hence, if we consider $\Delta$ to be an upper bound for the maximum degree, we directly get the following.

Corollary 3.11.

Any deterministic algorithm that finds a maximal matching in $2$-colored graphs of maximum degree at most $\Delta$ requires $\Omega(\min\{\Delta,\log n/\log\log n\})$ rounds in the port-numbering model.

The following corollary gives a lower bound for the running time of any algorithm for maximal matching, if we express it solely as a function of $n$.

Corollary 3.12.

Any deterministic algorithm that finds a maximal matching in $\Delta$-regular $2$-colored graphs requires $\Omega(\log n/\log\log n)$ rounds in the port-numbering model.

We have now come to the conclusion of this section: we have a tight linear-in-$\Delta$ lower bound for deterministic algorithms in the port-numbering model. In Section 4 we show how to extend the same argument so that it also covers randomized algorithms in the usual LOCAL model (and as a simple corollary, also gives a lower bound for MIS). The extension is primarily a matter of technicalities—we will use the same ideas and the same formalism as what we have already used in this section, and then analyze how the probability of a failure increases when we speed up randomized algorithms.

Before presenting the randomized lower bound, we briefly discuss the question of how we came up with the right problem family $\Pi_{\Delta}(x,y)$ that enabled us to complete the lower bound proof—we hope similar ideas might eventually lead to a lower bound for other graph problems besides MM and MIS.

3.8. Behind the scenes: how the right problem family was discovered

Let us now look back at the ingredients of the lower-bound proof. The most interesting part is the speedup simulation of Section 3.4. Here algorithm $A_{1}$ follows the standard idea that is similar to what was used already by Linial (1987, 1992). Algorithm $A_{2}$ is related to the idea of simplification by maximality in (Brandt, 2019)—this is something we can do without losing any power in the speedup simulation argument. On the other hand, algorithm $A_{4}$ merely renames the output labels. Hence algorithm $A_{3}$ is the only place in which truly novel ideas are needed.

Now if we already had the insight that the problem family $\Pi_{\Delta}(x,y)$ defined in (2) is suitable for the purpose of the speedup simulation, then inventing $A_{3}$ is not that hard with a bit of trial and error and pattern matching. However, at least to us it was not at all obvious that (2) would be the right relaxation of the maximal matching problem (1).

While some amount of lucky guessing was needed, it was greatly simplified by following this approach:

• •

We start with the formulation of (1); let us call this problem $\Pi_{0}$. This is an edge labeling problem with $3$ labels.

• •

We apply the automatic speedup simulation framework of (Brandt, 2019) to obtain a problem $\Pi_{1}$ that is exactly one round faster to solve than $\Pi_{0}$. Then simplify $\Pi_{1}$ as much as possible without losing this property. It turns out that $\Pi_{1}$ is an edge labeling problem with $4$ labels.

• •

Repeat the same process to obtain problem $\Pi_{2}$, which is an edge labeling problem with $6$ labels.

• •

At this point we can see that the structure of problems $\Pi_{0}$, $\Pi_{1}$, and $\Pi_{2}$ is vaguely similar, but the set of labels is rapidly expanding and this also makes the problem description much more difficult to comprehend.

• •

A key idea is this: given problem $\Pi_{2}$ with $6$ labels, we can construct another problem $\Pi^{\prime}_{2}$ that is at least as easy to solve as $\Pi_{2}$ by identifying some labels of $\Pi_{2}$. For example, if the set of output labels in $\Pi_{2}$ is $\{1,2,3,4,5,6\}$, we could replace both $1$ and $2$ with a new label $12$ and obtain a new problem $\Pi^{\prime}_{2}$ with the alphabet $\{12,3,4,5,6\}$. Trivially, given an algorithm for solving $\Pi_{2}$ we can also solve $\Pi^{\prime}_{2}$ by remapping the outputs. However, it is not at all obvious that $\Pi^{\prime}_{2}$ is a nontrivial problem.

• •

Many such identifications result in a problem $\Pi^{\prime}_{2}$ that can be shown to be trivial (e.g. we can construct a problem that solves it in [math] 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 $\Pi^{\prime}_{2}$ still seems to be almost as hard to solve as the maximal matching problem.

• •

At this point we have obtained the following problems: $\Pi_{0}$ with $3$ labels, $\Pi_{1}$ with $4$ labels, and $\Pi^{\prime}_{2}$ also with $4$ labels. For $\Pi_{0}$ we had labels $\{\mathsf{M},\mathsf{P},\mathsf{O}\}$ with a simple interpretation. The next step is to try to rename the labels of $\Pi_{1}$ and $\Pi^{\prime}_{2}$ so that they would also use the familiar labels $\{\mathsf{M},\mathsf{P},\mathsf{O}\}$ plus some additional extra label $\mathsf{X}$. It turns out that there is a way to rename the labels so that both $\Pi_{1}$ and $\Pi^{\prime}_{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.

Now, in essence, (2) is inspired by a relaxation and a generalization of problems $\Pi_{0}$, $\Pi_{1}$, and $\Pi^{\prime}_{2}$ constructed above, and algorithm $A_{3}$ captures the key idea of mapping $6$ output labels to $4$ output labels.

While the idea is arguably vague and difficult to generalize, we highlight some ingredients that turned out to be instrumental:

• •

We do not try to first guess a family of problems; we apply the speedup simulation framework from (Brandt, 2019) in a mechanical manner for a couple of iterations and see what is the family of problems that emerges. Only after that we try to relate it to natural graph problems, such as $k$-matchings.

• •

We keep the size of the output alphabet manageable by collapsing multiple distinct labels to one label. However, we allow for some new “unnatural” labels (here: $\mathsf{X}$) that emerge in the process in addition to the “natural” labels that we had in the original problem (here: $\mathsf{M},\mathsf{P},\mathsf{O}$).

While many of the elements in our proof have some flexibility—we often somewhat liberally “round down” and simplify problems in order to keep the proofs and definitions as simple as possible—we are not aware of any way of generalizing (1) to something similar to (2) so that we could use a natural $3$-symbol alphabet and still prove a speedup result.

Finally, we point out that the new label $\mathsf{X}$ that emerged in the mechanical process was not exactly a wildcard symbol. It behaved a bit like a wildcard in certain contexts, and we simply forced this simple interpretation by relaxing the problem and allowing it to behave like a wildcard in all contexts.

4. Lower bounds in the LOCAL model

In Section 3 we gave a linear-in-$\Delta$ lower bound for deterministic distributed algorithms in the port-numbering model. Now we would like to

1. (1)

extend the result from the port-numbering model to the LOCAL model, 2. (2)

extend the result from deterministic algorithms to randomized algorithms.

4.1. LOCAL model

In the area of distributed graph algorithms, there are two widely used models of computing: LOCAL and CONGEST (Peleg, 2000). The LOCAL model is strictly stronger than the CONGEST model; as we are interested in lower bounds, we will here use the LOCAL model to make our result as widely applicable as possible.

In the LOCAL model, each node is labeled with a unique identifier. If there are $n$ nodes in the network, the unique identifiers are some subset of $\{1,2,\dotsc,\operatorname{poly}(n)\}$. Put otherwise, the unique identifiers are $O(\log n)$-bit natural numbers. We assume that the nodes know $n$, which can be done without loss of generality as we are proving impossibility results.

Other than the assumption of unique identifiers, the model of computing is the same as what we already used in Section 3: nodes are computational entities, edges are communication links, and computation proceeds in synchronous communication rounds. The computational power of each entity and the bandwidth is not limited, that is, each node can send messages of arbitrary size and can perform local computation of arbitrary complexity. Initially, each node knows its own unique identifier. In each round, each node can:

• •

send an arbitrary message to each of its neighbors;

• •

receive a message from each neighbor;

• •

perform some local computation and update its own state.

A distributed algorithm runs in $T$ rounds in the LOCAL model if after $T$ rounds each node has terminated and outputted a local output, and these local outputs constitute a feasible global solution. Since the communication power is not limited, a distributed algorithm that runs in $T$ rounds in the LOCAL model can be seen as a procedure that does the following at each node $v$:

1. (1)

gather the topology of the network up to distance $T$ form $v$; 2. (2)

perform unbounded local computation to produce its local output.

In a randomized algorithm the nodes are labeled also with a stream of random bits. We are primarily interested in Monte Carlo algorithms that find a maximal matching with high probability, which we here define so that the running time is fixed and the global success probability is at least $1-1/n$.

4.2. High-level plan

We will use a construction similar to Section 3. In particular, we will prove a lower bound for the problem of finding a maximal matching in a $2$-colored regular tree. Naturally, the same lower bound then holds also in the general case, even if we do not have a $2$-coloring.

Ideally, we would like to first extend the proof so that it holds also with unique identifiers, this way derive a lower bound for deterministic algorithms in the LOCAL model, and then later add random input bits to derive a lower bound for randomized algorithms in the LOCAL model.

Unfortunately, the speedup simulation technique does not work well with unique identifiers. If we look at e.g. regions $D_{1}$ and $D_{2}$ in Figure 5, the inputs in these parts are no longer independent: for example, if $D_{1}$ contains a node with unique identifier $1$, we know that $D_{2}$ cannot contain such a node.

Hence, as usual, we take a different route (Brandt et al., 2016): we first add randomness. We repeat the analysis of Section 3 for randomized Monte Carlo algorithms in the port-numbering model. This way we can still use independence: random bits in $D_{2}$ are independent of random bits in $D_{1}$.

Once we have a lower bound for Monte Carlo randomized algorithms in the port-numbering model, it is straightforward to turn this into a lower bound for Monte Carlo randomized algorithms in the LOCAL model. To see this, we first observe that the lower bound holds also even if all nodes are labeled with the value of $n$ (such extra information does not change anything in the proof). But now if we know $n$, it is easy to use randomness to construct $O(\log n)$-bit labels that are unique with high probability. Hence a Monte Carlo randomized algorithm in the LOCAL model can be turned into a Monte Carlo randomized algorithm in the port-numbering model (with knowledge of $n$), and our lower bound applies. Finally, a lower bound for randomized algorithms in the LOCAL model trivially implies a lower bound also for deterministic algorithms in the LOCAL model.

4.3. White and black randomized algorithms

Let us now extend the concepts of white and black algorithms to white and black randomized algorithms. As discussed above, we use the port-numbering model augmented with randomness; in brief, each node is labeled with a random bit string, and in a time-$T$ algorithm, the output of a node $u$ may depend on the random bit strings of all nodes $v$ that are within distance $T$ from $u$.

We say that $A$ is a white randomized algorithm for $\Pi=(W,B)$ with a local error probability $p$ if the following holds:

1. (1)

White nodes produce labels for the incident edges, and black nodes produce an empty output. 2. (2)

For each white node, the labels of the incident edges always form a word in $W$. 3. (3)

For each black node, the labels of the incident edges form a word in $B$ with probability at least $1-p$.

A black randomized algorithm is analogous, with the roles of white and black nodes reversed.

Note that if we are given any Monte Carlo randomized algorithm $A$ that solves $\Pi$ with high probability in time $T$, we can always turn it into a white randomized algorithm (or black randomized algorithm) $A^{\prime}$ that solves $\Pi$ with a local error probability $1/n$ and running time $T+O(1)$: the local failure probability cannot exceed the global failure probability, and if some white nodes are unhappy (violating constraints in $W$), we can locally fix it so that all white nodes are happy and only black nodes are unhappy (e.g. all unhappy white nodes simply pick the first word of $W$). Hence it is sufficient to prove a lower bound for white randomized algorithms.

4.4. Speedup simulation

We will first prove a probabilistic version of Lemma 3.2; the proof follows the same strategy as (Brandt et al., 2016):

Lemma 4.1.

Assume that there exists a white randomized algorithm that solves $\Pi_{\Delta}(x,y)$ in $T\geq 1$ rounds in trees, for $\Delta\geq 2x+y+1$, with local error probability $p\leq 1/4^{\Delta+1}$. Then there exists a white randomized algorithm that solves $\Pi_{\Delta}(x+1,y+x)$ in $T-1$ rounds in trees, with local error probability at most $q=5\Delta p^{\frac{1}{\Delta+1}}$.

To prove the lemma, assume that $A$ is the white randomized algorithm with running time $T$ and local error probability $p$. Let $\alpha\in[0,1]$ be a parameter that we will fix later.

4.4.1. Preliminaries

Let $N(x,r)$ denote the radius-$r$ neighborhood of node $x$. Throughout this section, we will use $u,u^{\prime},u_{i}$ etc. to refer to black nodes and $v,v^{\prime},v_{i}$ etc. to refer to white nodes. For a black node $u$ and a white node $v$ adjacent to $u$, define

[TABLE]

With this notation, the regions in Figure 5 are

[TABLE]

It will be convenient to assume that the port numbering is chosen independently and uniformly at random. If the local error probability is at most $p$ for an adversarial choice of port numbering, it is at most $p$ also for a random port numbering. In what follows, e.g. $U(u)$ refers to all random choices within distance $T-1$ from $u$: both the random bit string given to the nodes and the randomly chosen port numbers.

Definition 4.0 (typical labels).

We say that $x$ is a typical label for edge $\{u,v\}$ w.r.t. $U(u)$ if

[TABLE]

Otherwise the label is atypical.

Note that as long as $\alpha\leq 1/4$, there is always at least one typical label for each edge (recall that the alphabet size is $4$).

Definition 4.0 (lucky neighborhoods).

We say that $U(u)$ is lucky if the following holds: for each edge $\{u,v\}$ we can pick any typical label and this makes node $u$ happy, i.e., any combination of typical labels forms a word in $B_{\Delta}(x,y)$. Otherwise, we call $U(u)$ unlucky.

Lemma 4.4.

The probability that $U(u)$ is unlucky is at most $p/\alpha^{\Delta}$.

Proof.

If $U(u)$ is unlucky, then for each edge $e_{i}=\{u,v_{i}\}$ we can choose a typical edge label $x_{i}$ so that $u$ is unhappy. By definition, given $U(u)$, algorithm $A$ will output $x_{i}$ on edge $e_{i}$ with probability at least $\alpha$, and this only depends on $D(u,v_{i})$. As the regions $D(u,v_{i})$ are independent, we see that $u$ is unhappy with probability at least $\alpha^{\Delta}$.

Let $\beta$ be the probability that $U(u)$ is unlucky. Node $u$ is then unhappy with probability at least $\beta\alpha^{\Delta}$, which is at most $p$ by assumption. ∎

Definition 4.0 (nice neighborhoods).

We say that $V(v)$ is nice if the following holds for each edge $e=\{v,u\}$ incident to $v$: the label assigned by algorithm $A$ to $e$ is a typical label for $\{u,v\}$ w.r.t. $U(u)$. Otherwise $V(v)$ is bad.

Lemma 4.6.

The probability that $V(v)$ is bad is at most $4\Delta\alpha$.

Proof.

There are $\Delta$ edges incident to $v$; let us focus on one of them, say $e=\{v,u\}$. We next analyze the probability that $e$ has an atypical label.

We first fix $U(u)$. Then we see which labels are atypical for $e$ w.r.t. $U(u)$. Now consider each possible label $x$; if $x$ is atypical, then the probability that $A$ outputs $x$ for $e$ given $U(u)$ is less than $\alpha$. Summing over all possible atypical labels (at most $4$) and all possible choices of $U(u)$, the probability that the output of $A$ for $e$ is atypical is at most $4\alpha$.

The claim follows by union bound. ∎

Definition 4.0 (friendly neighborhoods).

We say that $V(v)$ is friendly if:

1. (1)

$V(v)$ is nice, 2. (2)

$U(u)$ is lucky for each black neighbor $u$ of $v$.

Otherwise $V(v)$ is unfriendly.

Lemma 4.8.

The probability that $V(v)$ is unfriendly is at most $\Delta(4\alpha+p/\alpha^{\Delta})$.

Proof.

There are $\Delta+1$ bad events: one possible bad neighborhood, with probability at most $4\Delta\alpha$, and $\Delta$ possible unlucky neighborhoods, each with probability at most $p/\alpha^{\Delta}$. By union bound, we have an unfriendly neighborhood with probability at most $\Delta(4\alpha+p/\alpha^{\Delta})$. ∎

Now if we choose $\alpha=p^{\frac{1}{\Delta+1}}\leq 1/4$, we obtain:

Corollary 4.9.

The probability that $V(v)$ is unfriendly is at most $q=5\Delta p^{\frac{1}{\Delta+1}}$.

4.4.2. Speedup simulation for friendly neighborhoods

We will first look at speedup simulation in friendly neighborhoods. The high-level plan is this:

• •

Speedup simulation is well-defined for each black node $u$ such that $U(u)$ is lucky.

• •

Speedup simulation results in a good output for each white node $v$ such that $V(v)$ is friendly.

Using the notation of Section 3.4, we redefine $A_{1}$ as follows:

Set $S_{i}$ consists of all typical labels for $e_{i}$ w.r.t. $U(u)$.

Let us now look at how to extend algorithms $A_{2}$ to $A_{4}$ and their analysis to the probabilistic setting, assuming a friendly neighborhood:

• •

Algorithm $A_{2}$: The mapping from $15$ sets to $6$ labels is identical to the deterministic version.

• •

Output of $A_{2}$: The analysis holds verbatim, as we assumed that $u$ is lucky and hence any combination of typical labels has to make $u$ happy.

• •

Algorithm $A_{3}$: The mapping from $6$ sets to $4$ labels is identical to the deterministic version.

• •

Algorithm $A_{4}$: The mapping from $4$ labels to $4$ labels is identical to the deterministic version.

• •

Output of $A_{4}$: As we look at a white node in a friendly neighborhood, we know that the output of $A$ is typical, and hence the output of $A$ is contained in the sets of typical labels that $A_{1}$ outputs. The rest of the analysis holds verbatim.

4.4.3. Speedup simulation for all neighborhoods

Let us now address the case of unfriendly neighborhoods. We modify $A_{4}$ so that if node $u$ is unlucky, we produce some arbitrary fixed output from $W_{\Delta}(x+1,y+x)$. This way $A_{4}$ is always well-defined and the output of a black node is always in $W_{\Delta}(x+1,y+x)$.

Furthermore, we know that the labels incident to a white node $v$ are in $B_{\Delta}(x+1,y+x)$ whenever $V(v)$ is friendly, and this happens with probability at least $1-q$. We conclude that $A_{4}$ is a black randomized algorithm that solves $\Pi^{\prime}_{\Delta}(x+1,y+x)$ with local error probability at most $q$.

Finally, we obtain a white randomized algorithm for $\Pi_{\Delta}(x+1,y+x)$ by reversing the roles of white and black nodes. This concludes the proof of Lemma 4.1.

4.5. Multiple speedup steps

By a repeated application of Lemma 4.1, we obtain the following corollary that is analogous to Corollary 3.3:

Corollary 4.10.

Assume that there exists a white randomized algorithm that solves $\Pi_{\Delta}(x,y)$ in $T$ rounds in trees with local error probability $p$, for $\Delta\geq x+y+T(x+1+(T-1)/2)$. Then there is a white randomized algorithm that solves $\Pi_{\Delta}(x^{\prime},y^{\prime})$ in [math] rounds in trees with local error probability $p^{\prime}$ for

[TABLE]

Proof.

Let $p_{i}$ be the local error probability after applying Lemma 4.1 for $i$ times, with $p_{0}=p$ and $p_{T}=p^{\prime}$. We prove by induction that

[TABLE]

The base case is $p_{0}\leq(5\Delta)^{2}p$, which trivially holds. For the inductive step, note that

[TABLE]

4.6. Base case

Lemma 4.11.

There is no white randomized algorithm that solves $\Pi_{\Delta}(x,y)$, for $x,y\leq\Delta/8$ and $\Delta\geq 8$, in [math] rounds in trees with local error probability $p\leq 1/{\Delta^{\Delta}}$.

Proof.

Fix a white randomized algorithm $A$ that runs in [math] rounds. As each white node has no knowledge of their neighborhood, they all have the same probability $q$ to choose the output $\mathsf{M}\mspace{1.0mu}\mathsf{O}^{\Delta-x-1}X^{x}$, and probability $1-q$ to output $\mathsf{P}^{\Delta-x-y}\mspace{1.0mu}\mathsf{O}^{y}\mspace{1.0mu}\mathsf{X}^{x}$. There are two cases:

• •

$q\geq\frac{1}{2}$: Consider a black node $u$ with $\Delta$ white neighbors $v_{1},v_{2},\dotsc,v_{\Delta}$. As the port numbering of $v_{i}$ is chosen uniformly at random, the probability that $v_{i}$ labels the edge $\{v_{i},u\}$ with $\mathsf{M}$ is $q/\Delta\geq 1/(2\Delta)$. Now if the first $x+2$ white neighbors output $\mathsf{M}$ on the connecting edge, node $u$ will be unhappy, and this happens with probability at least

[TABLE]

• •

$q\leq\frac{1}{2}$: Now a black node $u$ is unhappy if all white neighbors produce an output of type $\mathsf{P}^{\Delta-x-y}\mspace{1.0mu}\mathsf{O}^{y}\mspace{1.0mu}\mathsf{X}^{x}$, and furthermore the first $x+y+1$ neighbors output $\mathsf{P}$ on the connecting edge; this happens with probability at least

[TABLE]

4.7. Putting things together

Lemma 4.12.

For a sufficiently large $\Delta$, there is no white algorithm that solves $\Pi_{\Delta}(x,0)$ for $x\leq\sqrt{\Delta}$ in $T\leq\sqrt{\Delta}/16$ rounds in trees with local error probability $p<2^{-\Delta^{2T+2}}$.

Proof.

Assume that $A$ solves $\Pi_{\Delta}(x,0)$ in $T\leq\sqrt{\Delta}/16$ rounds with local error probability $p$. By Corollary 4.10, we obtain a white randomized algorithm $A^{\prime}$ that solves $\Pi_{\Delta}(x^{\prime},y^{\prime})$ in [math] rounds with local error probability $p^{\prime}$, where

[TABLE]

By Lemma 4.11 we have $p^{\prime}>1/\Delta^{\Delta}$ and therefore

[TABLE]

Theorem 4.13.

There exists a constant $c>0$ such that for any $n$ and $\Delta$ large enough satisfying that at least one of $n$ and $\Delta$ is even and $\Delta<n/10$, any algorithm that finds a $\sqrt{\Delta}$-matching in $\Delta$-regular graphs of $n$ nodes with probability at least $1-1/n$ requires at least $c\min\{\sqrt{\Delta},\log_{\Delta}\log n\}$ rounds.

Proof.

Let us assume for a contradiction that for any constant $c>0$ and any positive integers $n_{0}$ and $\Delta_{0}$ there exist $n>n_{0}$ and $\Delta>\Delta_{0}$ satisfying $\Delta<n/10$ such that there is an algorithm that finds a $\sqrt{\Delta}$-matching in $\Delta$-regular graphs of $n$ nodes in less than $c\min\{\sqrt{\Delta},\log_{\Delta}\log n\}$ rounds with probability at least $1-1/n$.

By Lemma 3.6 there is then a white randomized algorithm $A$ that solves $\Pi_{\Delta}(\sqrt{\Delta},0)$ with only an additional constant overhead. Let $\bar{c}$ be the largest $c\leq 0.1$ such that the obtained algorithm $A$ runs in $T<\sqrt{\Delta}/16$ rounds.

We fix $c$ to be the minimum of $\bar{c}$ and the constant $c$ of Lemma 3.9. Then, we fix $\Delta_{0}$ as the minimum value required to apply Lemma 4.12, and $n_{0}$ as the minimum value required to apply Lemma 3.9. We then apply Lemma 3.9 to construct a $\Delta$-regular graph of $n$ nodes that contains a node $v$ such that the radius-$t$ neighborhood of $v$ is isomorphic to a $\Delta$-regular tree, for some $t\geq c\log_{\Delta}n$. Since $T<c\log_{\Delta}\log n\leq t$ and $T<\sqrt{\Delta}/16$, by Lemma 4.12, algorithm $A$ fails in such a neighborhood with probability at least

[TABLE]

Hence the global success probability cannot be $1-1/n$. ∎

Now the same idea as in Theorem 3.8 gives our main result:

Theorem 4.14.

There exists a constant $c>0$ such that for any $n$ and $\Delta$ large enough satisfying that at least one of $n$ and $\Delta$ is even and $\Delta<n/10$, any LOCAL-model algorithm that finds a maximal matching in $\Delta$-regular graphs of $n$ nodes with probability at least $1-1/n$ requires at least $c\min\{\Delta,\log_{\Delta}\log n\}$ rounds.

Note that $\Delta$ and $\log_{\Delta}\log n$ become roughly the same by setting $\Delta\approx\log\log n/\log\log\log n$. Hence, if we consider $\Delta$ to be an upper bound of the maximum degree, we directly get the following.

Corollary 4.15.

Any LOCAL-model algorithm that finds a maximal matching in graphs of maximum degree at most $\Delta$ with probability at least $1-1/n$ requires $\Omega(\min\{\Delta,\log\log n/\log\log\log n\})$ rounds.

The following corollary gives a lower bound for the running time of any algorithm for maximal matching, if we express it solely as a function of $n$.

Corollary 4.16.

Any LOCAL-model algorithm that finds a maximal matching in $\Delta$-regular graphs with probability at least $1-1/n$ requires $\Omega(\log\log n/\log\log\log n)$ rounds.

4.8. Deterministic lower bound via speedup simulation

Our randomized lower bound implies also a stronger deterministic lower bound. The proof is again based on a speedup argument: we show that the existence of a (too) fast deterministic algorithm implies the existence of an even faster deterministic algorithm. Using the simple observation that the randomized complexity of a problem is at most its deterministic complexity, we will then obtain a contradiction with Theorem 4.14. Our proof is similar to Chang et al. (2016, Theorem 6), and the coloring algorithm follows the idea of Barenboim et al. (2016, Remark 3.6).

Theorem 4.17.

There exists a constant $c>0$ such that for any $n$ and $\Delta$ large enough satisfying that at least one of $n$ and $\Delta$ is even and $\Delta<n/10$, any deterministic LOCAL-model algorithm that finds a maximal matching in $\Delta$-regular graphs of $n$ nodes requires at least $c\min\{\Delta,\log_{\Delta}n\}$ rounds.

Proof.

Let us assume for a contradiction that for any constant $c>0$ and any positive integers $N_{0}$ and $\Delta_{0}$ there exist $N>N_{0}$ and $\Delta>\Delta_{0}$ satisfying $\Delta<N/10$ such that there is a deterministic algorithm $A$ that finds a maximal matching in $\Delta$-regular graphs of $N$ nodes in less than $T=c\min\{\Delta,\log_{\Delta}N\}$ rounds. We use this assumption to create a randomized algorithm that violates Theorem 4.14.

Let $\hat{c}$, $N_{0}$, and $\Delta_{0}$ be, respectively, the constant $c$, the minimum size $n$, and the minimum degree $\Delta$, required to apply Theorem 4.14. Let $\bar{c}$ be the minimum of $0.1$ and $\hat{c}$. Let $c=\epsilon\bar{c}$ for some positive constant $\epsilon$ to be fixed later. We get that there exists an algorithm $A$ that finds a maximal matching in $\Delta$-regular graphs of $N$ nodes in less than $T=c\min\{\Delta,\log_{\Delta}N\}$ rounds, for some specific $N>N_{0}$ and $\Delta>\Delta_{0}$. We show how to construct an algorithm $A^{\prime}$ that is able to find a maximal matching in any $\Delta$-regular graphs of $n=2^{N}$ nodes in less than $\epsilon^{-1}T$ rounds. Note that $T=c\min\{\Delta,\log_{\Delta}N\}=c\min\{\Delta,\log_{\Delta}\log n\}$. This implies that we can solve maximal matching on $\Delta$-regular graphs ($\Delta>\Delta_{0}$) of size $n=2^{N}>N_{0}$ in $\epsilon^{-1}T=\bar{c}\min\{\Delta,\log_{\Delta}\log n\}$, a contradiction with Theorem 4.14.

Let $G$ be any $\Delta$-regular graph of $n$ nodes. We show how to simulate $A$ on $G$, for any possible given assignment of unique identifiers in $\{1,\ldots,\operatorname{poly}(n)\}$ for the nodes of $G$. In order to simulate $A$ we need to compute a labeling that locally looks like an assignment of unique identifiers of size $N$, and we need to make sure that each neighborhood contains less than $N$ nodes. We compute an $N$-coloring of $G^{2T+2}$, the $(2T+2)$th power of $G$, using three iterations of Linial’s coloring algorithm (Linial, 1992, Corollary 4.1). This algorithm can be used to color a $k$-colored graph of maximum degree $\bar{\Delta}$ with e.g.

[TABLE]

colors in three rounds. The power graph $G^{2T+2}$ has maximum degree $\bar{\Delta}\leq\Delta^{2T+2}$ and thus we get a coloring of $G^{2T+2}$ with

[TABLE]

colors. Since $T\leq c\log_{\Delta}N$, we see that each $T$-radius neighborhood contains $O(\Delta^{T})<N$ nodes and that the number of colors is less than $N$. The coloring can be computed in time $O(T)$ in the original graph $G$.

Finally we simulate $A$ on the computed coloring. If we look at the radius-$(T+1)$ neighborhood of any node in $G$, the number of nodes is less than $N$, and the coloring looks like an assignment of unique identifiers from $\{1,2,\dotsc,N\}$, and thus the output of $A$ is well defined and correct by a standard argument—see e.g. (Chang et al., 2016, Theorem 6). Furthermore, the simulation of $A$ on $G$ can be done in $T$ rounds. Our simulation runs in $O(T)$ rounds on total.

We can easily transform this deterministic algorithm into a randomized algorithm with the same runtime on the same graph class: in the beginning, each node simply picks a random value from $\{1,2,\dotsc,n^{3}\}$, interprets its value as an identifier, and then runs the deterministic simulation with these identifiers. The picked values are globally unique with probability at least $1-1/n$, guaranteeing that the randomized algorithm is correct w.h.p. As previously stated, the obtained running time gives a contradiction with Theorem 4.14. ∎

By setting $\Delta\approx\log n/\log\log n$ in Theorem 4.17 we directly get the following.

Corollary 4.18.

Any deterministic LOCAL-model algorithm that finds a maximal matching in $\Delta$-regular graphs requires $\Omega(\log n/\log\log n)$ rounds.

If we consider $\Delta$ to be an upper bound of the maximum degree, we directly get the following.

Corollary 4.19.

Any deterministic LOCAL-model algorithm that finds a maximal matching in graphs of maximum degree $\Delta$ requires $\Omega(\min\{\Delta,\log n/\log\log n\})$ rounds.

4.9. Lower bounds for MIS

If we have any algorithm that finds an MIS, we can simulate it in the line graph and obtain an algorithm for MM; the simulation overhead is constant and the increase in the maximum degree is also bounded by a constant factor. We obtain:

Corollary 4.20.

Any LOCAL-model algorithm that finds a maximal independent set in graphs of maximum degree $\Delta$ with probability at least $1-1/n$ requires $\Omega(\min\{\Delta,\log\log n/\log\log\log n\})$ rounds.

Corollary 4.21.

Any deterministic LOCAL-model algorithm that finds a maximal independent set in graphs of maximum degree $\Delta$ requires $\Omega(\min\{\Delta,\log n/\log\log n\})$ rounds.

4.10. Matching upper bounds

Recall the bound from Theorem 4.14: it excludes the possibility of randomized distributed algorithms that find a maximal matching in $o(\Delta)+o(\log\log n/\log\log\log n)$ rounds in general. The first term is optimal in general: there are deterministic and randomized algorithms that find a maximal matching in $O(\Delta)+o(\log\log n/\log\log\log n)$ rounds (Panconesi and Rizzi, 2001). The second term is optimal for randomized MM algorithms in trees: there is a randomized algorithm that finds a maximal matching in trees in $o(\Delta)+O(\log\log n/\log\log\log n)$ rounds (Barenboim et al., 2016, Theorem 7.3). Note that the construction of our lower bounds ensures that they already hold in trees.

5. Discussion

We have learned that the prior algorithms for MM and MIS with a running time of $O(\Delta+\log^{*}n)$ rounds (Panconesi and Rizzi, 2001; Barenboim et al., 2014) are optimal for a wide range of parameters: in order to solve MM or MIS in time $o(\Delta)+g(n)$, we must increase $g(n)$ from $O(\log^{*}n)$ all the way close to $O(\log\log n)$.

A priori, one might have expected that we should be able to achieve a smooth transition for MM algorithms between $O(\Delta+\log^{*}n)$ and $O(\log\Delta+\log^{c}\log n)$, which are the currently best known complexities as a function of $n$ and $\Delta$, respectively. However, this turned out to be not the case. We conjecture that the qualitative gap between $\log^{*}n$ and $\log^{c}\log n$ regions is closely related to similar gaps in the landscape of locally checkable labeling problems (Chang et al., 2016).

5.1. Open questions

After the preliminary conference version of this work, one of the key open questions was related to the complexity of maximal independent set in the region $\Delta\gg\log\log n$, but thanks to the recent work by Rozhoň and Ghaffari (2020), this question is now largely settled. We now know that the maximal independent set problem cannot be much harder to solve than the maximal matching problem.

However, the complexity of vertex coloring and edge coloring is still wide open. Here is one concrete example of a big open question, closely related to the theme of the current work: Is it possible to find a $(\Delta+1)$-vertex coloring in $O(\log\Delta+\log^{*}n)$ rounds, for all $\Delta$?

Several more fine-grained questions related to the complexity of MM still remain: For example, we proved that MM requires $\Omega(\min\{\Delta,\log\log n/\log\log\log n\})$ rounds in trees, even for randomized algorithms, and the dependency on $n$ is also tight in trees (Barenboim et al., 2016). In general graphs the current randomized algorithms take $O(\log\Delta+\log^{c}\log n)$ rounds for $c>1$. A natural open question is whether or not MM in general graphs is strictly harder than MM in trees, if we allow the dependency on $\Delta$ to be $O(\log\Delta)$. Proving such a separation through the speedup simulation technique would require one to be able to handle cycles, which is an interesting open question by itself. Also, when we consider algorithms that take $\operatorname{poly}\log\log n$ rounds as a function of $n$, there is a gap in the complexity as a function of $\Delta$: the current lower bound is $\Omega(\log\Delta/\log\log\Delta)$, while the upper bound is $O(\log\Delta)$; it is wide open whether the speedup simulation technique is applicable in the study of such questions.

5.2. Recent follow-up work

Computers played a key role in the present work especially in the discovery of an appropriate problem family (2): speedup simulation is a fairly laborious but mechanical process and hence well suited to be automated. The computer program that we used to help us with this project has been now further developed into a freely available open-source web application known as Round Eliminator (Olivetti, 2020), and it has already been used to assist in the discovery of several other lower and upper bounds, see e.g. (Balliu et al., 2020b; Brandt and Olivetti, 2020; Balliu et al., 2020a).

Recent work has also led to an even more fine-grained characterization of the distributed computational complexity of maximal matchings. Recall the trivial algorithm for bipartite maximal matching from Section 3; one can verify that the round complexity of the algorithm is exactly $2\Delta-1$. While the present work showed that this is asymptotically optimal, the latest follow-up work (Brandt and Olivetti, 2020) showed that this is exactly optimal: the problem cannot be solved in $2\Delta-2$ rounds.

Acknowledgements.

This work is an extended and revised version of a preliminary conference report that appeared in the 60th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2019). We would like to thank Mohsen Ghaffari for pointing out that the randomized lower bound implies a better deterministic lower bound, and Seth Pettie for pointing out that the bound is tight for trees, as well as for many other helpful comments. Many thanks also to Laurent Feuilloley and Tuomo Lempiäinen for comments and discussions, and to the reviewers of the previous versions of this work for their numerous helpful suggestions. This work was supported in part by the Academy of Finland, Grants 285721 and 314888 and the Project ESTATE (ANR-16-CE25-0009-03).