Linial for lists

Abstract

Linial’s famous color reduction algorithm reduces a given m-coloring of a graph with maximum degree $\varDelta$ to an $O(\varDelta ^2\log m)$-coloring, in a single round in the LOCAL model. We give a similar result when nodes are restricted to choose their color from a list of allowed colors: given an m-coloring in a directed graph of maximum outdegree $\beta$, if every node has a list of size $\varOmega (\beta ^2 (\log \beta +\log \log m + \log \log |{\mathcal {C}}|))$ from a color space ${\mathcal {C}}$ then they can select a color in two rounds in the LOCAL model. Moreover, the communication of a node essentially consists of sending its list to the neighbors. This is obtained as part of a framework that also contains Linial’s color reduction (with an alternative proof) as a special case. Our result also leads to a defective list coloring algorithm. As a corollary, we improve the state-of-the-art truly local $({\text {deg}}+1)$-list coloring algorithm from Barenboim et al. (PODC, pp 437–446, 2018) by slightly reducing the runtime to $O(\sqrt{\varDelta \log \varDelta })+\log ^* n$ and significantly reducing the message size (from $\varDelta ^{O(\log ^* \varDelta )}$ to roughly $\varDelta$). Our techniques are inspired by the local conflict coloring framework of Fraigniaud et al. (in: FOCS, pp 625–634, 2016).

1 Introduction

Symmetry breaking problems are a cornerstone of distributed graph algorithms in the LOCAL model.¹ A central question in the area asks: How fast can these problems be solved in terms of the maximum degree $\varDelta$, when the dependence on n is as mild as $O(\log ^*n)$? [11]. That is, we are looking for truly local algorithms, with complexity of the form $f(\varDelta )+O(\log ^*n)$.² The $O(\log ^*n)$ term is unavoidable due to the seminal lower bound by Linial [41] that, via simple reductions, applies to most typical symmetry breaking problems. $(\varDelta +1)$-vertex coloring and maximal independent set (MIS) are the key symmetry breaking problems. Both can be solved by simple centralized greedy algorithms (in particular they are always solvable), and even more importantly in a distributed context, any partial solution (e.g. a partial coloring) can be extended to a complete solution. The complexity of MIS is settled up to constant factors with $f(\varDelta )=\varTheta (\varDelta )$, by the algorithm from [13] and a recent breakthrough lower bound by Balliu et al. [3]. In contrast, the complexity of vertex coloring, despite being among the most studied distributed graph problems [11], remains widely open, with the current best upper bound $f(\varDelta )={\tilde{O}}(\sqrt{\varDelta })$ and lower bound $f(\varDelta )=\varOmega (1)$. While most work has focused on the $(\varDelta +1)$-coloring problem, recent algorithms, e.g., [8, 12, 23, 37], rely on the more general list coloring problem as a subroutine, where each vertex v of a graph G has a list $L_v\subseteq {\mathcal {C}}$ of colors from a colorspace ${\mathcal {C}}$, and the objective is to compute a proper vertex coloring, but each vertex has to select a color from its list. Again, a natural case is the always solvable $({\text {deg}}+1)$-list coloring problem, where the list of each vertex is larger than its degree. Our paper contributes to the study of list coloring problems. To set the stage for our results, let us start with an overview of truly local coloring algorithms.

In [41], besides the mentioned lower bound, Linial showed that an $O(\varDelta ^2)$-coloring can be done in $O(\log ^*n)$ rounds. Szegedy and Vishwanathan [49] improved the runtime to $\frac{1}{2}\log ^*n+O(1)$, and showed that in additional $O(\varDelta \cdot \log \varDelta )$ rounds, the $O(\varDelta ^2)$-coloring could be reduced to $(\varDelta +1)$-coloring. The latter result was rediscovered by Kuhn and Wattenhofer [39]. Barenboim, Elkin and Kuhn used defective coloring for partitioning the graph into low degree subgraphs and coloring in a divide-and-conquer fashion, and brought the complexity of $(\varDelta +1)$-coloring down to $O(\varDelta + \log ^*n)$ [13]. A simpler algorithm with the same runtime but without using defective coloring was obtained recently in [12, 42]. All of these results also hold for $({\text {deg}}+1)$-list coloring, since given an $O(\varDelta )$-coloring, one can use it as a “schedule” for computing a $({\text {deg}}+1)$-list coloring in $O(\varDelta )$ additional rounds. Meantime, two sub-linear in $\varDelta$ algorithms were already published [8, 23]. They both used low outdegree colorings, or arb-defective colorings, introduced by Barenboim and Elkin in [10], for graph partitioning purposes. The basic idea here is similar to the defective coloring approach, with the difference that the graph is partitioned into subgraphs with low maximum average degree or arborocity. In [12] they also improved and simplified the computation of low outdegree colorings, which led to improved runtime and simplification of that component in the mentioned sublinear algorithms. As a result, the currently fastest CONGEST algorithm needs $O(\varDelta ^{3/4} +\log ^*n)$ rounds ([8]+ [12]),³ while the fastest LOCAL algorithm needs $O(\sqrt{\varDelta \log \varDelta }\log ^*\varDelta +\log ^*n)$ rounds ([23]+ [12]).

Let us take a better look at the latter result, which is the closest to our paper. The algorithm consists of two main ingredients: (1) an algorithm that partitions a given graph into $p=O(\varDelta /\beta )$ subgraphs, each equipped with a $\beta =O(\sqrt{\varDelta /\log \varDelta })$-outdegree orientation, in $O(p)+\frac{1}{2}\log ^*n$ rounds [12], (2) a list coloring subroutine that gives rise to the following [23]:

Theorem 1

([23]) In a directed graph with max. degree $\varDelta$, max. outdegree $\beta$, and an input m-coloring, list coloring problem with lists $L_v$ of size $|L_v|\ge 10\beta ^2\ln \varDelta$ from any color space can be solved in $O(\log ^*(\varDelta + m))$ rounds in LOCAL.

The two ingredients are combined to give a $({\text {deg}}+1)$-list coloring of the input graph G [23]. First, partition G using (1), iterate through the p directed subgraphs, and for each of them, let uncolored nodes refine their lists by removing colors taken by a neighbor, and use (2) to color nodes that still have sufficiently large lists ($\ge 10\beta ^2\ln \varDelta$). With a fine grained choice of $\beta$ it is ensured that every node v with (refined) list size greater than $\varDelta /2$ is colored. Thus, after iterating through all p subgraphs, all uncolored nodes have list size at most $\varDelta /2$, and because each vertex always has more colors in its list than uncolored neighbors, the max degree of the graph induced by uncolored nodes is at most half of that of G. Thus, we can apply the partition-then-list-color paradigm recursively to the subgraph induced by uncolored nodes to complete the coloring. The runtime is dominated by the first level of recursion.

The strength of the partitioning algorithm above is that it is conceptually simple and works with small messages. In contrast, the algorithm from Theorem 1 is conceptually complicated and uses gigantic messages. This complication might be due to the generality of the addressed setting as, in fact, [23] studies the more general local conflict coloring problem, and Theorem 1 is only a special case. In local conflict coloring, each edge of the given graph is equipped with an arbitrary conflict relation between colors and this relation may vary across different edges. This framework is also leveraged to achieve the colorspace size independence of Theorem 1 (see the technical overview below). It was not clear prior to our work whether the situation simplifies significantly if one restricts to ordinary list coloring because, even if the input to the algorithm in Theorem 1 is a list coloring problem, the intermediate stages of the algorithm fall back to the more general local conflict coloring.

The overarching goal of our paper is providing deeper understanding of the remarkable framework of [23], better connecting it with classic works in the area, and obtaining a simpler list coloring algorithm that also uses smaller messages, by moderately sacrificing generality.

1.1 Our contribution

Our main result is a simple algorithm that yields the following theorem.

Theorem 2

(Linial for Lists) In a directed graph with max. degree $\varDelta$, max. outdegree $\beta$, and an input m-coloring, list coloring problem with lists $L_v$ from a color space ${\mathcal {C}}$ and of size $|L_v|\ge l_0=4e\beta ^2(4\log \beta +\log \log |{\mathcal {C}}|+\log \log m+8)$ can be solved in 2 rounds in LOCAL. Each node sends $l_0+1$ colors in the first round, and a $l_0/\beta ^2$-bit message in the second.

The name “Linial for Lists” stems from the fact that Theorem 2 is a “list version” of one of the cornerstones of distributed graph coloring, Linial’s color reduction, which says that an m-coloring can be reduced to a $(5\varDelta ^2\log m)$-coloring in a single round [41]. Moreover, our framework is itself a natural generalization of Linial’s approach of cover-free set families. Applied to equal lists, it yields an alternative proof of Linial’s color reduction, in the form of a greedy construction of cover-free families (Linial proved their existence using the probabilistic method [41]; he also used an alternative construction from [21] via polynomials over finite fields, which however yields a weaker color reduction for $m\gg \varDelta$) (see Sects. 2.3 and 6).

Compared with Theorem 1, we lose colorspace independence, and our algorithm does not extend to general local conflict coloring (although we use a kind of conflict coloring in the process). In exchange, we eliminate $\varDelta$ from the bound on the list size, reduce the runtime to exactly 2 rounds, and dramatically reduce message size. This is achieved by a non-trivial paradigm shift in the local conflict coloring framework (see the technical overview below). The runtime cannot be reduced to 1 round, due to a lower bound of [49] (see Sect. 6).

Combining Theorem 2 with the partitioning algorithm of [12] as outlined above gives us a $({\text {deg}}+1)$-list coloring algori Note that any improvement in the list size bound in Theorem 2 (with little increase in runtime) would yield a faster $({\text {deg}}+1)$-list coloring algorithm.

Theorem 3

($({\text {deg}}+1)$-List Coloring) In a graph with max. degree $\varDelta$, $({\text {deg}}+1)$-list coloring problem with lists $L_v\subseteq {\mathcal {C}}$ from a color space of size $|{\mathcal {C}}|=2^{{\text {poly}}(\varDelta )}$⁴ can be solved in $O\big (\sqrt{\varDelta \log \varDelta }\big )+\frac{1}{2}\cdot \log ^*n$ rounds in LOCAL.

Furthermore, each node only needs to broadcast to its neighbors a single non-CONGEST message consisting of a subset of its list (i.e., of size ${\text {poly}}(\varDelta )$ which could be $\omega (\log n)$).

The bound on the color space size stems from the color space dependence in Theorem 2. As discussed in Sect. 6, it is possible to trade color space dependence with runtime in Theorem 2, which could improve or suppress the bound in Theorem 3. That, however, comes with the cost of having large messages.

Theorem 3 immediately provides the fastest known truly local $(\varDelta +1)$-coloring algorithm in LOCAL. Below we list further implications of our framework.

• CONGEST (see Cor. 1): We obtain an improved $(\varDelta +1)$-coloring algorithm in a low degree regime in CONGEST. In particular, if $\varDelta ={\tilde{O}}(\log n)$ then $(\varDelta +1)$-coloring (more generally, $({\text {deg}}+1)$-list coloring with colorspace of size $|{\mathcal {C}}|={\text {poly}}(\varDelta )$) can be solved in ${\tilde{O}}(\sqrt{\varDelta })+\frac{1}{2}\cdot \log ^*n$ rounds in CONGEST. Generally, if one allows messages of size B, this runtime holds for degree up to $\varDelta ={\tilde{O}}(B)$. On the other hand, if $\varDelta =\varOmega (\log ^{2+\varepsilon }n)$, for an arbitrarily small constant $\varepsilon >0$, an algorithm from recent work [37] achieves runtime ${O}(\sqrt{\varDelta })$ in CONGEST (if one recasts their dependency on n as a $\varDelta$-dependency). Thus, only for the regime of $\varDelta \in \varOmega (\log ^{1+\epsilon } n)\cap O(\log ^{2+\epsilon } n)$ we do not have a deterministic algorithm with runtime ${\tilde{O}}(\sqrt{\varDelta })$ in CONGEST (with the current best being $O(\varDelta ^{3/4}+\log ^*n)$ due to [8]).

• Defective list coloring (see Theorem 6): Our framework extends to d-defective list coloring, that is, list coloring where each node v can have at most d neighbors with the same colors as v: If lists are of size $\varOmega \big ((\varDelta /(d+1))^2 \cdot (\log \varDelta + \log \log |{\mathcal {C}}| + \log \log m)\big )$ we can compute a d-defective list coloring in 2 rounds in LOCAL. The result can be seen as the “list variant” of a defective coloring result in [36]. While we are not aware of an immediate application, defective list coloring with a better “colors vs. defect” tradeoff (d vs. $O(\varDelta /d)$) for line graphs has recently been used to obtain an edge coloring algorithm with complexity ${\text {quasi}}{\text {poly}}\log \varDelta + O(\log ^*n)$ [6].

• $\varDelta$-coloring: The improvements obtained in Theorem 3 also imply respective improvements for several $\varDelta$-coloring algorithms that use $({\text {deg}}+1)$-list coloring as a subroutine [27].

1.2 Technical overview

At their core, the proofs of Theorems 1 and 2 are based on three important concepts: conflict coloring, problem amplification and 0-round solvability. A conflict coloring problem is a list coloring problem where every node has a list of available colors but two colors can conflict even if they are not equal (in particular, a color can conflict with multiple colors). The associated conflict degree is the maximum number of conflicts per color a node can have. Problem amplification transforms one conflict coloring problem instance into another, as follows: given an input to a problem A, each node computes its input to another problem B (perhaps by exchanging information along the way), with the property that, 1. having a solution to B, a simple one round algorithm computes a solution to A, and 2. the list-size-to-conflict-degree (l/d) ratio of B is larger than that of A. Note that the first property essentially determines the conflicts in B, and usually a color in B is a set of colors in A. The importance of the second property stems from the concept of 0-round solvability: an instance of a problem B with large enough l/d ratio can be solved in 0 rounds, i.e., with no communication.

From here, the plan is simple: take problem $P_0$, which is the list coloring problem, recast it as a conflict coloring problem, and amplify it into problems $P_1,\dots ,P_t$, so that $P_t$ is 0-round solvable. Then we can cascade down to a solution of problem $P_0$, in t rounds. Crucially, in order to do the above, we need $P_0$ to have sufficiently large l/d ratio to begin with (which explains the particular list size requirements in our theorems). The input m-coloring is used for tie-breaking in the 0-round solution of $P_t$.

In [23], local conflict coloring is the main problem type, where the conflict between two colors depends on who the colors belong to, i.e., two colors can conflict along one edge of the graph and not conflict on another one. Their framework allows solving any local conflict coloring problem, and by re-modeling a problem with an arbitrary colorspace via mapping each list to an interval [1, l] of natural numbers, one can redefine local conflicts and “forget” about the real size of the colorspace (hence colorspace independence). When computing the input of $P_i$ (given $P_{i-1}$), in order to maintain manageable conflict degree, nodes exchange messages to filter out colors in $P_i$ that cause too much conflict with any neighboring node. These messages are large (recall that a color in $P_i$ is a set of colors in $P_{i-1}$), although this can be implemented more efficiently by pre-collecting lists from a neighborhood of appropriate radius. Thus, the input to $P_i$ is usually the topology, $P_0$-lists and conflicts in the i-hop neighborhood of a node. The goal towards 0-round solvability is then to find a problem $P_t$ whose l/d ratio is larger than the number of all t-hop neighborhood patterns (i.e., inputs). The complicated nature of the input to $P_t$ also makes the 0-round solvability proof rather conceptually involved. The number t of problems required is about $3\log ^*(m+\varDelta )$.

Our framework, on the other hand, is based on special global conflict coloring instances, where the conflict relation of two colors does not depend on the edge across which they are. This limits us to solving only ordinary list problems $P_0$. Our key insight (see Sect. 3.3), which sets Theorems 1 and 2 apart, is that in our setting nodes do not need to communicate for computing the input to problems $P_1,\dots ,P_t$. To achieve this, we show that when forming the lists for $P_i$ from the input to $P_{i-1}$, it suffices to drop “universally bad” colors (sets of colors in $P_{i-1}$), whose absence is enough to ensure moderate conflict degree towards any (!) other node. We achieve this by crucially exploiting the symmetry of the particular conflict coloring problems arising from ordinary list coloring.

Thus, the input of a node in $P_t$ is just its input in $P_0$. This makes the 0-round solution (of $P_t$) particularly simple. The only communication happens when we cascade down from a solution of $P_t$ to that of $P_0$. With $t=2$, we get our main theorem. Since here we have only two problems, the message size is limited (the first round is needed to learn the $P_0$-lists of neighbors, while the second one consists of a small auxiliary message). Taking larger t would reduce the requirement on the initial list size but increase message size (see Sect. 6). Since $t=2$ is sufficient for our applications, we limit our exposition to that case. Setting $t=1$ does not give anything non-trivial for list coloring, since the l/d ratio is not large enough, but when all $P_0$-lists are equal, it gives an alternative proof of Linial’s color reduction (Sect. 2.3). In fact, $P_1$ is essentially the problem of finding a low intersecting set family, which Linial’s algorithm is based on, while $P_2$ is a “higher-dimensional” variant of it. Thus, at the core of our result there is an (offline) construction of certain set families over the given color space: given those, the algorithm is easy. This way, we believe our paper also provides a deeper insight into the framework of Theorem 1. Our result can also be seen as a bridge between the results of [23] and the recently popular concept of speedup (see Sect. 6).

1.3 Further related work

Most results on distributed graph coloring until roughly 2013 are covered in the excellent monograph by Barenboim and Elkin [11]. An overview of more recent work can be found in [37]. Due to the large volume of published work on distributed graph coloring, we limit this section to an informative treatment of a selected subset. While we have covered most literature on truly local vertex coloring algorithms, there are many known algorithms that trade the high $\varDelta$-dependence in the runtime with lower n-dependence. All deterministic algorithms in this category (for general input graphs) involve a $\varOmega (\log n)$ factor. From the early 90s until very recently, the complexity of $({\text {deg}}+1)$-list coloring (and $(\varDelta +1)$-coloring) in terms of n was $2^{O(\sqrt{\log n})}$ [1, 45], with algorithms based on network decomposition (into small diameter components). A recent breakthrough in network decomposition algorithms [47] brought the runtime of $({\text {deg}}+1)$-list coloring down to ${\text {poly}}\log n$ in LOCAL (it also applies to many other symmetry breaking problems; see [26, 29, 47]). A ${\text {poly}}\log n$-round CONGEST algorithm appeared a little later [7].

Historically, decompositions into subgraphs that are equipped with small outdegree orientations as used in our results, in [23], and in [8] are closely related to the notion of arboricity. To the best of our knowledge, orientations were first introduced as a tool for distributed graph coloring by Barenboim and Elkin [9]. They showed how to compute O(a)-outdegree acyclic orientations in graphs with arboricity a in $O(\log n)$ rounds, and used those to devise several algorithms to color graphs with bounded arboricity. They also noticed that the degree bound of $\varDelta$ in Linial’s color reduction can be replaced with a bound on the outdegree. In another paper, they designed algorithms to recursively partition an input graph into small-arboricity subgraphs, which were used to obtain an $O(\log \varDelta \log n )$-round algorithm for $O(\varDelta ^{1+\varepsilon })$-coloring and an $O(\varDelta ^{\varepsilon }\log n)$-round algorithm for $O(\varDelta )$-coloring [10]. Recently, this recursive technique was extended to $({\text {deg}}+1)$-list coloring, giving an algorithm with runtime $(2^{O(\sqrt{\log \varDelta })}\log n)$ [37]; this runtime has hidden dependence on the color space. While the algorithms from [9, 10, 37] have an inherent $O(\log n)$-factor in their runtime, it was shown in [8] that one can decompose a graph into small arboricity subgraphs⁵ (equipped with a small outdegree orientation) without incurring a $\log n$ factor, yielding the first sublinear in $\varDelta$ algorithm for $\varDelta +1$ coloring. The runtime for computing the underlying decompositions (as well as the conceptual complexity of the algorithm) were later improved in [12, 42]. This immediately improves the results of [23] and [8], as well as gives the current form of our result.

Note that our results, as well as those of [23] and [8], only require partitioning into subgraphs of appropriately bounded outdegree, and are oblivious to their arboricity. While a bound on outdegree provides a similar bound on arboricity, computing a bounded outdegree orientation given a graph with bounded arboricity requires $\varOmega (\log n)$ rounds [9].

Recent randomized coloring algorithms rely on the graph shattering technique [14]. In the shattering phase, a randomized algorithm computes a partial coloring of the graph, after which every uncolored connected component of the graph has small size (i.e., ${\text {poly}}\log n$). In the post-shattering phase, deterministic $({\text {deg}}+1)$-list coloring is applied on all uncolored components in parallel. The runtime of the shattering phase has progressed from $O(\log \varDelta )$ [14], over $O(\sqrt{\log \varDelta })$ [33] to $O(\log ^*\varDelta )$ [20]. Combined with the ${\text {poly}}\log n$-round list coloring algorithm of [47], this gives the current best runtime ${\text {poly}}\log \log n$, for $(\varDelta +1)$-coloring [20], and $O(\log \varDelta )+{\text {poly}}\log \log n$, for $({\text {deg}}+1)$-list coloring [14].

While special graph classes are out of the scope of this paper, we mention the extensively studied case of distributed edge coloring. Here, ${\text {poly}}\log n$-round algorithms were designed for progressively improving number of colors, from $(2+\varepsilon )\varDelta$ [28, 31] to $(2\varDelta -1)$ [22, 32], then to $(1+\varepsilon )\varDelta$ [30, 32, 48]. In a very recent manuscript, Bernshteyn gives a deterministic $(\varDelta +1)$-edge coloring algorithm with runtime polynomial in $\varDelta$ and $\log n$ [15]. This matches the bound given by Vizing’s theorem [50]. The truly local complexity of $(2\varDelta -1)$-edge coloring has improved from $O(\varDelta )$ [44] to $2^{O(\sqrt{\log \varDelta })})$ [37] then to ${\text {quasi}}{\text {poly}}\log \varDelta$ [6] (in addition to $O(\log ^*n)$).

Little is known on coloring lower bounds (in contrast to other symmetry breaking problems, e.g., maximal matching, MIS or ruling sets [3, 4, 38]). Linial’s $\varOmega (\log ^*n)$ lower bound is extended to randomized algorithms in [43]. The deterministic bound has recently been re-proven in a topological framework [24]. A lower bound of $\varOmega (\varDelta ^{1/3})$ for $O(\varDelta )$-coloring holds in a weak variant of the LOCAL model [34]. Several works characterized coloring algorithms which can only spend a single communication round [34, 39, 49]. None of these results gives anything non-trivial for two rounds. The speedup technique (e.g., [2,3,4, 16,17,18]), which has been very successful for MIS lower bounds, is poorly understood for graph coloring. We briefly discuss the technique and its relation to our result in Sect. 6. There are lower bounds for more restricted variants of coloring. There is a $\varOmega (\log n)$ ($\varOmega (\log \log n)$) lower bound for deterministic [17] (randomized [19]) $\varDelta$-coloring, as well as for $(\varDelta -2)$-defective 2-coloring [5]. An $\varOmega (\log n/\log \log n)$ lower bound is known for greedy coloring [25]. Similar bounds hold for coloring trees and bounded arboricity graphs with significantly fewer than $\varDelta$ colors [9, 41].

1.4 Roadmap

Section 2.1 introduces our version of conflict coloring together with the 0-round solvability lemma. Section 2.2 defines the problems $P_0$ and $P_1$ and provides further notation. Section 2.3 contains the first result of our framework: an alternative proof of Linial’s algorithm. Theorem 2 (Linial for Lists) is proved in Sect. 3. Theorem 3 ($({\text {deg}}+1)$-list coloring) is proved in Sect. 4. Theorem 6 (Defective list coloring) is proved in Sect. 5. We conclude with a discussion of the results and open problems in Sect. 6.

2 Basic setup and Linial’s color reduction

In this section, we first introduce the conflict coloring framework that is the basis of our algorithm, then we show how it quickly implies an alternative variant of Linial’s color reduction algorithm. For a set S and an integer $k\ge 0$, let ${\mathcal {P}}(S)$ and ${S\atopwithdelims ()k}$ denote the set of all subsets and all size-k subsets of S, respectively. For a map f we use $f^{(i)}$ to denote the i-fold application of f, e.g., ${\mathcal {P}}^{(2)}(S)={\mathcal {P}}({\mathcal {P}}(S))$.

2.1 Global conflict coloring

A list family ${\mathcal {F}}\subseteq {\mathcal {P}}({\mathcal {C}})$ is a set of subsets of a color space ${\mathcal {C}}$. Given a symmetric conflict relation ${{\mathcal {R}}}\subseteq \{\{c,c'\} \mid c,c'\in {\mathcal {C}}\}$, the conflict degree of a family ${\mathcal {F}}$ in ${{\mathcal {R}}}$ is the maximum number of colors in a list L that conflict with a single color in a list $L'$ (possibly same as L), i.e. , $d_{{\mathcal {R}}}({\mathcal {F}})=\max _{L,L'\in {\mathcal {F}}, c\in L}|\{c'\in L' \mid \{c,c'\}\in {{\mathcal {R}}}\}|$. An instance ${\mathfrak {P}}=({\mathcal {C}},{{\mathcal {R}}},{\mathcal {F}}, {\mathcal {L}})$ of the global conflict coloring problem on the graph G is given⁶ by a color space ${\mathcal {C}}$, a symmetric conflict relation ${{\mathcal {R}}}$ on ${\mathcal {C}}$, a list family ${\mathcal {F}}$, and an assignment ${\mathcal {L}}:V\rightarrow {\mathcal {F}}$ of lists ${\mathcal {L}}(v)\in {\mathcal {F}}$ of colors to each vertex v. The goal is to assign each vertex a color from its list such that no pair of neighboring vertices get conflicting colors $\{c,c'\}\in {{\mathcal {R}}}$. The conflict degree of ${\mathfrak {P}}$ is $d_{{\mathcal {R}}}({\mathcal {F}})$. Note that the conflict degree does not depend on G or ${\mathcal {L}}$.

Lemma 1

(Zero Round Solution) An instance $({\mathcal {C}},{{\mathcal {R}}},{\mathcal {F}}, {\mathcal {L}})$ of the conflict coloring problem on a graph G can be solved without communication if G is m-colored, $m,{{\mathcal {R}}},{\mathcal {F}}$ are globally known, and every list in ${\mathcal {F}}$ has size greater than $(m\cdot |{\mathcal {F}}|-1) \cdot d_{{\mathcal {R}}}({\mathcal {F}})~$.

Proof

Every vertex v has a type $(\psi _v, {\mathcal {L}}(v))\in [m]\times {\mathcal {F}}$, which is uniquely determined by its input color $\psi _v$ and list ${\mathcal {L}}(v)$. Note that adjacent vertices have distinct types, and there are $t= m\cdot |{\mathcal {F}}|$ (globally known) possible types. Below, we show how to greedily assign each type a color from its list s.t. different types get non-conflicting colors. The conflict coloring problem is then solved by running this algorithm locally and consistently by all vertices, where each vertex gets the color assigned to its type.

Let $\{T_i=(m_i,L_i)\}_{i=1}^t$ be a fixed ordering of $[m]\times {\mathcal {F}}$. Assign $T_1$ a color $\phi (T_1)\in L_1$ arbitrarily. For any $i\ge 1$, given the colors $\phi (T_1),\dots ,\phi (T_{i})$ of preceding types, assign $T_{i+1}$ a color from $L_{i+1}$ that does not conflict with $\phi (T_1),\dots ,\phi (T_{i})$. This can be done since each of the i fixed colors conflicts with at most $d_{{\mathcal {R}}}({\mathcal {F}})$ colors in $L_{i+1}$, i.e., there are at most $i\cdot d_{{\mathcal {R}}}({\mathcal {F}})\le (m |{\mathcal {F}}|-1) d_{{\mathcal {R}}}({\mathcal {F}})$ colors that $T_{i+1}$ cannot take, and this is less than the size of $L_{i+1}$, as assumed. $\square$

2.2 Basic problems: $P_0$ and $P_1$

Let ${\mathcal {C}}$ be a fixed and globally known color space (which may depend on the graph G). An i-list is a subset $L\subseteq {\mathcal {P}}^{(i)}({\mathcal {C}})$; e.g., the initial color list $L_v\subseteq {\mathcal {C}}$ of a vertex v is a 0-list. Below, we introduce two problems. Problem $P_0$ is the standard list coloring problem, which we would like to solve via Lemma 1. However, the Lemma may not apply, if the lists $L_v$ are not large enough. We then introduce problem $P_1$, with parameters $0<\tau \le k$, which is a low intersecting sublist selection problem. On the one hand, $P_1$ can be reformulated as a conflict coloring problem with larger lists and color space (hence could be solvable via Lemma 1), and on the other hand, a solution to $P_1$ can be used to solve $P_0$. The input of a node v in both problems contains its list $L_v$. Formally, we have, for parameters $\tau$ and $k$,

• $\mathbf{P} _\mathbf{0}$ (list coloring): Node v has to output a color $c(v)\in L_v$ such that adjacent nodes’ colors do not conflict, i.e., they are not equal.

• $P_1$ (low intersecting sublists): Node v has to output a 0-list $C_v\subseteq L_v$ such that $|C_v|=k$ and adjacent nodes’ 0-lists do not $\tau$-conflict. Two 0-lists $C,C'\subseteq {\mathcal {C}}$ do $\tau$-conflict if $|C\cap C'|\ge \tau$.

Note that problems $P_0$ and $P_1$ are not conflict coloring problems in the formal sense defined above (e.g., we do not define a list family ${\mathcal {F}}$ or a list assignment ${\mathcal {L}}:V\rightarrow {\mathcal {F}}$). The aim with such definitions is to have a higher level and more intuitive (but still formal) problem statement. As the name suggests, in $P_1$ each node needs to compute a subset of its list such that the outputs form a low intersecting set family. $P_1$ can be reduced to a formal conflict coloring problem ${\mathfrak {P}}_1$ whose solution immediately solves the $P_1$ instance (see Theorem 4).

2.3 Warmup: Linial’s color reduction (without lists)

As a demonstration, we use the introduced framework to re-prove Linial’s color reduction theorem [41, Thm. 4.1] (which was extended to directed graphs in [9]). An r-cover-free family of size k over a set U is a collection of k subsets $C_1,\ldots , C_k\subseteq U$ such that no set $C_i$ is a subset of the union of r others. The obtained algorithm is essentially a greedy construction (via Lemma 1) of an r-cover-free family (with appropriate parameters) whose existence was proved via the probabilistic method in [41]. This greedy construction was first obtained in [35] but, to our knowledge, remained unnoticed in the distributed computing community.

While our aim is to make the proof below reusable for the later sections (hence the general statement in list coloring terms), we note that similar ideas can be used to obtain a less technical proof of Linial’s color reduction (see “Appendix A”).

Theorem 4

([9, 41]) Let the graph G be m-colored and oriented, with max outdegree $\beta$. All nodes have an identical color list $L_v={\mathcal {C}}$ from a color space ${\mathcal {C}}$. Further, ${\mathcal {C}}$, m, and $\beta$ are globally known. If $|L_v|= l_0\ge 2e\cdot \beta ^2\cdot \lceil \log m\rceil$ holds then in 1 round in LOCAL, each node can output a color from its list s.t. adjacent nodes output distinct colors.

Proof

Our goal is to solve $P_0$ with the given lists. To this end, it suffices to solve $P_1$ with parameters $\tau =\lceil \log m\rceil >1$ and $k=\beta \cdot \tau$, without communication. Indeed, having selected the sublists $(C_v)_{v\in V}$, we need only one round to solve $P_0$: Node v learns sublists of its outneighbors and outputs any color $c(v) \in C_v \setminus \cup _{u\in N_{out}(v)} C_u$. This can be done since for any outneighbor u, $C_v$ and $C_u$ do not $\tau$-conflict ($|C_v\cap C_u|\le \tau -1$) and hence $|C_v\setminus \cup _{u\in N_{out}(v)} C_u| \ge k-(\tau -1)\beta >0$.

We recast the given $P_1$ instance with (identical) input lists $(L_v)_{v\in V}$ as a conflict coloring problem ${\mathfrak {P}}_1=({\mathcal {C}}_1, {\mathcal {R}}_1, {\mathcal {F}}_1,{\mathcal {L}}_1)$ with color space ${\mathcal {C}}_1={\mathcal {P}}({\mathcal {C}})$ and the $\tau$-conflict relation as ${\mathcal {R}}_1$. The list of a node ${\mathcal {L}}_1(v)={L_v\atopwithdelims ()k}$ in ${\mathfrak {P}}_1$ consists of all k-sized subsets of its input list $L_v$. As each $L_v$ is identical to ${\mathcal {C}}$, we have that ${\mathcal {L}}_1$ maps each node v to the same list ${L_v\atopwithdelims ()k}={{\mathcal {C}}\atopwithdelims ()k}$ and the list family ${\mathcal {F}}_1=\{{{\mathcal {C}}\atopwithdelims ()k}\}$ consists of that singleton. A solution to ${\mathfrak {P}}_1$ immediately solves $P_1$.

Claim 1

The conflict degree of ${\mathfrak {P}}_1$ is upper bounded by $d_1 = {k\atopwithdelims ()\tau }\cdot {{l_0-\tau } \atopwithdelims (){k-\tau }}$.

Proof

Consider two arbitrary lists $L,L'\in {\mathcal {F}}_1$ and some 0-list $C\in L$ (that is of size k). Each 0-list $C'\in L'$ that $\tau$-conflicts with C can be constructed by first choosing $\tau$ elements of C, and then adding $k-\tau$ elements from the rest of ${\mathcal {C}}$ which is of size $l_0-\tau$. This can be done in at most $d_1$ many ways. $\square$

Claim 2

Let $l_1={l_0\atopwithdelims ()k}$. For any $k\ge \tau >1$, if $l_0\ge 2ek^2/\tau$ then $l_1/d_1> 2^\tau$.

Proof

We have

$$\begin{aligned} \frac{l_1}{d_1} = \frac{{l_0\atopwithdelims ()k}}{{l_0-\tau \atopwithdelims ()k-\tau }{k\atopwithdelims ()\tau }} >\left( \frac{l_0}{k}\right) ^{\tau }\cdot \left( \frac{\tau }{ek}\right) ^{\tau } =\left( \frac{l_0\tau }{ek^2}\right) ^\tau \ge 2^\tau , \end{aligned}$$

(1)

where in the first inequality, we used the well-known approximation ${k\atopwithdelims ()\tau }\le (ek/\tau )^\tau$, and the following inequality, applied to ${l_0\atopwithdelims ()k}/{l_0-\tau \atopwithdelims ()k-\tau }$: for integers $L>K>x>0$,

$$\begin{aligned} \frac{{L\atopwithdelims ()K}}{{L-x\atopwithdelims ()K-x}}&= \frac{L!(K-x)!(L-K)!}{K!(L-K)!(L-x)!}\nonumber \\&=\frac{L(L-1)\dots (L-x+1) }{K(K-1)\dots (K-x+1)}>\left( \frac{L}{K}\right) ^{x}~, \end{aligned}$$

(2)

which follows as $(L-i)/(K-i)>L/K$ holds for $0< i\le x$. $\square$

Since $\tau \ge \lceil \log m\rceil$ and $|{\mathcal {F}}_1|=1$ the last claim implies $|{\mathcal {L}}_1(v)| =l_1>m d_1\ge m |{\mathcal {F}}_1| d_{{\mathcal {R}}_1}({\mathcal {F}}_1)$, hence we can solve ${\mathfrak {P}}_1$ (and thus also $P_1$) without communication, using Lemma 1. $\square$

What we did above is greedily forming a $\varDelta$-cover-free family $C_1,\ldots , C_m\subseteq [O(\varDelta ^2 \log m)]$ of size m. The same was done in [41], using the probabilistic method. Having such a family globally known, every vertex of input color x picks, in 0 rounds, the set $C_x$ as its candidate output colors (neighboring vertices get distinct sets). Then, every vertex of color x learns the sets C of its neighbors, and based on the $\varDelta$-cover-free property and the fact that there are at most $\varDelta$ neighbors, can select a color $c\in C_x$ that is not a candidate for any neighbor.

3 Linial for lists

The goal of this section is to prove the following theorem.

Theorem 2 (Linial for Lists). In a directed graph with max. degree $\varDelta$, max. outdegree $\beta$, and an input m-coloring, list coloring with lists $L_v$ from a color space ${\mathcal {C}}$ and of size

$$\begin{aligned} |L_v|\ge l_0=4e\beta ^2(4\log \beta +\log \log |{\mathcal {C}}|+\log \log m+8) \end{aligned}$$

can be solved in 2 rounds in LOCAL. Each node sends $l_0\cdot \lceil \log |{\mathcal {C}}|\rceil +\lceil \log m\rceil$ bits in the first round and $\lceil l_0/4e\beta ^2\rceil$ bits in the second.

Assumption

Throughout this section, we assume that the list of each node is exactly of size $l_0$; if a node has a list of size $l>l_0$ then it removes $l-l_0$ arbitrary colors from its list.

3.1 Problem $P_2$ (low intersecting sublist systems)

Recall that when applying our framework to the case where all lists were equal (Theorem 4), we essentially constructed a $\varDelta$-cover-free family over the color space, and this was sufficient because we only needed a family of size m: one set for each possible input pair (x, L) of a color x and list L, with the same L for all nodes. In order to replicate the construction for list coloring, we would need to construct a cover-free family with a set $C_{x,L}$ for every combination of color x and list L, and such that $C_{x,L}\subseteq L$. It is not hard to see that such a family does not exist.⁷ Instead, we introduce problem $P_2$, whose goal is to assign every input (x, L) a collection of candidate subsets $K_{x,L}=\{C_{x,L,1}, C_{x,L,2},\ldots \}$, where each $C_{x,L,i}\subseteq L$. Further, we need that for every pair of distinct collections, there are not many pairs of subsets from the two collections that intersect much (in a sense formally defined below). This ensures that having such $K_{x,L}$, the nodes can compute the desired $\varDelta$-cover free family with one communication round, and use it to choose a color in another round.

Problem $P_2$ depends on parameters $0<\tau \le k\le l_0$ and $0<\tau '\le k'$, and each node has a list $L_v\subseteq {\mathcal {C}}$ in its input. Instead of a color (as in $P_0$) or a sublist (as in $P_1$), each vertex v now needs to output a collection $K_v=\{C_1,C_{2},\ldots \}$ of sublists of $L_v$, each of size $k$.

• $\mathbf{P} _\mathbf{2}$ (low intersecting sublist systems): Node v has to output a 1-list $K_v\subseteq {\mathcal {P}}(L_v)$ s.t. adjacent nodes’ 1-lists do not $(\tau ',\tau )$-conflict and $|K_v|=k'$ and $|C|=k$ for all $C\in K_v$. Two 1-lists $K, K'\subseteq {\mathcal {P}}({\mathcal {C}})$ do $(\tau ',\tau )$-conflict if there are two sequences $C_1,\ldots ,C_{\tau '}\in K$ and $C'_1,\ldots ,C'_{\tau '}\in K'$,⁸ where at least one of the sequences has $\tau '$ distinct elements, and for every $1\le i\le \tau '$, $C_i$ and $C_i'$ $\tau$-conflict.

We prove in Lemma 2 that with a suitable choice of the parameters a solution of $P_2(\tau ,k,\tau ',k')$ yields a solution of $P_1(\tau ,k)$ and $P_0$, where we implicitly impose (and throughout this section assume) that $P_0, P_1$ and $P_2$ receive the same input lists $(L_v)_{v\in V}$.

3.2 Algorithm

Under the assumptions of Theorem 2, fix the following (globally known) four parameters:

$$\begin{aligned}&\tau =\lceil 8\log \beta + 2\log \log |{\mathcal {C}}| + 2\log \log m\rceil +14\\&\tau '=2^{\tau -\lceil \log (2e\beta ^2)\rceil }\\&k=\beta \cdot \tau \\&k'=\beta \cdot \tau '. \end{aligned}$$

Note that, $\tau ', k, k'$ are determined by $\tau$ and $\beta$.⁹ We have the bound $l_0\ge 2e k^2/\tau$ on list size.

The algorithm consists of two phases. In the first phase, nodes locally and without any communication compute a solution $(K_v)_{v\in V}$ of $P_2$ consisting of 1-lists (see Lemma 3). The second phase has two rounds of communication. In the first round, each node v learns the solution $K_u$ to $P_2$ of each outneighbor $u\in N_{out}(v)$, and selects a 0-list $C_v\in K_v$ that does not $\tau$-conflict with the 0-lists in $K_u$, for $u\in N_{out}(v)$, and thus is a solution to $P_1$ (Lemma 2). In the second round, node v learns the lists $C_u$ of outneighbors, and selects a color $c(v)\in C_v$ that does not appear in $C_u$, for $u\in N_{out}(v)$ (Lemma 2). This solves $P_0$.

Lemma 2

($P_2\rightarrow P_1\rightarrow P_0$) Given a solution $(K_v)_{v\in V}$ of $P_2$ (a solution $(C_v)_{v\in V}$ of $P_1$), a solution of $P_1$ (of $P_0$, resp.) can be computed in one round.

Proof

$\mathbf{P} _\mathbf{2} \rightarrow \mathbf{P} _\mathbf{1}$: As $K_v$ and $K_{u}$ do not $(\tau ',\tau )$-conflict for any $u\in N_{out}(v)$, there are at most $\tau '-1$ 0-lists $C\in K_v$ that $\tau$-conflict with a 0-list in $K_u$. By removing all C from $K_v$ that $\tau$-conflict with any $C'\in K_u$ for any outneighbor $u\in N_{out}(v)$, at least $|K_v|-\beta \cdot (\tau '-1)=k'-\beta \cdot (\tau '-1)\ge 1$ outputs remain; let $C_v$ be any such 0-list. As the conflict relation is symmetric, $P_1$ is solved.

$\mathbf{P} _\mathbf{1} \rightarrow \mathbf{P} _\mathbf{0}$: Since $C_v,C_u$ do not $\tau$-conflict, removing from $C_v$ all the colors from the 0-lists of the outneighbors leaves at least $k-\beta \cdot (\tau -1)\ge 1$ colors that v can select as c(v). $\square$

3.3 Zero round solution to $P_2$

The results in this section hold for parameters $\tau , \tau ', k'$ fixed as in Sect. 3.2, and for any $\tau \le k\le \beta \tau$. While we set $k=\beta \tau$ for solving $P_0$, we will use another value of $k$ for our defective coloring result (see Sect. 5). Note that we still have the bound $l_0\ge 2e k^2/\tau$ on list size, for any such $k$. The goal of this section is to prove the following lemma.

Lemma 3

($P_2$ in zero rounds) Under the assumptions of Theorem 2, the problem $P_2(\tau , k, \tau ', k')$ can be solved in zero rounds.

To prove Lemma 3, we reduce (without communication) an instance of $P_2$ to a conflict coloring instance ${\mathfrak {P}}_2$ that can be solved in zero rounds with Lemma 1.

Reducing $P_2$ to a conflict coloring instance (no communication): Given input lists $(L_v)_{v\in V}$ and parameters $0< \tau \le k\le l_0$ and $0<\tau '\le k$, the conflict coloring instance ${\mathfrak {P}}_2$ is given by the colorspace ${\mathcal {P}}^{(2)}({\mathcal {C}})$, the $(\tau ',\tau )$-conflict relation ${\mathcal {R}}_2$ on 1-lists, the list family ${\mathcal {F}}_2=\text {Im}(L_2)=\{L_2(S)\mid S\in {{\mathcal {C}} \atopwithdelims ()l_0}\}$ and list ${\mathcal {L}}(v)=L_2(L_v)$ for node v, where $L_2: {{\mathcal {C}}\atopwithdelims ()l_0}\rightarrow {\mathcal {P}}^{(3)}({\mathcal {C}})$ maps $l_0$-sized subsets of ${\mathcal {C}}$ to 2-lists and is defined below. The map $L_2$, the colorspace, the conflict relation and the set family ${\mathcal {F}}_2$ are global knowledge and no communication is needed to compute the list ${\mathcal {L}}(v)$ of a node in ${\mathfrak {P}}_2$.

To define the map $L_2$ we need another definition. For an integer $t\ge 0$ and a 2-list T, a 1-list $K\in T$ is $(T,t,\tau ',\tau )$-good if there are less than t 1-lists $K'\in T$ such that K and $K'$ do $(\tau ',\tau )$-conflict. We define maps $L_1$, ${\bar{L}}_2$ and $L_2$, as follows. For $S\in {{\mathcal {C}}\atopwithdelims ()l_0}$,

$$\begin{aligned} L_1(S)&={S\atopwithdelims ()k} \qquad \qquad \qquad \text {(elements} C \text { are } 0-\text {lists})\\ {\bar{L}}_2(S)&={L_1(S)\atopwithdelims ()k'} \qquad \quad \quad \text {(elements} K \text { are } 1-\text {lists})\\ L_2(S)&=\{K\in {\bar{L}}_2(S) | K \text { is } ({\bar{L}}_2(S), d_2, \tau ', \tau )-\text {good}\}~, \end{aligned}$$

where $d_2$ is chosen as in Lemma 5.¹⁰ Due to the definition of the $(\tau ',\tau )$-conflict relation and the map $L_2$, solving ${\mathfrak {P}}_2$ immediately solves $P_2$.

The sizes of $L_1(S), {{\bar{L}}}_2(S)$ and $L_2(S)$ do not depend on S. Let $l_1=|L_1(S)|={l_0 \atopwithdelims ()k}$, and $l_2=|\bar{L}_2(S)|/2={l_1 \atopwithdelims ()k'}/2$. We will later show that $|L_2(S)|\ge l_2$. Let ${\mathcal {F}}_1=\{L_1(S)\mid S\in {{\mathcal {C}} \atopwithdelims ()l_0}\}$.

Some intuition: In the conflict coloring instance ${\mathfrak {P}}_2$, every node v has a list $\{K_1, K_2, \ldots \}$ of 1-lists, each a collection of subsets of its input list $L_v$. To ensure small conflict degree, but still large list size, it is enough that v only takes Ks that are “good”, as defined above. Since being “good” only depends on $L_v$, node v can also compute its ${\mathfrak {P}}_2$-list locally.

In Lemmas 4,  5, 6, we show that lists $L_2(L_v)$ are large and that ${\mathfrak {P}}_2$ has small conflict degree. Before that, let us see how these lemmas imply 0-round solvability of $P_2$ (Lemma 3).

Proof (of Lemma 3)

To solve an instance of $P_2$ on input lists $(L_v)_{v\in V}$, nodes locally set up the conflict coloring instance ${\mathfrak {P}}_2$. Lemmas 4 and 5 show that the conflict degree of ${\mathfrak {P}}_2$ is bounded by $d_{{\mathcal {R}}_2}({\mathcal {F}}_2)\le d_2$, and that every list in ${\mathcal {F}}_2$ has size at least $l_2$. Note that ${\mathcal {F}}_2$ is globally known and $|{\mathcal {F}}_2| = {|{\mathcal {C}}|\atopwithdelims ()l_0}<|{\mathcal {C}}|^{l_0}$, since each element in ${\mathcal {F}}$ can be written as $L_2(S)$ for some $S\in {{\mathcal {C}}\atopwithdelims ()l_0}$. Using Lemma 6 we obtain $l_2/d_2\ge \frac{1}{8}2^{2^{\tau -\log (4e\beta ^2)}}\ge m\cdot |{\mathcal {C}}|^{l_0}>m\cdot |{\mathcal {F}}_2|$, where the second inequality follows by a routine calculation (following hereafter) using the definition of $\tau$ and $l_0$. Thus, Lemma 1 holds, and ${\mathfrak {P}}_2$ and $P_2$ can be solved in zero rounds.

Next, we perform the missing calculation. We use $\tau =\lceil 8\log \beta + 2\log \log |{\mathcal {C}}| + 2\log \log m\rceil +14$, and $l_0= 2e\beta ^2(\tau +1)$, to deduce that $(1/8) \cdot 2^{2^{\tau -\log (4e\beta ^2)}}\ge m|{\mathcal {C}}|^{l_0}$ holds. We have (explanation below):

$$\begin{aligned}&\log \log \left( 8m\cdot |{\mathcal {C}}|^{l_0}\right) \\&\quad \le \log \log m + \log \log C+\log l_0 +\log 3\\&\quad \le \log \log m + \log \log C+\log 6e + 2\log \beta +\log (\tau +1) \ \\&\quad \le \tau /2+ \log \log m + \log 6e+ 2\log \beta +\log \log C \\&\quad \le \tau /2+\tau /2 -\log (4e\beta ^2) =\tau -\log (4e\beta ^2) , \end{aligned}$$

where in the first inequality, we used $\log (x+y)\le \log x + \log y$, for $x,y\ge 1$, in the second one we used $l_0=2e\beta ^2(\tau +1)$, in the third we used $\log (\tau +1) \le \tau /2$ (holds for $\tau \ge 6$), while in the last one we used $\tau /2\ge 4\log \beta + \log \log |C| + \log \log m + 7$.

Exponentiating (with base 2) both sides twice gives us the claim. $\square$

We continue with proving Lemmas 4,  5, 6. First, we bound the conflict degree of ${\mathfrak {P}}_2$ by $d_2$ (from the definition of $L_2$). Note that it is a property of the list family ${\mathcal {F}}_2$ and the conflict relation ${\mathcal {R}}_2$, and is independent of the graph and list assignment. From the definition of $L_2$, the value $d_2$ can be seen as a bound on the number of 1-lists in $L_2(X)$ that conflict with a given 1-list K in $L_2(X)$. The intuition behind the lemma is that $L_2(Y)$, for $Y\ne X$, should have fewer conflicts with K, since Y can be obtained from X by removing some elements and adding new ones (which do not appear in K). The proof involves establishing an isomorphism between $L_2(X)$ and $L_2(Y)$, which preserves their common elements. For this, it is crucial to have $|X|=|Y|$. This is why we need all input lists to have same size $|L_v|=l_0$.

Lemma 4

(Conflict Degrees) Let $X,Y\in {{\mathcal {C}}\atopwithdelims ()l_0}$ be 0-lists. Let $d_1= {k\atopwithdelims ()\tau }\cdot {{l_0-\tau } \atopwithdelims (){k-\tau }}$.

• 1. For any 0-list $C\in L_1(X)$, there are at most $d_1$ 0-lists in $L_1(Y)$ that $\tau$-conflict with C.

• 2. For any 1-list $K\in L_2(X)$, there are at most $d_2$ 1-lists in $L_2(Y)$ that $(\tau ',\tau )$-conflict with K. In particular, $d_{{\mathcal {R}}_2}({\mathcal {F}}_2)\le d_2$, and this holds irrespective of the value of $d_2$.

Proof

The proof of the first claim is along the same lines as the proof of Claim 1, so we only prove the second claim here. Let $X_1=L_1(X),X_2=L_2(X)$ and ${{\bar{X}}}_2={{\bar{L}}}_2(X)$, and define $Y_1,Y_2,{{\bar{Y}}}_2$ similarly. As $|X|=|Y|$, there is a bijection between X and Y that is the identity on $X\cap Y$. Let $\alpha : X\rightarrow Y$ be an arbitrary such bijection; if $c\in X\cap Y$ then $\alpha (c)=c$. Further, since $X_1={X \atopwithdelims ()k}$ and $Y_1={Y \atopwithdelims ()k}$, we have the bijection $\beta :X_1\rightarrow Y_1$ given by $\beta (\{c_1,\dots ,c_k\})=\{\alpha (c_1),\dots ,\alpha (c_k)\}$, and since ${\bar{X}}_2={X_1 \atopwithdelims ()k'}$ and ${\bar{Y}}_2={Y_1 \atopwithdelims ()k'}$, we have the bijection $\gamma :{\bar{X}}_2\rightarrow {\bar{Y}}_2$, where $\gamma (\{C_1,\dots ,C_{k'}\})=\{\beta (C_1),\dots ,\beta (C_{k'})\}$.

We show that the claim holds for any $t\ge 0$ and for any $K\in {\bar{X}}_2$ that is $({\bar{X}}_2,t,\tau ',\tau )$-good (which demonstrates that the actual value of $d_2$ is irrelevant). As $Y_2\subseteq {\bar{Y}}_2$, it suffices to show that K does $(\tau ',\tau )$-conflict with at most t 1-lists in ${\bar{Y}}_2$. Towards a contradiction, let $K\in {\bar{X}}_2$ $(\tau ',\tau )$-conflict with each of t distinct 1-lists $K'_1,K'_2,\dots ,K'_t\in {\bar{Y}}_2$ and define $K_i=\gamma ^{-1}(K'_i)\in {\bar{X}}_2$. We show that K also $(\tau ',\tau )$-conflicts with each of the distinct ($\gamma$ is a bijection) $K_1,\ldots , K_{t}\in {\bar{X}}_2$, which is a contradiction to K being $({\bar{X}}_2,t,\tau ',\tau )$-good: To ease notation, let us focus on K and $K_1$. Assume that there are $\tau '$ distinct (case 2: not necessarily distinct) 0-lists $C'_1,C'_2,\dots ,C'_{\tau '}$ in $K'_1$, and $\tau '$ not necessarily distinct (case 2: distinct) 0-lists $C_1,C_2,\dots ,C_{\tau '}$ in K, such that $C_i$ and $C'_i$ $\tau$-conflict. Then $\beta ^{-1}(C'_i)$ and $C_i$ $\tau$-conflict, since $\alpha$ is the identity on $C_i\cap C'_i$, $\beta ^{-1}(C'_i)$ are all distinct (since $\beta$ is a bijection) and belong to $K_1$, therefore K and $K_1$ $(\tau ',\tau )$-conflict. $\square$

Next, we show that at most half of the elements $K\in {\bar{L}}_2$ fail to be good; this lemma crucially depends on the value of $d_2$. Below, we use the conflict degree $d_1$ from Lemma 4.

Lemma 5

($L_2$ is large) Let $d_2=4{k'd_1 \atopwithdelims ()\tau '}\cdot {l_1-\tau '\atopwithdelims ()k'-\tau '}$. For any $S\in {{\mathcal {C}}\atopwithdelims ()l_0}$, we have $|L_2(S)|\ge l_2$.

Proof

Fix $S\in {{\mathcal {C}}\atopwithdelims ()l_0}$ and consider the digraph $H=(V_H,E_H)$ over the vertex set $V_H={\bar{L}}_2(S)$, where $(K,K')\in E_H$ iff K contains at least $\tau '$ lists, each in $\tau$-conflict with a list in $K'$ (in particular, for every K, $(K,K)\in E_H$). Note that a 1-list K is $({\bar{L}}_2(S),d_2,\tau ',\tau )$-good iff its undirected degree in H is at most $d_2$.

Claim 3

The maximum outdegree of a node $K\in V_H$ is at most $d_2/4$.

Proof

Consider a fixed $K\in V_H$. Let $X\subseteq K$ be the set of 0-lists in $L_1(S)$ that $\tau$-conflict with a 0-list in K. By Lemma 4 part 1, every $C\in K$ $\tau$-conflicts with at most $d_1$ of 0-lists, hence $|X|\le |K|\cdot d_1=k'd_1$. Every 1-list $K'$, such that there are at least $\tau '$ 0-lists in K that are in $\tau$-conflict with a 0-list in $K'$, can be obtained by first choosing $\tau '$ 0-lists from X, and adding an arbitrary subset of $k'-\tau '$ other 0-lists. Clearly, this can be done in at most ${k'd_1 \atopwithdelims ()\tau '}\cdot {l_1-\tau '\atopwithdelims ()k'-\tau '}=d_2/4$ many ways. $\square$

The Claim implies that $|E_H|\le |V_H|\cdot d_2/4$, hence the undirected average degree of a node in H is at most $2|E_H|/|V_H| \le d_2/2$, and by Markov’s inequality, at most half of the nodes have degree greater than $d_2$. Since $L_2(S)$ is the set of nodes of degree at most $d_2$, we conclude that $|L_2(S)|\ge |V_H|/2=|{\bar{L}}_2(S)|/2=l_2$. $\square$

Finally, we bound the ratio $l_2/d_2$ based on the values of the remaining parameters.

Lemma 6

(l/d Ratio) If $k\ge \tau \ge \lceil \log (2e\beta ^2)\rceil$, $l_0\ge 2ek^2/\tau$, $\tau '=2^{\tau -\lceil \log (2e\beta ^2)\rceil }$, and $k'=\beta \tau '$, then

$$\begin{aligned} l_2/d_2> 2^{2^{\tau -\log (4e\beta ^2)}}/8\ . \end{aligned}$$

Proof

First, we get $l_1/d_1\ge 2^{\tau }$, as in Eq. (1). Then, with ${k'd_1\atopwithdelims ()\tau '}\le (\frac{ekd_1}{\tau '})^{\tau '}$, and (2) applied to ${l_1\atopwithdelims ()k'}/{l_1-\tau '\atopwithdelims ()k'-\tau '}$, we lower bound $l_2/d_2$ as

$$\begin{aligned} \frac{l_2}{d_2}&=\frac{1}{8} \frac{{l_1\atopwithdelims ()k'}}{{l_1-\tau '\atopwithdelims ()k'-\tau '}{k'd_1\atopwithdelims ()\tau '}} >\frac{1}{8}\left( \frac{l_1}{k'}\cdot \frac{\tau '}{e(k'd_1)} \right) ^{\tau '}\\&\ge \frac{1}{8}\left( \frac{2^{\tau }}{e\beta ^2\tau '}\right) ^{\tau '}{\ge }\frac{2^{\tau '}}{8}\ge \frac{2^{2^{\tau -\log (4e\beta ^2)}}}{8}\ , \end{aligned}$$

where the third and fourth inequalities hold since $\tau '\le \frac{2^\tau }{2e\beta ^2}\le 2\tau '$. $\square$

3.4 Proof of the main theorem

Proof (of Theorem 2)

Nodes solve $P_2$ without communication (Lemma 3), then use two rounds of communication to solve the input list coloring problem $P_0$ (see algorithm description and Lemma 2).

We bound the messages sent by a node v during the algorithm. In the first round, v needs to send $K_v$ to its neighbors. Note that $K_v$ is uniquely determined by the list $L_v$ and the input color $\psi _v$ (see the proof of Lemma 1) , so it suffices to send $(\psi _v,L_v)$, which can be encoded in $l_0\lceil \log |{\mathcal {C}}|\rceil +\lceil \log m\rceil$ bits. In the second round, v needs to send $C_v$. Since $C_v\in K_v$, and the neighbors know $K_v$, it suffices to send the index of $C_v$ in $K_v$ (in a fixed ordering). Recall that $|K_v|=k'<2^\tau$, so v only needs to send $\tau \le l/4e\beta ^2$ bits. $\square$

Remark 1

Note that in both communication rounds of Theorem 2 each node only needs to send messages to its in-neighbors. In contrast, the results in Sects. 4 and 5 require bi-directional communication.

4 Application: $(\varDelta +1)$-coloring and $({\text {deg}}+1)$-List Coloring

Theorem 3(Restatement). In a graph with max. degree $\varDelta$, $({\text {deg}}+1)$-list coloring problem with lists $L_v\subseteq {\mathcal {C}}$ from a color space of size $|{\mathcal {C}}|=2^{{\text {poly}}(\varDelta )}$ can be solved in $O(\sqrt{\varDelta \log \varDelta })+\frac{1}{2}\cdot \log ^*n$ rounds in LOCAL. Furthermore, each node only needs to broadcast to its neighbors a single non-CONGEST message consisting of a subset of its list.

The proof combines Theorem 2 with the graph partitioning provided by [12], following the high level description in Sect. 1. A variant of this framework was also used in [6, 37]. We nevertheless present a proof for completeness, and also due to subtle but important differences from [23] (we have an additional finishing phase that is not present there).

The graph partitioning given by [12] aims at arbdefective colorings, as introduced in [10], but the main technical object provided by [12] (and which is all we need here) is a low outdegree partition of a graph. For a graph $H=(V,E)$, the collection $H_1,\dots ,H_k$ of directed graphs $H_i=(V_i,E_i)$ is a $\beta$-outdegree partition of H if their vertices span V, i.e., $V=V_1\cup \dots \cup V_k$, the underlying undirected graph of $H_i$ is the induced subgraph $H[V_i]$ (so it is indeed a partition), and the max. outdegree of a node in $H_i$ is at most $\beta$, for all i.

Lemma 7

(Lemmas 6.1-6.3, [12, 42]) There are constants $c,c'>0$, s.t. for every $\beta \ge c$, given a graph H with an m-coloring, there is a deterministic algorithm that computes a $\beta$-outdegree partition $H_1,\dots ,H_k$ with $k=c'\varDelta /\beta$ in $O(k+\log ^*m)$ rounds in CONGEST.

Proof (of Theorem 3)

We begin with computing an $m=O(\varDelta ^2)$-coloring in $\frac{1}{2}\log ^*n+O(1)$ rounds [41, 49]. The main algorithm consists of $t=\log _2(\varDelta /\varDelta ^{1/4})$ phases. After phase j, we have colored a subset of vertices, s.t. the maximum degree $\varDelta _j$ of the graph $G[U_j]$ induced by uncolored vertices is upper bounded as $\varDelta _j\le \varDelta /2^j$. Before describing a phase j, let us show how we finish the coloring after the phase t, in a final phase. Consider the graph $G[U_t]$ at the end of phase t. Note that it has maximum degree $\varDelta _t=O(\varDelta ^{1/4})$. We compute an $m'$-coloring of $G[U_t]$ with $m'=O(\varDelta _t^2)=O(\sqrt{\varDelta })$ from the initial m-coloring in O(1) rounds [41]. In each of the final $m'$ rounds $i=1,\dots ,m'$, vertices with color i pick a color from their list not picked by a neighbor (can be done since each node has more available colors than uncolored neighbors, and no two neighbors pick simultaneously). The runtime of the final phase is $O(\sqrt{\varDelta })$.

The following happens in phase $j=1,\dots ,t$. At the beginning of the phase, we have the set $U_{j-1}$ of uncolored vertices, where $U_0=V(G)$. Let $X=4e \cdot (4\log \varDelta +\log \log |{\mathcal {C}}|+\log \log m+8)=O(\log \varDelta )$ and for $j=0,\ldots ,t-1$ let $\beta _j=\sqrt{\varDelta _j/(2X)}$ and $k_j=c' \cdot \varDelta _j/\beta _j$, where $c'$ is the constant in Lemma 7.¹¹ We partition $G[U_{j-1}]$ into $\beta _j$-outdegree subgraphs $H_1,H_2,\dots ,H_{k_j}$, using Lemma 7. The phase consists of $k_j$ stages $i=1,\dots ,k_j$, each consisting of 3 rounds. In stage i , we partially color $H_i$, as follows. For every uncolored vertex $v\in H_i$, let $L_{v,j,i}$ be the set of colors in $L_v$ that have not been taken by a neighbor of v. Let $W_i=\{v\in H_i : |L_{v,j,i}|\ge \beta _j^2X\}$. Color the graph $H_i[W_i]$ using Linial for Lists (Theorem 2) with color space ${\mathcal {C}}$, the $\beta _j$-outdegree orientation and the m-coloring. This is a valid application of the theorem, by the definition of X, $\beta _j$ and $W_i$. In the third round of the stage, all nodes in $W_i$ send their color to their neighbors. This completes the algorithm description. Clearly, phase j takes $3k_j$ rounds.

It remains to show that $\varDelta _j\le \varDelta /2^j$. We do this by induction, with base $j=0$, $\varDelta _0=\varDelta$. Assume $\varDelta _j\le \varDelta /2^j$ holds for some $j\ge 0$. Let $v\in U_j$ be a node that is uncolored at the end of phase j. We know that $|L_{v,j,i}|<\beta _j^2X=\varDelta _j/2$, in a stage i. Recall that $L_{v,j,i}$ is the set of colors in $L_v$ not taken by a neighbor of v. Since $|L_v|$ is larger than the number of neighbors of v, $|L_{v,j,i}|$ is larger than the number of uncolored neighbors of v. Therefore v has at most $|L_{v,j,i}|< \varDelta _j/2\le \varDelta /2^{j+1}$ neighbors in $U_j$, which proves the induction: $\varDelta _{j+1}\le \varDelta /2^{j+1}$.

Recall that $X=O(\log \varDelta )$ and bound the runtime as follows:

$$\begin{aligned}&\frac{1}{2}\log ^* n +O(1) + \sum _{j=1}^{t} 3k_j+m'\\&\quad =\frac{1}{2}\log ^* n +\sum _{j=1}^{t} 3c'\sqrt{\frac{X\varDelta }{2^{j-1}}}+O(\sqrt{\varDelta }) \\&\quad =\frac{1}{2}\log ^* n+O(\sqrt{\varDelta \log \varDelta }) . \end{aligned}$$

The second claim easily follows, recalling the message complexity of Linial for Lists. $\square$

Note that the final phase in the algorithm above is necessary as otherwise, if the recursion continued until the maximum degree of uncolored nodes was, say, $O(\log ^{(3)}\varDelta )$, their reduced list size would be similarly small, and we could no longer apply Theorem 2, which requires lists of size $\varOmega (\log \log |{\mathcal {C}}|)=\varOmega (\log \log \varDelta )$, as the color space does not change in the recursion.

Corollary 1

In a graph with max. degree $\varDelta ={\tilde{O}}(\log n)$, $({\text {deg}}+1)$-list coloring problem with lists $L_v\subseteq {\mathcal {C}}$ from a color space of size $|{\mathcal {C}}|={{\text {poly}}(\varDelta )}$ can be solved in ${\tilde{O}}(\sqrt{\varDelta })+\frac{1}{2}\cdot \log ^*n$ rounds in CONGEST.

Proof

In the algorithm of Theorem 3 each vertex only participates in a single instance of Linial for lists, and all other steps of the algorithm can be implemented in CONGEST. Thus, as stated above, the only non-CONGEST message M of a node consists of a subset of its list. Note that we can always limit the lists to size $\varDelta +1$, so the number of colors in M is at most $\varDelta +1$. Each color can be encoded in $O(\log |{\mathcal {C}}|)=O(\log \varDelta )$ bits. Thus, M can be encoded in $O(\varDelta \log \varDelta )$ bits. By the assumption of the claim, we have $\varDelta \le a\log n \cdot (\log \log n)^b$, for constants $a\ge 1,b\ge 0$. It follows that $\varDelta \log \varDelta \le a\log n \cdot (\log \varDelta )^{b+1}$, as otherwise we would have $\varDelta>a\log n (\log \varDelta )^b>a\log n (\log \log n)^b$. Thus, each node sends at most $O(\varDelta \log \varDelta /\log n)=O((\log \varDelta )^{b+1})$ messages more than in the LOCAL algorithm, and the runtime increases by the corresponding factor. $\square$

5 Defective (list) coloring

A d-defective c-coloring is a c-coloring where each vertex v can have at most d neighbors with the same color as v. A d-defective list coloring is a list coloring where each vertex v can have at most d neighbors with the same color as v. As proven in [36], one can compute a d-defective $O((\varDelta /(d+1))^2\log m)$-coloring, given an m-coloring, in one round in CONGEST. As a warm up to our “list version”, we re-prove this result by adapting the proof of Theorem 4.

Theorem 5

([36]) Let $d\ge 0$ be an integer. In a graph with max. degree $\varDelta >d$ and an input m-coloring, d-defective coloring problem with $2e\cdot \lceil \varDelta /(d+1)\rceil ^2\cdot \lceil \log _2 m\rceil$ colors can be computed in one round in CONGEST.

Proof

We adapt the proof of Theorem 4. Note that the proof holds when G is not directed, and $\beta$ is replaced with $\varDelta$. For a consistent notation, let $\beta =\varDelta$. Also, let $P_1(a, b)$ denote problem $P_1$ under the parameter setting $\tau =a$ and $k=b$. First, we solve problem $P_1(\tau ,k)$ with parameters $\tau =\lceil \log m\rceil$, $k=\lceil \beta /(d+1)\rceil \tau$. As Claim 2 holds for any $k\ge \tau \ge \log m$ and $l_0\ge 2ek^2/\tau$ the corresponding $P_1(\tau ,k)$ can be solved locally with list size $l_0\ge 2ek^2/\tau =2e\lceil \beta /(d+1)\rceil ^2\tau$, which holds by our theorem assumption. Let $(C_v)_{v\in V}$ be the solution to $P_1$, with $|C_v|=k$. Let v be a node. Since the solution is conflict free, we have $|C_v\cap C_u|< \tau$, for every neighbor of v. For a color $c\in C_v$, let f(c) be the number of neighbors u s.t. $c\in C_u$. It follows that $\sum _{c\in C_v}f(c)<\beta \tau$, hence there is a color $c\in C_v$ with $f(c)<\beta \tau /|C_v|\le d+1$. Each node v picks a color $c\in C_v$ with minimum f(c). $\square$

Note that, as for Theorem 4, the set systems in the proof of Theorem 5 are computed greedily. The theorem also works with a $d_1$-defective m-coloring as input. The defect of the output coloring is then $d+d_1$. Applying this result iteratively and combining it with another set system construction based on polynomials over finite fields, one can compute a d-defective $O((\varDelta /(d+1))^2)$-coloring in $O(\log ^*m)$ rounds from a given m-coloring [36, 13, Section 3.2].

Theorem 6

(Defective List Coloring) Let $d\ge 0$ be an integer. In a graph with max. degree $\varDelta >d$ and an input m-coloring, d-defective list coloring problem with lists $L_v$ from a color space ${\mathcal {C}}$ and of size $|L_v|\ge l=4e\lceil \varDelta /(d+1)\rceil ^2 \cdot (4\log \varDelta + \log \log |{\mathcal {C}}| + \log \log m+8)$ can be solved in 2 rounds in LOCAL, if ${\mathcal {C}}$, m and $\varDelta$ are globally known.

Proof

As in Theorem 5, observe that our whole analysis of Linial for lists holds in the case when G is not directed, and $\beta$ is replaced with $\varDelta$. Let $\beta =\varDelta$, as before. First, we solve problems $P_2$ and $P_1$ with parameters $\tau ,\tau ',k'$ as in Sect. 3.3, and $k=\lceil \beta /(d+1)\rceil \tau$ (as observed in the beginning of Sect. 3.3, $P_2$ and $P_1$ can be solved for any $\tau \le k\le \beta \tau$). Thus, we require the list size of each node to be at least $l_0\ge 2ek^2/\tau$, which holds. Given a solution of $P_1$, we can obtain the d-defective coloring in the same manner as in Theorem 5. $\square$

6 Discussion

We conclude with several observations on our results, as well as open problems.

• 1. It is possible to define problems $P_3,\ldots , P_t$ for any t, as we defined $P_1$ and $P_2$. Lemma 4 extends naturally to these problems, so the input of a node v in $P_i$ is again only its initial list $L_v$. We need t rounds, instead of 2, to derive a solution of $P_0$ from a solution of $P_t$ (which also implies larger messages). On the other hand, we have somewhat smaller list size requirement: $c\beta ^2(\log \beta + \log ^{(t)} |{\mathcal {C}}|+\log ^{(t)} m)$, for a constant $c>0$. In particular, one can list color in $O(\log ^*\max \{|{\mathcal {C}}|,m\})$ rounds if lists are at least $c\beta ^2\log \beta$ for a sufficiently large constant $c>0$.

• 2. Unlike in [23], our bound on the list size does not depend on $\varDelta$. This result implies that, e.g., given a graph with a $\beta$-outdegree orientation and an input coloring with $2^{{\text {poly}}(\beta )}$ colors and list sizes of at least $c\beta ^2\cdot \log \beta$ from a color space of size $2^{{\text {poly}}(\beta )}$, for a constant $c>0$, it is possible to list-color the graph in 2 rounds. By the remark above, one can have even larger color space, by increasing the runtime accordingly.

• 3. A lower bound in [49] suggests that the coloring in Theorem 2 cannot be done in a single round. In particular, if one is willing to keep the doubly-logarithmic dependence on m in the list size, then one has to pay a factor exponential in $\beta$. On the other hand, we do not know how to eliminate the $\log \beta$ term, even if we use more communication.

• 4. The recently popular speedup technique has mostly been used to prove lower bounds, e.g., [2,3,4, 16,17,18]. Here, a problem $P_0$ is mechanically (and without communication!) transformed into a problem $P_1$ whose complexity is exactly one round less. Then, if $P_1$ cannot be solved locally one deduces that $P_0$ cannot be solved in 1 round. By iterating this process, one can derive larger lower bounds. However, the description complexity of derived problems grows exponentially, and it is very important to be able to simplify the problem description, in order to iterate the process. If $P_0$ is the $(\varDelta +1)$-vertex coloring problem, this process has only been understood in the special case of $\varDelta =2$, which corresponds to Linial’s $\varOmega (\log ^*n)$ lower bound [40, 41]. While [23] also performs a similar transformation, it is different from the speedup technique, since the transformation is not mechanical, requiring nodes to communicate for building the new problems. It may rather be seen as a transformation of problem instances (that depend on the graph) than problems. In contrast, our transformations are mechanical, and the input and output labels live in the same universe as it is the case for mechanical speedup.

• 5. While our present treatment of the proof of Theorem 2 in terms of conflict coloring problems and problems $P_0, P_1$ and $P_2$ has the aim of connecting to the framework of [23] as well as to the speedup framework, we note that the proof can be stated entirely in terms of set systems, just like the proof of Linial’s color reduction.

• 6. Linial used the probabilistic method to show the existence of large low intersecting set families required for solving $P_1$ in the setting of identical lists. As we saw in Sect. 2.3, such families can also be constructed greedily. We also used a greedy algorithm for the construction of the low intersecting set systems for problem $P_2$. It is therefore an interesting question whether the probabilistic method can be used to show the existence of low intersecting set systems with similar or better parameters.

• Open Problem: Remove the $\log \beta$ term in Theorem 2 while keeping the runtime $o(\sqrt{\log \beta })$.

This question is particularly of interest because $\log \beta$ is the source of the $\sqrt{\log \varDelta }$ factor in in Theorem 3 (note that the terms depending on $m,|{\mathcal {C}}|$ can be reduced, by the remarks above). The non-list $O(\varDelta ^2)$-coloring by Linial uses, in addition to his main color reduction, an $O(\varDelta ^3)$-to-$O(\varDelta ^2)$ color reduction, using polynomials over finite fields [41]. With a more sophisticated use of polynomials [8] constructs a cover-free family for list coloring but it requires a much smaller outdegree. It is not clear if polynomials help with our question.

• Open Problem: More generally, prove or rule out a truly local $(\varDelta +1)$-coloring algorithm with $\varDelta$-dependence $f(\varDelta )=o(\sqrt{\varDelta })$.

A color reduction via greedy construction of cover-free families

For an integer $\varDelta \ge 1$, a $\varDelta$-cover free family ${\mathcal {F}}\subseteq 2^U$ over a universe U is a collection of subsets of U, such that no set in ${\mathcal {F}}$ is contained in the union of $\varDelta$ others.

To be self contained we quickly repeat how [41] use such families to reduce a coloring: Suppose a graph G of max. degree $\varDelta$ is m-colored and there is a globally known $\varDelta$-cover free family ${\mathcal {F}}=\{C_1,C_2\dots \}$ with $|{\mathcal {F}}|\ge m$ over a universe $U=[m']$. Then G can be recolored with $m'$ colors, as follows. Every node v of input color x selects $C(v)=C_x\subseteq U$, sends x to its neighbors, after which every node picks a color $y\in C(v)\setminus \cup _{u\in N(v)}C(u)$: y exists since $|N(v)|\le \varDelta$ and ${\mathcal {F}}$ is $\varDelta$-cover free. By the choice of y, the coloring is proper.

Theorem 7

For integers $\varDelta \ge 2$ and $m\ge 3$, there is a greedy algorithm that constructs a $\varDelta$-cover free set family ${\mathcal {F}}$ of size m over a universe of size at most $5.2\varDelta ^2\log _2(em)$.

Proof

Let $z=\lceil \ln m\rceil$, $x=\varDelta z$ and $l=\lceil e^2x/z\rceil$, and note that $z\le x$. Let ${\mathcal {P}}$ be the set of all functions from [x] to [l]. Two functions conflict if they agree on at least z inputs. Consider the following greedy procedure for selecting a conflict-free set ${\mathcal {R}}$ of functions:

• ${\mathcal {R}}\leftarrow \emptyset$, ${\mathcal {T}}\leftarrow {\mathcal {P}}$,

• while ${\mathcal {T}}\ne \emptyset$

  • ${\mathcal {R}}\leftarrow {\mathcal {R}}\cup \{f\}$ for arbitrary $f\in {\mathcal {T}}$

  • ${\mathcal {T}}\leftarrow {\mathcal {T}}\setminus \{g\in {\mathcal {T}}\mid g \text { conflicts with } f\}$.

No pair of functions in ${\mathcal {R}}$ conflict: After each iteration of the while-loop the set ${\mathcal {T}}$ only contains functions that do not conflict with any function in ${\mathcal {R}}$. Thus, in each iteration the function $f\in {\mathcal {T}}$ that we add to ${\mathcal {R}}$ does not conflict with any previously picked function in ${\mathcal {R}}$.

$|{\mathbf {\mathcal {R}}}|\ge \mathbf{m}$: For a given function f, there are at most $d={x \atopwithdelims ()z} l^{x-z}$ functions in ${\mathcal {P}}$ that conflict with f: every such function can be obtained by making it agree with f at some z inputs, and choosing the value on the rest of the inputs arbitrarily. Therefore, the number of functions removed from ${\mathcal {T}}$ at every step is at most d. Thus, the process runs for at least $|{\mathcal {P}}|/d$ iterations and using ${x \atopwithdelims ()z}\le (ex/z)^z$, $l\ge e^2x/z$, and $z\ge \ln m$ we obtain $|{\mathcal {R}}|\ge \frac{|{\mathcal {P}}|}{d}\ge \left( \frac{l\cdot z}{e\cdot x}\right) ^z\ge e^z\ge m$ .

Now, the $\varDelta$-cover-free family ${\mathcal {F}}$ over the universe $U=[x]\times [l]$ consists of sets $S_f=\{(i,f(i))\mid i\in [x]\}\subseteq U$, for all $f\in {\mathcal {R}}$. Let $f\ne g\in {\mathcal {R}}$. Since f and g do not conflict, there are at most $z-1$ values $i\in [x]$, s.t. $f(i)=g(i)$. Therefore, $|S_f\cap S_g|\le z-1$. Since $|S_f|=x=z\varDelta$, for every $\varDelta$ distinct functions $g_1,\dots ,g_\varDelta \in {\mathcal {R}}\setminus \{f\}$, we have $|S_f\setminus \cup _{t=1}^\varDelta S_{g_t}|\ge x-\varDelta (z-1)=\varDelta$. The size of the universe is $|U|=x\cdot l\le 7.4\varDelta ^2z\le 7.4\varDelta ^2 \ln (em)\le 5.2\varDelta ^2\log _2(em)$. $\square$