Locality of not-so-weak coloring

1 Introduction

	(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$ :	$3$	$\dots \infty$	$2$		$2$		$2$		$\infty$	$2$	$2$		$2$
$3$ :	$4$	$\dots \infty$	$4$	$\dots \infty$	$3$		$3$		$\infty$	$4$	$3$		$3$
$4$ :	$5$	$\dots \infty$	$5$	$\dots \infty$	$5$	$\dots 7$	$4$		$\infty$	$5$	$5$		$4$
$5$ :	$6$	$\dots \infty$	$6$	$\dots \infty$	$6$	$\dots 9$	$6$	$\dots 9$	$\infty$	$\framebox$7$$	$6$	$\dots 9$	$6$
$6$ :	$7$	$\dots \infty$	$7$	$\dots \infty$	$7$	$\dots 11$	$7$	$\dots 11$	$\infty$	$\framebox$8$$	$7$	$\dots 11$	$7$	$\dots 11$
$7$ :	$8$	$\dots \infty$	$8$	$\dots \infty$	$8$	$\dots 13$	$8$	$\dots 13$	$\infty$	$\framebox$10$$	$\framebox$9$$	$\dots 13$	$8$	$\dots 13$

Table 1: An overview of

k

-partial

c

-coloring in

d

-regular graphs: for each

k

and

c

, the table shows what is the smallest

d

such that the problem is easy. For example, “

4 \dots 5

” means that for these parameters the problem is known to be easy in

5

-regular graphs, while the case of

4

-regular graphs is unknown. The new results are highlighted with a frame. Our main contributions are the new lower bounds for

c = 2

(Theorem 3) and upper bounds for

c = 3

(Theorem 2), which were previously completely open. We also obtain stronger lower bounds for e.g.

c = 3

k \geq 5

(Theorem 7) and stronger upper bounds for

c = k \geq 4

(Theorem 2).

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 $Ω (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 $Ω (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]:

[noitemsep]
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 2 d - 1$ , hard for $c \leq 2 d - 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 : V \to {1, 2, \dots, 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 ≫ 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$ :

[noitemsep]
$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 ≫ 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, \dots, 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, \dots, 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 $Δ = O (1)$ , possibly labeled with some node labels from a constant-size set $X$ . The task is to find a labeling $f : 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”

: [noitemsep]
“Easy”:: solvable in $O ({log}^{*} n)$ rounds with both deterministic and randomized algorithms.
“Hard”:: requires $Ω (log n)$ rounds with deterministic algorithms and $Ω (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 $Δ$ ).

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 $⌊ d / p ⌋$ -defective $p^{2}$ -coloring in time $O ({log}^{*} n)$ , which is essentially a defective variant of Linial’s $O (Δ^{2})$ -coloring algorithm [18]. This algorithm requires at least $4$ colors, and for the case $c = 4$ it translates to a $⌈ d / 2 ⌉$ -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 ≫ 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$ :

[noitemsep]
$k < c$ : easy for all $d \geq k$ .
$k \geq c$ : hard for $d = k$ but easy for $d ≫ k$ .

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

[noitemsep]
$k < c$ : easy for all $d \geq k$ .
$k \geq c$ : hard for $d = k$ but easy for $d ≫ k$ .

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

[noitemsep]
$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 $⌈ d / 2 ⌉$ -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, \dots$ 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} ≫ 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:

[noitemsep]
A $k$ -partial $3$ -coloring, if $d \geq 3 k - 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.

Figure 1: Examples of the output of the $3$ -partial $3$ -coloring algorithm, running at the central node $v$ , in a graph where the degree is $5$ . The figure shows 3 cases: $v$ keeps the color chosen during the first sweep, $v$ switches to the special color in the second sweep, $v$ switches to color $2$ in the second sweep.

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, \dots, 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 3 k - 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$ .
$x + y \geq k$ . Then $v$ can safely choose color $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 2 k - 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,

	$t + y + z$	$\leq k - 1,$
	$x + y$	$\leq k - 1,$
	$y$	$\geq 1,$
	$and d$	$\leq 2 t + x + y + z,$

yielding the contradiction that

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

$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$ .
$x + y \geq k$ . Then $v$ can safely choose color $k$ .
There are $f > 0$ “free” colors from ${2, \dots, 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 $⌊ t / f ⌋$ 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

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

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

	$t + y + z$	$\leq k - 1,$
	$x + y$	$\leq k - 1,$
	$y$	$\geq k - 2,$
	$and r$	$\leq \frac{t}{k - 2} .$

Together, this implies

\begin{matrix} (k - 2) d & \leq (k - 1) (t + x + y + z) - y \leq (k - 1)^{2} + (k - 1) (x + y) - k y \leq 2 (k - 1)^{2} - k (k - 2) = k^{2} - 2 k + 2, \end{matrix}

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 $Ω (log n)$ deterministic time and $Ω (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 $ω ({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 $Ω (log n)$ deterministic time and $Ω (log log n)$ randomized time.

Theorem 3.

Computing a $2$ -partial $2$ -coloring in $d$ -regular trees in the LOCAL model requires $Ω (log n)$ deterministic time and $Ω (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 $D C$ 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 $ω (1)$ lower bound for $2$ -partial $2$ -coloring in the DC-LOCAL model, since we know that sinkless orientation requires $Ω (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 $(k + 1, d^{2 (k + 1)})$ 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 {black, white}$ be the color of the root of the gadget and let $¯ c$ be the opposite color. Among all nodes at distance $2 t$ 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 $¯ c$ at all nodes at distance $2 t$ from the root. Then all nodes at distance $2 t - 1$ must have color $c$ in order to guarantee a $2$ -proper $2$ -coloring. This would imply that all nodes at distance $2 t - 2$ have color $¯ c$ . By applying this reasoning recursively, we conclude that the root must have color $¯ 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 $(k + 1, d^{2 (k + 1)})$ model, then we can design an algorithm $A^{'}$ that solves sinkless orientation on trees of degree $Δ = d^{2 k}$ in which a $2$ -coloring of the tree is given, in $O ({log}^{*} n)$ rounds in the LOCAL model.

Consider a $Δ$ -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 $2 k$ . We call this tree $T_{v i r t}$ $(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 $T_{v i r t}$ $(v)$ with the $j$ -th leaf of $T_{v i r t}$ $(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 $Δ$ -regular, and since each virtual tree $T_{v i r t}$ has $Δ$ leaves, then all the leaves of $T_{v i r t}$ are merged nodes (except for the case in which the original node is a leaf, where just one leaf of $T_{v i r t}$ 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.

Figure 3: In this example, the merged node of $T_{v i r t} (y)$ and $T_{v i r t} (z)$ has the same color as node $y$ , hence the edge ${y, z}$ in $B$ is oriented from $y$ to $z$ .

Now, each node $v$ in $B$ simulates the $k$ -round algorithm $A$ on all nodes of $T_{v i r t} (v)$ and gets a color $c \in {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 $ω (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, \dots, n}$ . Let $Δ = O (1)$ be the maximum degree of the graph.

Fix $N$ to be the smallest integer such that $t = f (N) + 1$ and $Δ^{2 (t + r)} < N$ . We show that we can construct an algorithm $A^{'}$ running in $t$ rounds that solves $P$ in the DC-LOCAL $(t + r$ , $Δ^{2 (t + r)})$ 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 $Δ^{2 (t + r)}$ -coloring of distance $(t + r)$ . We assume that the diameter of the graph is at least $2 t$ , otherwise nodes can gather the entire graph in constant time and solve $P$ by brute force.

Algorithm $A^{'}$ 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^{'}$ 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 $Δ^{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^{'} = B_{v} (t + r)$ , the subgraph of radius $r + t$ centered at $v$ . All nodes in $G^{'}$ have different colors and the number of nodes is at most $N$ , since $N$ satisfies $Δ^{2 (t + r)} < N$ . We now modify $G^{'}$ 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^{'}$ are set to be equal to their colors. The ID space in $G^{'}$ is in $1, \dots, N$ . At this point, we run algorithm $A$ on $G^{'}$ . 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^{'}$ , hence the output of $A$ on these nodes must be the same as the output of $A^{'}$ . Thus, the failure of $A^{'}$ on $G$ implies the failure of $A$ on $G^{'}$ . 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 $Ω (log n)$ deterministic time and $Ω (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.

References

Balliu et al. [2018a] Alkida Balliu, Sebastian Brandt, Dennis Olivetti, and Jukka Suomela. Almost global problems in the LOCAL model. In Proc. 32nd International Symposium on Distributed Computing (DISC 2018), Leibniz International Proceedings in Informatics (LIPIcs). Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2018a. doi:10.4230/LIPIcs.DISC.2018.9.
Balliu et al. [2018b] Alkida Balliu, Juho Hirvonen, Janne H Korhonen, Tuomo Lempiäinen, Dennis Olivetti, and Jukka Suomela. New classes of distributed time complexity. In Proc. 50th ACM Symposium on Theory of Computing (STOC 2018)
, pages 1307–1318. ACM Press, 2018b. doi:10.1145/3188745.3188860.
Barenboim and Elkin [2013] Leonid Barenboim and Michael Elkin. Distributed Graph Coloring: Fundamentals and Recent Developments, volume 4. 2013. doi:10.2200/S00520ED1V01Y201307DCT011.
Barenboim et al. [2014] Leonid Barenboim, Michael Elkin, and Fabian Kuhn. Distributed ( $Δ$ +1)-Coloring in Linear (in $Δ$ ) Time. SIAM Journal on Computing, 43(1):72–95, 2014. doi:10.1137/12088848X.
Bonamy et al. [2018] Marthe Bonamy, Paul Ouvrard, Mikaël Rabie, Jukka Suomela, and Jara Uitto. Distributed recoloring. In Proc. 32nd International Symposium on Distributed Computing (DISC 2018), Leibniz International Proceedings in Informatics (LIPIcs). Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.DISC.2018.12.
Brandt et al. [2016] Sebastian Brandt, Orr Fischer, Juho Hirvonen, Barbara Keller, Tuomo Lempiäinen, Joel Rybicki, Jukka Suomela, and Jara Uitto. A lower bound for the distributed Lovász local lemma. In Proc. 48th ACM Symposium on Theory of Computing (STOC 2016), pages 479–488. ACM Press, 2016. doi:10.1145/2897518.2897570.
Brandt et al. [2017] Sebastian Brandt, Juho Hirvonen, Janne H Korhonen, Tuomo Lempiäinen, Patric R J Östergård, Christopher Purcell, Joel Rybicki, Jukka Suomela, and Przemysław Uznański. LCL problems on grids. In Proc. 36th ACM Symposium on Principles of Distributed Computing (PODC 2017), pages 101–110. ACM Press, 2017. doi:10.1145/3087801.3087833.
Chang and Pettie [2017] Yi-Jun Chang and Seth Pettie. A Time Hierarchy Theorem for the LOCAL Model. In Proc. 58th IEEE Symposium on Foundations of Computer Science (FOCS 2017), pages 156–167. IEEE, 2017. doi:10.1109/FOCS.2017.23.
Chang et al. [2016] Yi-Jun Chang, Tsvi Kopelowitz, and Seth Pettie. An Exponential Separation between Randomized and Deterministic Complexity in the LOCAL Model. In Proc. 57th IEEE Symposium on Foundations of Computer Science (FOCS 2016), pages 615–624. IEEE, 2016. doi:10.1109/FOCS.2016.72.
Chang et al. [2018] Yi-Jun Chang, Qizheng He, Wenzheng Li, Seth Pettie, and Jara Uitto. The Complexity of Distributed Edge Coloring with Small Palettes. In Proc. 29th ACM-SIAM Symposium on Discrete Algorithms (SODA 2018), pages 2633–2652. Society for Industrial and Applied Mathematics, 2018. doi:10.1137/1.9781611975031.168.
Chung et al. [2017] Kai-Min Chung, Seth Pettie, and Hsin-Hao Su. Distributed algorithms for the Lovász local lemma and graph coloring. Distributed Computing, 30(4):261–280, 2017. doi:10.1007/s00446-016-0287-6.
Cole and Vishkin [1986] Richard Cole and Uzi Vishkin. Deterministic coin tossing with applications to optimal parallel list ranking. Information and Control, 70(1):32–53, 1986. doi:10.1016/S0019-9958(86)80023-7.
Fischer and Ghaffari [2017] Manuela Fischer and Mohsen Ghaffari. Sublogarithmic Distributed Algorithms for Lovász Local Lemma, and the Complexity Hierarchy. In Proc. 31st International Symposium on Distributed Computing (DISC 2017), pages 18:1–18:16, 2017. doi:10.4230/LIPIcs.DISC.2017.18.
Ghaffari and Su [2017] Mohsen Ghaffari and Hsin-Hao Su. Distributed Degree Splitting, Edge Coloring, and Orientations. In Proc. 28th ACM-SIAM Symposium on Discrete Algorithms (SODA 2017), pages 2505–2523. Society for Industrial and Applied Mathematics, 2017. doi:10.1137/1.9781611974782.166.
Ghaffari et al. [2018a] Mohsen Ghaffari, David G Harris, and Fabian Kuhn. On Derandomizing Local Distributed Algorithms. In Proc. 59th IEEE Symposium on Foundations of Computer Science (FOCS 2018), 2018a. doi:10.1109/FOCS.2018.00069. URL http://arxiv.org/abs/1711.02194.
Ghaffari et al. [2018b] Mohsen Ghaffari, Juho Hirvonen, Fabian Kuhn, and Yannic Maus. Improved Distributed $Δ$ -Coloring. In Proc. 37th ACM Symposium on Principles of Distributed Computing (PODC 2018), pages 427–436. ACM, 2018b. doi:10.1145/3212734.3212764.
Kuhn [2009] Fabian Kuhn. Weak graph colorings. In Proc. 21st ACM Symposium on Parallelism in Algorithms and Architectures (SPAA 2009), pages 138–144, New York, New York, USA, 2009. ACM Press. doi:10.1145/1583991.1584032.
Linial [1992] Nathan Linial. Locality in Distributed Graph Algorithms. SIAM Journal on Computing, 21(1):193–201, 1992. doi:10.1137/0221015.
Naor [1991] Moni Naor. A lower bound on probabilistic algorithms for distributive ring coloring. SIAM Journal on Discrete Mathematics, 4(3):409–412, 1991. doi:10.1137/0404036.
Naor and Stockmeyer [1995] Moni Naor and Larry Stockmeyer. What Can be Computed Locally? SIAM Journal on Computing, 24(6):1259–1277, 1995. doi:10.1137/S0097539793254571.
Panconesi and Rizzi [2001] Alessandro Panconesi and Romeo Rizzi. Some simple distributed algorithms for sparse networks. Distributed Computing, 14(2):97–100, 2001. doi:10.1007/PL00008932.
Peleg [2000] David Peleg. Distributed Computing: A Locality-Sensitive Approach. Society for Industrial and Applied Mathematics, 2000. doi:10.1137/1.9780898719772.

Locality of not-so-weak coloring

Authors

Related Research

Towards the Locality of Vizing's Theorem

Distance-2 Coloring in the CONGEST Model

Hardness of minimal symmetry breaking in distributed computing

Distributed Recoloring

Peacock Bundles: Bundle Coloring for Graphs with Globality-Locality Trade-off

Local Mending

Distributed Computing in the Asynchronous LOCAL model

This week in AI

1 Introduction

Definition 1.

2 Preliminaries and related work

2.1 Local model of computing

2.2 Lcl problems and gap theorems

2.3 Prior work related to partial colorings

Notes on terminology.

Weak coloring, k=1.

Partial coloring for k<c.

Proper vertex coloring, k=d.

Partial coloring for c≥4.

Partial coloring for c≤3.

Algorithms based on Lovász local lemma.

Other algorithms.

3 Our contributions

3.1 Corollary: locally optimal cuts

3.2 Key techniques

Upper bound for 3-coloring.

Lower bound for 2-coloring.

4 Partial colorings with more than two colors

Theorem 2.

The algorithm.

k-partial 3-coloring.

k-partial k-coloring.

5 Two-partial two-coloring

Theorem 3.

Dc-Local model.

5.1 A lower bound for the Dc-Local model

Gadgets.

Property 4.

Proof.

Reduction.

Lemma 5.

5.2 From Dc-Local to Local

Lemma 6.

6 Additional hardness results

Theorem 7.

Proof.

Acknowledgments

References

Weak coloring, $k = 1$ .

Partial coloring for $k < c$ .

Proper vertex coloring, $k = d$ .

Partial coloring for $c \geq 4$ .

Partial coloring for $c \leq 3$ .

$k$ -partial 3-coloring.

$k$ -partial $k$ -coloring.