Locality of not-so-weak coloring

TL;DR

This paper investigates the distributed complexity of defective graph colorings, revealing that certain partial colorings transition from easy to hard at specific parameters, with new results for cases where the number of colors is less than four.

Contribution

It establishes the complexity thresholds for k-partial 2-coloring and 3-coloring problems in bounded-degree graphs, filling gaps in understanding for small color counts.

Findings

k-partial 2-coloring is hard for k ≥ 2 regardless of degree

k-partial 3-coloring is hard at degree d = k but easy when d >> k

Partial coloring with fewer than four colors exhibits distinct complexity behaviors

Abstract

Many graph problems are locally checkable: a solution is globally feasible if it looks valid in all constant-radius neighborhoods. This idea is formalized in the concept of locally checkable labelings (LCLs), introduced by Naor and Stockmeyer (1995). Recently, Chang et al. (2016) showed that in bounded-degree graphs, every LCL problem belongs to one of the following classes: - "Easy": solvable in $O(\log^* n)$ rounds with both deterministic and randomized distributed algorithms. - "Hard": requires at least $\Omega(\log n)$ rounds with deterministic and $\Omega(\log \log n)$ rounds with randomized distributed algorithms. Hence for any parameterized LCL problem, when we move from local problems towards global problems, there is some point at which complexity suddenly jumps from easy to hard. For example, for vertex coloring in $d$-regular graphs it is now known that this jump is at precisely $d$ colors: coloring with $d+1$ colors is easy, while coloring with $d$ colors is hard. However, it is currently poorly understood where this jump takes place when one looks at defective colorings. To study this question, we define $k$-partial $c$-coloring as follows: nodes are labeled with numbers between $1$ and $c$, and every node is incident to at least $k$ properly colored edges. It is known that $1$-partial $2$-coloring (a.k.a. weak $2$-coloring) is easy for any $d \ge 1$. As our main result, we show that $k$-partial $2$-coloring becomes hard as soon as $k \ge 2$, no matter how large a $d$ we have. We also show that this is fundamentally different from $k$-partial $3$-coloring: no matter which $k \ge 3$ we choose, the problem is always hard for $d = k$ but it becomes easy when $d \gg k$. The same was known previously for partial $c$-coloring with $c \ge 4$, but the case of $c < 4$ was open.

Tables

Table 1. Table 1: An overview of k 𝑘 k -partial c 𝑐 c -coloring in d 𝑑 d -regular graphs: for each k 𝑘 k and c 𝑐 c , the table shows what is the smallest d 𝑑 d such that the problem is easy. For example, “ 4 ​ … ​ 5 4 … 5 4\ldots 5 ” means that for these parameters the problem is known to be easy in 5 5 5 -regular graphs, while the case of 4 4 4 -regular graphs is unknown. The new results are highlighted with a frame. Our main contributions are the new lower bounds for c = 2 𝑐 2 c=2 (Theorem  3 ) and upper bounds for c = 3 𝑐 3 c=3 (Theorem  2 ), which were previously completely open. We also obtain stronger lower bounds for e.g.  c = 3 𝑐 3 c=3 , k ≥ 5 𝑘 5 k\geq 5 (Theorem  7 ) and stronger upper bounds for c = k ≥ 4 𝑐 𝑘 4 c=k\geq 4 (Theorem  2 ).

(a) Before this work:

(b) After this work:

$c=2$

$c=3$

$c=4$

$c=5$

$c=2$

$c=3$

$c=4$

$c=5$

$k=1$:

$1$

$1$

$1$

$1$

$1$

$1$

$1$

$1$

$2$:

$\mathrm{\hspace{0.17em}3}$

$\dots \infty$

$2$

$2$

$2$

$\infty$

$2$

$2$

$2$

$3$:

$\mathrm{\hspace{0.17em}4}$

$\dots \infty$

$\mathrm{\hspace{0.17em}4}$

$\dots \infty$

$3$

$3$

$\infty$

$\mathrm{\hspace{0.17em}4}$

$\dots 5$

$3$

$3$

$4$:

$\mathrm{\hspace{0.17em}5}$

$\dots \infty$

$\mathrm{\hspace{0.17em}5}$

$\dots \infty$

$\mathrm{\hspace{0.17em}5}$

$\dots 7$

$4$

$\infty$

$\mathrm{\hspace{0.17em}5}$

$\dots 8$

$\mathrm{\hspace{0.17em}5}$

$\dots 6$

$4$

$5$:

$\mathrm{\hspace{0.17em}6}$

$\dots \infty$

$\mathrm{\hspace{0.17em}6}$

$\dots \infty$

$\mathrm{\hspace{0.17em}6}$

$\dots 9$

$\mathrm{\hspace{0.17em}6}$

$\dots 9$

$\infty$

$7$

$\dots 11$

$\mathrm{\hspace{0.17em}6}$

$\dots 9$

$\mathrm{\hspace{0.17em}6}$

$\dots 7$

$6$:

$\mathrm{\hspace{0.17em}7}$

$\dots \infty$

$\mathrm{\hspace{0.17em}7}$

$\dots \infty$

$\mathrm{\hspace{0.17em}7}$

$\dots 11$

$\mathrm{\hspace{0.17em}7}$

$\dots 11$

$\infty$

$8$

$\dots 14$

$\mathrm{\hspace{0.17em}7}$

$\dots 11$

$\mathrm{\hspace{0.17em}7}$

$\dots 11$

$7$:

$\mathrm{\hspace{0.17em}8}$

$\dots \infty$

$\mathrm{\hspace{0.17em}8}$

$\dots \infty$

$\mathrm{\hspace{0.17em}8}$

$\dots 13$

$\mathrm{\hspace{0.17em}8}$

$\dots 13$

$\infty$

$10$

$\dots 17$

$9$

$\dots 13$

$\mathrm{\hspace{0.17em}8}$

$\dots 13$

Equations

$$t+y+z$$

$$x+y$$

$$y$$

$$\text{mbox}andd$$

$$d\le 2t+x+y+z\le 2(k-1)-y-z+x\le 3(k-1)-2y-z\le 3k-5.$$

$$d=r+t+x+y+z\ge d-k+f+y+3\ge d+1,$$

$$t+y+z$$

$$x+y$$

$$y$$

$$\text{mbox}andr$$

$$\begin{array}{rl}(k-2)d& \le (k-1)(t+x+y+z)-y\le (k-1{)}^2+(k-1)(x+y)-ky\\ & \le 2(k-1{)}^2-k(k-2)=k^2-2k+2,\end{array}$$

Full text

• Locality of not-so-weak coloring

Alkida Balliu  $\cdot$  alkida.balliu@aalto.fi  $\cdot$  Aalto University

Juho Hirvonen  $\cdot$  juho.hirvonen@aalto.fi  $\cdot$  Aalto University

Christoph Lenzen  $\cdot$  clenzen@mpi-inf.mpg.de  $\cdot$  Max Planck Institute for Informatics

Dennis Olivetti  $\cdot$  dennis.olivetti@aalto.fi  $\cdot$  Aalto University

Jukka Suomela  $\cdot$  jukka.suomela@aalto.fi  $\cdot$  Aalto University

• Abstract. Many graph problems are locally checkable: a solution is globally feasible if it looks valid in all constant-radius neighborhoods. This idea is formalized in the concept of locally checkable labelings (LCLs), introduced by Naor and Stockmeyer (1995). Recently, Chang et al. (2016) showed that in bounded-degree graphs, every LCL problem belongs to one of the following classes:

• –

“Easy”: solvable in $O(\log^{*}n)$ rounds with both deterministic and randomized distributed algorithms.

• –

“Hard”: requires at least $\Omega(\log n)$ rounds with deterministic and $\Omega(\log\log n)$ rounds with randomized distributed algorithms.

Hence for any parameterized LCL problem, when we move from local problems towards global problems, there is some point at which complexity suddenly jumps from easy to hard. For example, for vertex coloring in $d$-regular graphs it is now known that this jump is at precisely $d$ colors: coloring with $d+1$ colors is easy, while coloring with $d$ colors is hard.

However, it is currently poorly understood where this jump takes place when one looks at defective colorings. To study this question, we define $k$-partial $c$-coloring as follows: nodes are labeled with numbers between $1$ and $c$, and every node is incident to at least $k$ properly colored edges.

It is known that $1$-partial $2$-coloring (a.k.a. weak $2$-coloring) is easy for any $d\geq 1$. As our main result, we show that $k$-partial $2$-coloring becomes hard as soon as $k\geq 2$, no matter how large a $d$ we have.

We also show that this is fundamentally different from $k$-partial $3$-coloring: no matter which $k\geq 3$ we choose, the problem is always hard for $d=k$ but it becomes easy when $d\gg k$. The same was known previously for partial $c$-coloring with $c\geq 4$, but the case of $c<4$ was open.

1 Introduction

There is a broad family of graph problems—so-called locally checkable labelings or LCLs [20]—that exhibits the following dichotomy [9]: either the problem can be solved in $O(\log^{*}n)$ rounds with deterministic distributed algorithms, or any such algorithm requires at least $\Omega(\log n)$ rounds.

Hence, for any parameterized LCL problem there is a sudden jump in complexity, from $O(\log^{*}n)$, which is a very slowly-growing function of $n$, to $\Omega(\log n)$, which can be already as much as the diameter of the network. We will call these two cases “easy” and “hard” from now on.

If we look at $d$-regular graphs for constant $d=O(1)$, then by prior work the following thresholds are known [21, 12, 6, 9]:

• •

Proper vertex coloring with $c$ colors: easy for $c\geq d+1$, hard for $c\leq d$.

• •

Proper edge coloring with $c$ colors: easy for $c\geq 2d-1$, hard for $c\leq 2d-2$.

Here the easy cases are exactly those cases that can be solved with a greedy algorithm that picks the colors of the nodes or edges one by one; a straightforward parallelization of this idea then gives an $O(\log^{*}n)$-round distributed algorithm.

In this work, we study colorings that are not necessarily proper:

Definition 1**.**

Let $G=(V,E)$ be a graph. Mapping $f\colon V\to\{1,2,\dotsc,c\}$ is a $k$-partial $c$-coloring if for each node $v\in V$, there are at least $k$ neighbors $u$ of $v$ with $f(u)\neq f(v)$.

By prior work on defective colorings, it is known that e.g. $k$-partial $4$-coloring is hard if $d=k\geq 4$ and easy if $d\gg k$. However, very little was known about partial $2$-coloring and $3$-coloring. In this work we complete the picture and show that the case of $c=2$ is very different from the case $c\geq 3$:

• •

$k$-partial $2$-coloring for any $k\geq 2$ is always hard, no matter how large a $d$ we have,

• •

$k$-partial $3$-coloring for any $k\geq 3$ is hard for $d=k$ but it becomes easy when $d\gg k$.

We summarize our contributions in Table 1.

2 Preliminaries and related work

2.1 LOCAL model of computing

We work in the usual LOCAL model of distributed computing [18, 22]. Each node of the input graph $G=(V,E)$ is a computer and each edge is a communication link. Computation proceeds in rounds: in one round each node can exchange a message (of any size) with each of its neighbors. Initially each node knows only $n=|V|$, and when a node stops, it has to produce its own part of the output—in our case, its own color from $\{1,2,\dotsc,c\}$. We say that an algorithm runs in time $T$ if after $T$ rounds all nodes stop and announce their local outputs.

When we study deterministic algorithms, we assume that each node is labeled with a unique identifier from $\{1,2,\dotsc,n^{O(1)}\}$. When we study randomized algorithms, we assume that each node has an unlimited source of random bits. For a randomized algorithm, we require that it solves the problem correctly with high probability, i.e., with probability at least $1-n^{-c}$ for an arbitrary, but predetermined constant $c>0$.

Note that if a problem is solvable in $T$ rounds in the LOCAL model, it also means that each node can produce its own part of the solution based on the information that is available in its radius-$T$ neighborhood.

2.2 LCL problems and gap theorems

LCL problems were introduced by Naor and Stockmeyer [20] in 1995. In an LCL problem, the input is a graph $G=(V,E)$ of maximum degree $\Delta=O(1)$, possibly labeled with some node labels from a constant-size set $X$. The task is to find a labeling $f\colon V\to Y$, for some constant-size set $Y$, that satisfies some local constraints—a labeling is globally feasible if it is feasible in all constant-radius neighborhoods.

For our purposes it is enough to note that $k$-partial $c$-coloring in $d$-regular graphs is an LCL problem, for any choice of constants $k,c,d=O(1)$. Hence also everything that we know about LCLs applies here.

In the past four years, we have seen a lot of progress in understanding the computational complexity of LCL problems in the LOCAL model [2, 1, 6, 9, 8, 13, 14, 15, 16, 10, 7]. For us, the most relevant result is the gap theorem by Chang et al. [9]. They show that every LCL problems belongs to one of the following classes, which we will here informally call “easy” and “hard”

“Easy”:

solvable in $O(\log^{*}n)$ rounds with both deterministic and randomized algorithms.

“Hard”:

requires $\Omega(\log n)$ rounds with deterministic algorithms and $\Omega(\log\log n)$ rounds with randomized algorithms.

In this work, our main goal is to understand for what values of $k,c,d$ the problem of finding $k$-partial $c$-coloring in $d$-regular graphs is “hard” and when it is “easy”. While we will focus on the case of $d$-regular graphs, most of the results directly generalize to the case of graphs of minimum degree $d$ (and maximum degree some constant $\Delta$).

2.3 Prior work related to partial colorings

Notes on terminology.

In $d$-regular graphs, a $k$-partial $c$-coloring is exactly the same thing as a $(d-k)$-defective $c$-coloring [3, Sect. 6]. While defective colorings are more commonly discussed in prior work, for our purposes the concept of a partial coloring is much more convenient, as we will often fix $c$ and $k$ and see what happens when $d$ increases.

Our definition is in essence equal to $k$-partially proper colorings used by Kuhn [17]; for brevity, we call these partial colorings.

Weak coloring, $k=1$.

In graphs without isolated nodes, a $1$-partial $c$-coloring is identical to a weak $c$-coloring [20]. Weak $2$-coloring can be solved in $O(\log^{*}n)$ rounds: find a maximal independent set $X\subseteq V$ using e.g. [21, 12]; then color all nodes of $X$ with color $1$ and all other nodes with color $2$. Naturally, this also gives a solution for weak $c$-coloring for any $c\geq 2$. Furthermore, this upper bound is tight: a weak $2$-coloring breaks symmetry everywhere in a regular grid, and the usual lower bounds [18, 19, 20] apply.

Weak coloring corresponds to the first row of Table 1.

Partial coloring for $k<c$.

Above we have seen that we can find a $1$-partial $2$-coloring by simply finding a maximal independent set (MIS). The same idea can be generalized to $(c-1)$-partial $c$-coloring for $k=c-1$: Find an MIS $X_{1}$, label $X_{1}$ with color $1$, and remove $X_{1}$. Find an MIS $X_{2}$, label $X_{2}$ with color $2$, and remove $X_{2}$, etc. We continue this for $c-1$ steps and finally label all remaining nodes with color $c$.

The region where this simple (folklore?) strategy works is indicated with green color in Table 1.

Proper vertex coloring, $k=d$.

In $d$-regular graphs, a $d$-partial $c$-coloring is a proper $c$-coloring. Recall that proper coloring with $d+1$ colors is easy [21, 12], while proper coloring with $d$ colors is known to be hard [6, 9].

Hardness of proper $d$-coloring implies the lower bounds in the blue and gray regions of Table 1a.

Partial coloring for $c\geq 4$.

Barenboim et al. [4] gave an algorithm that computes a $\lfloor d/p\rfloor$-defective $p^{2}$-coloring in time $O(\log^{*}n)$, which is essentially a defective variant of Linial’s $O(\Delta^{2})$-coloring algorithm [18]. This algorithm requires at least $4$ colors, and for the case $c=4$ it translates to a $\lceil d/2\rceil$-partial $4$-coloring. For example, $4$-partial $4$-coloring is therefore easy in $7$-regular graphs, and $5$-partial $4$-coloring is easy in $9$-regular graphs.

This algorithm gives the upper bounds in the blue region of Table 1a.

Partial coloring for $c\leq 3$.

To our knowledge, no $O(\log^{*}n)$-time algorithms are known for $k$-partial $c$-coloring for $c\leq 3$, $k\geq c$. In particular, it is not known if the problem becomes easy in $d$-regular graphs for sufficiently large values of $d\gg k$.

This unknown region is indicated with a gray shading in Table 1a.

Algorithms based on Lovász local lemma.

Chung et al. [11], Fischer and Ghaffari [13], and Ghaffari et al. [15, full version] present algorithms for defective coloring (and hence for partial coloring) that are based on the following idea: formulate a defective coloring as an instance of the Lovász local lemma (LLL), and then apply efficient distributed algorithms for LLL.

Unfortunately, this approach is unlikely to lead to an $O(\log^{*}n)$-time algorithm; LLL is known to be a hard problem for a wide range of parameters [6].

Other algorithms.

Bonamy et al. [5] shows that there is an $O(\log n)$-round algorithm for trees that finds an MIS $X$ such that every component induced by non-MIS nodes is of size one or two. This can be interpreted as an algorithm for partial $2$-coloring.

However, this approach cannot lead to an $O(\log^{*}n)$-time algorithm, either: if we color the MIS-nodes with color $1$ and the non-MIS nodes with colors $2$ and $3$, we obtain a proper $3$-coloring, and finding a $3$-coloring in $3$-regular trees is known to be a hard problem [6].

3 Our contributions

To recap, by prior work, we have a good qualitative understanding of $k$-partial $c$-coloring for $c\geq 4$:

• •

$k<c$: easy for all $d\geq k$.

• •

$k\geq c$: hard for $d=k$ but easy for $d\gg k$.

We complete the picture for $c\leq 3$. For $c=3$, we have precisely the same situation as above:

• •

$k<c$: easy for all $d\geq k$.

• •

$k\geq c$: hard for $d=k$ but easy for $d\gg k$.

However, the case of $c=2$ is fundamentally different:

• •

$k<c$: easy for all $d\geq k$.

• •

$k\geq c$: hard for all values of $d$.

3.1 Corollary: locally optimal cuts

Any partial $2$-coloring can be interpreted as a cut; the properly colored edges are cut edges, and the size of the cut is the number of cut edges. Let us look at the problem of maximizing the size of a cut with a simple greedy strategy: start with any cut and change the color of a node if it increases the size of the cut. The process will converge to a locally optimal cut, in which changing the color of any single node does not help.

Now a locally optimal cut in $d$-regular graphs is precisely the same thing as a $\lceil d/2\rceil$-partial $2$-coloring. For example, in $3$-regular graphs, any $2$-partial $2$-coloring is also a locally optimal cut, and vice versa.

Locally optimal cuts are easy to find in a centralized, sequential setting. However, previously it was not known if locally optimal cuts can be found efficiently in a distributed setting. As a corollary of our work, we now know that this is a hard problem.

3.2 Key techniques

Upper bound for 3-coloring.

Prior algorithms for e.g. partial $4$-coloring are based on the idea of organizing nodes in layers and doing two sweeps [4]: top to bottom, using colors from palette $A=\{1,2\}$, and bottom to top using colors from palette $B=\{1,2\}$. This way we eventually have a $4$-coloring with colors from $A\times B=\{(1,1),(1,2),(2,1),(2,2)\}$. This idea generalizes easily to e.g. $6,8,9,\dotsc$ colors, but it is not possible to use this idea to find a useful coloring with less than $4$ colors.

We show how to do two sweeps so that the end result is only $3$ colors. In brief, the first sweep uses tentative colors from palette $\{1,2\}$, and the second sweep finalizes the colors, depending on the tentative colors that we chose in the first step. Here the second sweep depends on the result of the first sweep, while in prior algorithms the two sweeps are independent.

Lower bound for 2-coloring.

We show that $2$-partial $2$-coloring in $d$-regular graphs for any constant $d$ is at least as hard to solve as sinkless orientation, which is known to be hard [6]. The key obstacle here is that sinkless orientation is known to be hard even if we are given a proper $2$-coloring of the graph, so how could a partial $2$-coloring help with it?

The basic idea is as follows: Assume we have a fast algorithm $A_{1}$ that finds a $2$-partial $2$-coloring in $d_{1}$-regular graphs. Then we can construct algorithm $A_{2}$ that finds a sinkless orientation in $d_{2}$-regular graphs, for a certain constant $d_{2}\gg d_{1}$ that depends on the exact running time of $A_{1}$. Given a $d_{2}$-regular graph $G_{2}$, algorithm $A_{2}$ first replaces all nodes with appropriate gadgets to obtain a $d_{1}$-regular graph $G_{1}$, applies $A_{1}$ to $G_{1}$, and extracts enough information from the partial coloring so that it can find a sinkless orientation. But sinkless orientation is hard also in $d_{2}$-regular graphs, no matter how large a constant $d_{2}$ is.

4 Partial colorings with more than two colors

In this section we analyze the distributed complexity of $k$-partial $c$-coloring in the case where $c$ is at least $3$. More formally, we will prove the following theorem.

Theorem 2**.**

There exists an algorithm running in $O(\log^{*}n)$ that is able to compute:

• •

A $k$-partial $3$-coloring, if $d\geq 3k-4$ and $k\geq 3$;

• •

A $k$-partial $k$-coloring, if $d\geq k+2$ and $k\geq 4$.

In order to prove the theorem, we start by providing an algorithm, and then we will analyze it for the two cases separately.

The algorithm.

The algorithm that we propose is inspired by the procedure Refine in [3, Sect. 6]. This procedure starts by first finding an acyclic partial orientation, and then assigns two colors for each node by exploiting the two possible orders given by the orientation. It finally combines the two colors to determine the output color. Our algorithm starts in the same way, but it does not compute two independent colors, allowing us to be slightly more efficient in some cases.

We start by finding an acyclic partial orientation of the edges. That is, we first compute an $O(d^{2})$ coloring in $O(\log^{*}n)$ rounds. Then, we assign a total order to the colors, and we orient the edges from the node with the smaller color to the node with the bigger one. The obtained directed graph is clearly acyclic, and all directed paths are of length at most $O(d^{2})$. Nodes reachable from $v$ through outgoing edges are considered to be above $v$, while the others are considered to be below $v$.

Now, we do two “sweeps” on the obtained acyclic graph, that is, we first process the nodes from above to below, and then we process them in the reverse order. More precisely, we start by processing the sinks, and then we continue by processing all nodes such that all of the nodes above them have already been processed. This is iterated until all nodes have been processed. Then, we repeat the same procedure in reverse order, i.e., from below to above. Each sweep takes $O(d^{2})$ rounds.

During the first sweep, we assign to each node $v$ a temporary color, by choosing the color that is the least used one among the neighbors above $v$. Crucially, during this phase, the choice is not among the full palette, but only colors from $1$ to $c-1$ are allowed. We call color $c$ the special color. During the second sweep, each node $v$ has three options:

• •

Keep the current color.

• •

Choose to switch to color $c$.

• •

Choose to switch to a color from $1$ to $c-1$. This option is allowed only if no neighbor below $v$ is currently using that color.

Different choices give different guarantees. For example, by choosing to not change the color, or by choosing to switch to a color from $1$ to $c-1$, node $v$ is ensured that the number of properly colored neighbors does not decrease when the nodes above it will be processed. This property is guaranteed by the fact that a node can switch to a color in $\{1,\ldots,c-1\}$ only if no node below it is using that color. On the other hand, a node may switch to color $c$ even if some neighbor below it is using color $c$ as well, but then it loses any guarantee about the nodes above it, which may all decide to switch to color $c$. See Figure 1 for an example of the execution of the algorithm.

The algorithm will make a choice that guarantees that $k$ neighbors have different color, regardless of whether the nodes above change their color (subject to the above rules) or not. Accordingly, our task is to prove that such a choice always exists, provided that $d$ is large enough.

$k$-partial 3-coloring.

We now show that the above described algorithm is able to compute a $k$-partial $3$-coloring if $d\geq 3k-4$ and $k\geq 3$. In order to analyze the algorithm running on node $v$, assume without loss of generality that during the first sweep, $v$ picks color $1$ and $t$ nodes above $v$ chose color $2$. Note that there are no more than $t$ other nodes above $v$, as $v$ picked the color out of $\{1,2\}$ that was least used by the nodes above it in the first sweep. Denote by $x,y,z\geq 0$ the numbers of nodes below $v$ that are colored $1$, $2$, and $3$, respectively, after making their final choice in the second sweep. Thus, the number of nodes above $v$ that chose $1$ in their first sweep equals $d-t-x-y-z\leq t$.

We make a case distinction.

$t+y+z\geq k$. Thus, $v$ can keep color $1$, as the $t$ nodes above it that have color $2$ must then choose a color different from $1$. 2. 2.

$x+y\geq k$. Then $v$ can safely choose color $3$. 3. 3.

$y=0$ and none of the other cases apply. Thus, $v$ is free to switch to color $2$. If it does so, it has $x+z$ nodes of different color below, and $d-t-x-z$ nodes above that choose a different color than $2$. As the first case does not apply and $k\geq 3$, these are at least $d-t\geq d-(k-1)\geq 2k-3\geq k$ nodes. Hence, switching to color $2$ is indeed a valid choice.

Hence, it suffices to show that one of the cases must apply. Assume for contradiction that this is false. Thus,

[TABLE]

yielding the contradiction that

[TABLE]

$k$-partial $k$-coloring.

We now show that the above described algorithm is able to compute a $k$-partial $k$-coloring if $d\geq k+2$ and $k\geq 4$. We analyze this case similarly to the case before. Let $t$ be the number of nodes above $v$ of color different from $v$ after the first sweep. Without loss of generality, assume that the color of $v$ is $1$, and the special color is $k$. Let $x$, $y$, and $z$ be the number of nodes below $v$ colored with $1$, with color $c$ such that $2\leq c\leq k-1$, and with color $k$, respectively. Recall that only colors from $1$ to $k-1$ are allowed during the first sweep. As $v$ chooses a minority color among its above neighbors’ choices, we have $r:=d-t-x-y-z\leq t/(k-2)$ remaining nodes above $v$ that choose color $1$ in the first sweep.

Let us analyze the second sweep. We make a case distinction.

$t+y+z\geq k$. Then $v$ can keep color $1$. 2. 2.

$x+y\geq k$. Then $v$ can safely choose color $k$. 3. 3.

There are $f>0$ “free” colors from $\{2,\ldots,k-1\}$ that no neighbor below $v$ chose and none of the other cases applies. If a free color was picked by at most $d-k$ above neighbors of $v$, it may select it with the guarantee that its other $k$ neighbors end up with a different color.

Assuming for contradiction that there is no such free color, observe that the least used free color was picked by at most $\lfloor t/f\rfloor$ neighbors above $v$ in the first sweep. Accordingly, $t\geq f(d-k+1)\geq d-k+f$. Moreover, clearly $f\geq k-2-y$ and, because the first case does not apply, $x+r=d-t-y-z\geq d-(k-1)\geq 3$. Thus, we can lower bound the total number of neighbors of $v$ by

[TABLE]

a contradiction. Therefore, one of the free colors is a valid choice for $v$.

Hence, there is indeed always a valid choice if we can show that the above case distinction is exhaustive. Assuming otherwise, collecting inequalities from the cases and the earlier bound on $r$ we obtain that

[TABLE]

Together, this implies

[TABLE]

yielding the contradiction that $d\leq k+2/(k-2)<k+2$ (using that $k\geq 4$).

5 Two-partial two-coloring

In this section, we show that, in the LOCAL model, $2$-partial $2$-coloring requires $\Omega(\log n)$ deterministic time and $\Omega(\log\log n)$ randomized time in any $d$-regular tree, where $d\geq 2$. We show the result by reducing from the sinkless orientation problem, for which we know that its distributed deterministic complexity is $\omega(\log^{*}n)$ rounds in the LOCAL model.

Informally, the proof proceeds in two steps. We first show that, if we can solve 2-partial 2-coloring in constant time in a slightly modified version of the LOCAL model, which we call DC-LOCAL model, then we can solve sinkless orientation in the LOCAL model in $O(\log^{*}n)$ rounds. Subsequently, we show that, if we can solve an LCL problem $P$ in $O(\log^{*}n)$ rounds in the LOCAL model, then we can solve $P$ in the DC-LOCAL model in constant time using a simulation similar to that of Chang et al. [9]. Therefore no $O(\log^{*}n)$-round algorithm exists, i.e., the problem is not easy and hence it has to be hard, i.e., it requires $\Omega(\log n)$ deterministic time and $\Omega(\log\log n)$ randomized time.

Theorem 3**.**

Computing a $2$-partial $2$-coloring in $d$-regular trees in the LOCAL model requires $\Omega(\log n)$ deterministic time and $\Omega(\log\log n)$ randomized time, for any $d\geq 2$.

DC-LOCAL model.

Consider the usual LOCAL model with the following modification. Instead of having unique identifiers, nodes are given as input a color from a palette of $c$ colors, and this coloring of the nodes guarantees a distance-$k$ coloring of the graph. In other words, each node sees different colors in its distance-$k$ ball, but it may see repeated colors in its distance-$(k+1)$ ball. We call this model DC-LOCAL$(k,c)$ (where $\sf{DC}$ stands for distance coloring).

5.1 A lower bound for the DC-LOCAL model

In this section, we show that $2$-partial $2$-coloring in $d$-regular trees is not solvable in $k=O(1)$ rounds in the DC-LOCAL$(k+1,d^{2(k+1)})$ model. We show this by reducing from the sinkless orientation problem in $2$-colored trees in the LOCAL model. More precisely, we show that, if there is an algorithm $A$ solving $2$-partial $2$-coloring in time $k=O(1)$ in the DC-LOCAL model, then we can use it to design an $O(\log^{*}n)$-round algorithm that solves sinkless orientation in $2$-colored trees in the LOCAL model. This would give an $\omega(1)$ lower bound for $2$-partial $2$-coloring in the DC-LOCAL model, since we know that sinkless orientation requires $\Omega(\log n)$ rounds, even in $2$-colored trees, in the LOCAL model [10].

Gadgets.

Let $A$ be the algorithm that solves $2$-partial $2$-coloring in time $k=O(1)$ rounds in $d$-regular trees in the DC-LOCAL\bigl{(}k+1,d^{2(k+1)}\bigr{)} model. We introduce two gadgets that we will use later for proving the lower bound. Let $T$ be an arbitrarily distance-$(k+1)$ colored $d$-regular tree of depth $k+3$, and let $u$ be the root of $T$. We run algorithm $A$ on $u$ and on each of its neighbors $v\in N(u)$. We denote with $A(v)$ the output of algorithm $A$ on a node $v$. Notice that $A(v)$ is well-defined on these nodes, since their $k$-radius ball is properly distance-$k$ colored and fully contained in $T$. Since algorithm $A$ solves $2$-partial $2$-coloring, we are sure that there are two nodes $v,z\in N(u)$ such that $A(u)\neq A(v)=A(z)$. Let $b\in\{u,v,z\}$ be a node for which $A$ outputs “black” and $w\in\{u,v,z\}$ be a node for which $A$ outputs “white”. Let $T_{w}$ and $T_{b}$ be the subtrees of depth $k$ rooted at $w$ and $b$ respectively: these are our gadgets (see Figure 2 for an example). The gadgets $T_{w}$ and $T_{b}$ satisfy the following property.

Property 4**.**

Let $c\in\{\mbox{black, white}\}$ be the color of the root of the gadget and let $\bar{c}$ be the opposite color. Among all nodes at distance $2t$ from the root of the gadget, there must be at least one node for which the algorithm outputs color $c$.

Proof.

Assume that $A$ outputs $\bar{c}$ at all nodes at distance $2t$ from the root. Then all nodes at distance $2t-1$ must have color $c$ in order to guarantee a $2$-proper $2$-coloring. This would imply that all nodes at distance $2t-2$ have color $\bar{c}$. By applying this reasoning recursively, we conclude that the root must have color $\bar{c}$, which is a contradiction. ∎

Reduction.

We now show that if there exists an algorithm $A$ that solves $2$-partial $2$-coloring in time $k=O(1)$ rounds (where $k$ is even) in $d$-regular trees in the DC-LOCAL\bigl{(}k+1,d^{2(k+1)}\bigr{)} model, then we can design an algorithm $A^{\prime}$ that solves sinkless orientation on trees of degree $\Delta=d^{2k}$ in which a $2$-coloring of the tree is given, in $O(\log^{*}n)$ rounds in the LOCAL model.

Consider a $\Delta$-regular $2$-colored tree $B=(V\cup U,E)$, where $V$ and $U$ represent the set of nodes belonging to the two color classes. We construct a virtual tree in the following way. Each node $x\in V\cup U$ pretends to be the root of a $d$-regular tree of depth $2k$. We call this tree \mathsf{T_{virt}}$$(x). Then, each node $v\in V$ (resp. $u\in U$) labels the nodes at distance at most $k$ with the same colors of the nodes of the gadget $T_{w}$ (resp. $T_{b}$). Note that this is possible since $T_{w}$ and $T_{b}$ are isomorphic to the subgraph induced by the nodes at distance at most $k$ from $v$ and $u$. Then, we merge the $i$-th leaf of \mathsf{T_{virt}}$$(v) with the $j$-th leaf of \mathsf{T_{virt}}$$(u) if and only if there is an edge $\{v,u\}$ connecting $v$ and $u$ through port $i$ of $v$ and port $j$ of $u$. We call this node $m_{u,v}$ (merged node). In order to make the graph $d$-regular, we attach additional $d-2$ virtual nodes to each merged node. Note that, since the original tree $B$ is $\Delta$-regular, and since each virtual tree $\mathsf{T_{virt}}$ has $\Delta$ leaves, then all the leaves of $\mathsf{T_{virt}}$ are merged nodes (except for the case in which the original node is a leaf, where just one leaf of $\mathsf{T_{virt}}$ is merged). We then color the nodes that are still uncolored, that is, nodes at distance more than $k$ from the root of the virtual trees, using a distance-$k$ coloring algorithm. Since the already colored parts are far enough apart, this can be done efficiently, in $O(\log^{*}n)$ rounds.

Now, each node $v$ in $B$ simulates the $k$-round algorithm $A$ on all nodes of $\mathsf{T_{virt}}(v)$ and gets a color $c\in\{\mbox{black, white}\}$ for each node. This requires constant time. Algorithm $A$ outputs “white” at all nodes $v\in V$, since they have the same view as the root of $T_{w}$ up to distance $k$. Similarly, algorithm $A$ outputs “black” at all nodes $u\in U$. We then orient an edge of $B$ from node $y$ to node $z$ if and only if $m_{y,z}$ has the same color of $y$ (see Figure 3 for an example). By Proposition 4, we know that at least one such a leaf exists for each node in $B$, meaning that each node is guaranteed to have at least one outgoing edge. This would solve sinkless orientation on $2$-colored trees in the LOCAL model in $O(\log^{*}n)$ rounds. Putting all together, we get the following lemma.

Lemma 5**.**

The 2-partial 2-coloring problem requires $\omega(1)$ rounds in the DC-LOCAL model.

5.2 From DC-LOCAL to LOCAL

We now show that all LCLs solvable in $O(\log^{*}n)$ rounds can be solved in a standard manner, that is, first find a distance-$k$ coloring, for some constant $k$, and then apply a constant time algorithm running in at most $k$ rounds. In particular, we will prove the following lemma.

Lemma 6**.**

Any LCL problem that can be solved in $O(\log^{*}n)$ rounds in the LOCAL model can be solved in $O(1)$ rounds in the DC-LOCAL model.

We prove the lemma by simulation. Let $P$ be an LCL problem checkable in $r$ rounds, where $r$ is some constant. Assume that we have an algorithm $A$ for the LOCAL model that solves $P$ in $f(n)=O(\log^{*}n)$ rounds on graphs of size $n$ in which nodes have unique identifiers in $\{1,\ldots,n\}$. Let $\Delta=O(1)$ be the maximum degree of the graph.

Fix $N$ to be the smallest integer such that $t=f(N)+1$ and $\Delta^{2(t+r)}<N$. We show that we can construct an algorithm $A^{\prime}$ running in $t$ rounds that solves $P$ in the DC-LOCAL\bigl{(}t+r, \Delta^{2(t+r)}\bigr{)} model. Note that $t$ is constant. In other words, we design an algorithm that solves $P$ in constant time given the promise that nodes are labeled with a $\Delta^{2(t+r)}$-coloring of distance $(t+r)$. We assume that the diameter of the graph is at least $2t$, otherwise nodes can gather the entire graph in constant time and solve $P$ by brute force.

Algorithm $A^{\prime}$ executed by a node $v$ is defined as follows. At first, node $v$ gathers its distance-$t$ neighborhood $B_{v}(t)$. Then, node $v$ creates a virtual instance of $P$ by renaming the nodes in $B_{v}(t)$ and setting their identifiers as their assigned colors. Now, node $v$ simulates algorithm $A$ on $B_{v}(t)$, by lying about the size of the graph and setting it to be $N$. Finally, the output of $A^{\prime}$ is defined to be the same as the output of algorithm $A$. Notice that this simulation is clearly possible, since $A$, running on instances of size $N$, terminates in strictly less than $t$ rounds.

We still need to show that the output is valid for the original LCL. For this purpose, we show that, if the algorithm fails in some neighborhood, then we can construct an instance in which the original algorithm fails as well. Let $G$ be the graph in which, given a $\Delta^{2(t+r)}$-coloring of distance $(t+r)$, there is a node $v$ such that the verifier executed on $v$ rejects (after running for $r$ rounds). Consider $G^{\prime}=B_{v}(t+r)$, the subgraph of radius $r+t$ centered at $v$. All nodes in $G^{\prime}$ have different colors and the number of nodes is at most $N$, since $N$ satisfies $\Delta^{2(t+r)}<N$. We now modify $G^{\prime}$ in order to make it a graph of size exactly $N$. For this purpose, we pick an arbitrary node at distance $t+r$ from $v$ (that exists by the diameter assumption), and we connect to it a path of as many nodes as needed. We then complete the coloring of these nodes in some consistent manner.

The identifiers of nodes in $G^{\prime}$ are set to be equal to their colors. The ID space in $G^{\prime}$ is in $1,\ldots,N$. At this point, we run algorithm $A$ on $G^{\prime}$. Consider the set $S$ of nodes at distance at most $r$ from $v$. For every node $u\in S$, the $t$-neighborhood of $u$ is the same on $G$ and $G^{\prime}$, hence the output of $A$ on these nodes must be the same as the output of $A^{\prime}$. Thus, the failure of $A^{\prime}$ on $G$ implies the failure of $A$ on $G^{\prime}$. Theorem 3 follows by combining Lemmas 5 and 6.

6 Additional hardness results

Theorem 7**.**

Computing a $k$-partial $c$-coloring in $d$-regular graphs, for $k\geq\frac{c-1}{c}d+1$, requires $\Omega(\log n)$ deterministic time and $\Omega(\log\log n)$ randomized time.

Proof.

Assume the problem is easy to solve. Each monochromatic subgraph has a maximum degree $x=d-k\leq\frac{d}{c}-1$, and hence it is easy to color with $x+1\leq\frac{d}{c}$ colors. Hence overall we can easily find a proper coloring of a $d$-regular graph with at most $c\cdot\frac{d}{c}=d$ colors, but this is known to be hard [6, 9]. ∎

Acknowledgments

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