Linial for lists

Linial’s famous color reduction algorithm reduces a given m-coloring of a graph with maximum degree Δ\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\varDelta $$\end{document} to an O(Δ2logm)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\varDelta ^2\log m)$$\end{document}-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 β\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\beta $$\end{document}, if every node has a list of size Ω(β2(logβ+loglogm+loglog|C|))\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\varOmega (\beta ^2 (\log \beta +\log \log m + \log \log |{\mathcal {C}}|))$$\end{document} from a color space C\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$${\mathcal {C}}$$\end{document} 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(deg+1)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$({\text {deg}}+1)$$\end{document}-list coloring algorithm from Barenboim et al. (PODC, pp 437–446, 2018) by slightly reducing the runtime to O(ΔlogΔ)+log∗n\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\sqrt{\varDelta \log \varDelta })+\log ^* n$$\end{document} and significantly reducing the message size (from ΔO(log∗Δ)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\varDelta ^{O(\log ^* \varDelta )}$$\end{document} to roughly Δ\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\varDelta $$\end{document}). Our techniques are inspired by the local conflict coloring framework of Fraigniaud et al. (in: FOCS, pp 625–634, 2016).


Introduction
Symmetry breaking problems are a cornerstone of distributed graph algorithms in the LOCAL model. 1 A central question in the area asks: How fast can these problems be solved in terms of the maximum degree Δ, 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  2 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. (Δ + 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 (Δ) = Θ(Δ), 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 (Δ) =Õ( √ Δ) and lower bound f (Δ) = Ω (1). While most work has focused on the (Δ+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 ⊆ C of colors from a colorspace 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 (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(Δ 2 )-coloring can be done in O(log * n) rounds. Szegedy and Vishwanathan [49] improved the runtime to 1 2 log * n + O (1), and showed that in additional O(Δ · log Δ) rounds, the O(Δ 2 )-coloring could be reduced to (Δ + 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 (Δ + 1)-coloring down to O(Δ + 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 (deg +1)list coloring, since given an O(Δ)-coloring, one can use it as a "schedule" for computing a (deg +1)-list coloring in O(Δ) additional rounds. Meantime, two sub-linear in Δ 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(Δ 3/4 + log * n) rounds ([8]+ [12]), 3 while the fastest LOCAL algorithm needs O( √ Δ log Δ log * Δ + 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(Δ/β) subgraphs, each equipped with a β = O( √ Δ/ log Δ)-outdegree orientation, in O( p) + 1 2 log * n rounds [12], (2) a list coloring subroutine that gives rise to the following [23]: In a directed graph with max. degree Δ, max. outdegree β, and an input m-coloring, list coloring problem with lists L v of size |L v | ≥ 10β 2 ln Δ from any color space can be solved in O(log * (Δ + m)) rounds in LOCAL.
The two ingredients are combined to give a (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 3 For more colors, i.e., (1 + ε)Δ-coloring, [8] gives runtime O( √ Δ + log * n) in CONGEST. sufficiently large lists (≥ 10β 2 ln Δ). With a fine grained choice of β it is ensured that every node v with (refined) list size greater than Δ/2 is colored. Thus, after iterating through all p subgraphs, all uncolored nodes have list size at most Δ/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.

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 Δ, max. outdegree β, and an input m-coloring, list coloring problem with lists L v from a color space C and of size |L v | ≥ l 0 = 4eβ 2 (4 log β + log log |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 /β 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Δ 2 log m)coloring in a single round [41]. Moreover, our framework is itself a natural generalization of Linial's approach of coverfree 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 Δ) (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 Δ from the bound on the list size, reduce the runtime to exactly 2 rounds, and dramatically reduce message size. This is achieved by a nontrivial 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 (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 (deg +1)list coloring algorithm.
· 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 poly(Δ) which could be ω(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 (Δ + 1)-coloring algorithm in LOCAL. Below we list further implications of our framework.

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-conflictdegree (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 , . . . , 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 + Δ).
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 , . . . , 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 algo-rithm 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).

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 Δ-dependence in the runtime with lower n-dependence. All deterministic algorithms in this category (for general input graphs) involve a Ω(log n) factor. From the early 90s until very recently, the complexity of (deg +1)-list coloring (and (Δ + 1)-coloring) in terms of n was 2 O( √ 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 (deg +1)-list coloring down to poly log n in LOCAL (it also applies to many other symmetry breaking problems; see [26,29,47]). A 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 Δ 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 Δ log n)-round algorithm for O(Δ 1+ε )-coloring and an O(Δ ε log n)-round algorithm for O(Δ)-coloring [10]. Recently, this recursive technique was extended to (deg +1)-list coloring, giving an algorithm with runtime (2 O( √ log Δ) 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 5 (equipped with a small outdegree orientation) without incurring a log n factor, yielding the first sublinear in Δ algorithm for Δ + 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 Ω(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., poly log n). In the post-shattering phase, deterministic (deg +1)-list coloring is applied on all uncolored components in parallel. The runtime of the shattering phase has progressed from O(log Δ) [14], over O( √ log Δ) [33] to O(log * Δ) [20]. Combined with the poly log n-round list coloring algorithm of [47], this gives the current best runtime poly log log n, for (Δ + 1)-coloring [20], and O(log Δ) + poly log log n, for (deg +1)-list coloring [14].
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 Ω(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 Ω(Δ 1/3 ) for O(Δ)-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 Ω(log n) (Ω(log log n)) lower bound for deterministic [17] (randomized [19]) Δ-coloring, as well as for (Δ − 2)-defective 2-coloring [5]. An Ω(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 Δ colors [9,41].

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 ((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.

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 ≥ 0, let P(S) and S 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., P (2) (S) = P(P(S)).

Global conflict coloring
A list family F ⊆ P(C) is a set of subsets of a color space C. Given a symmetric conflict relation R ⊆ {{c, c } | c, c ∈ C}, the conflict degree of a family F in 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 R (F) = max L,L ∈F ,c∈L |{c ∈ L | {c, c } ∈ R}|. An instance P = (C, R, F, L) of the global conflict coloring problem on the graph G is given 6 by a color space C, a symmetric conflict relation R on C, a list family F, and an assignment L : The goal is to assign each vertex a color from its list such that no pair of neighboring vertices get conflicting colors {c, c } ∈ R. The conflict degree of P is d R (F). Note that the conflict degree does not depend on G or L.

Lemma 1 (Zero Round Solution)
An instance (C, R, F, L) of the conflict coloring problem on a graph G can be solved without communication if G is m-colored, m, R, F are globally known, and every list in F has size greater than Proof Every vertex v has a type (ψ v , L(v)) ∈ [m]×F, which is uniquely determined by its input color ψ v and list L(v). Note that adjacent vertices have distinct types, and there are t = m · |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 This can be done since each of the i fixed colors conflicts and this is less than the size of L i+1 , as assumed.

Basic problems: P 0 and P 1
Let C be a fixed and globally known color space (which may depend on the graph G). An i-list is a subset L ⊆ P (i) (C); e.g., the initial color list L v ⊆ 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 < τ ≤ 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 τ and k, -P 0 (list coloring): Node v has to output a color c(v) ∈ 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 ⊆ L v such that |C v | = k and adjacent nodes' 0-lists do not τ -conflict. Two 0-lists C, 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 F or a list assignment L : V → 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 P 1 whose solution immediately solves the P 1 instance (see Theorem 4).

Warmup: Linial's color reduction (without lists)
As a demonstration, we use the introduced framework to reprove 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 , . . . , C k ⊆ 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 β. All nodes have an identical color list L v = C from a color space C. Further, C, m, and β are globally known. If |L v | = l 0 ≥ 2e · β 2 · log m 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 τ = log m > 1 and k = β · τ , without communication. Indeed, having selected the sublists (C v ) v∈V , we need only one round to solve P 0 : Node v learns sublists of its outneighbors and outputs any color c(v) ∈ C v \ ∪ u∈N out (v) C u . This can be done since for any outneighbor u, We recast the given P 1 instance with (identical) input lists (L v ) v∈V as a conflict coloring problem P 1 = (C 1 , R 1 , F 1 , L 1 ) with color space C 1 = P(C) and the τ -conflict relation as R 1 . The list of a node L 1 (v) = L v k in P 1 consists of all k-sized subsets of its input list L v . As each L v is identical to C, we have that L 1 maps each node v to the same list L v k = C k and the list family F 1 = { C k } consists of that singleton. A solution to P 1 immediately solves P 1 .

Claim 1 The conflict degree of P 1 is upper bounded by
Proof Consider two arbitrary lists L, L ∈ F 1 and some 0-list C ∈ L (that is of size k). Each 0-list C ∈ L that τ -conflicts with C can be constructed by first choosing τ elements of C, and then adding k − τ elements from the rest of C which is of size l 0 − τ . This can be done in at most d 1 many ways.
where in the first inequality, we used the well-known approximation k τ ≤ (ek/τ ) τ , and the following inequality, applied which follows as Since τ ≥ log m and |F 1 | = 1 the last claim implies |L 1 (v)| = l 1 > md 1 ≥ m|F 1 |d R 1 (F 1 ), hence we can solve P 1 (and thus also P 1 ) without communication, using Lemma 1.
What we did above is greedily forming a Δ-cover-free family C 1 , . . . , C m ⊆ [O(Δ 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 Δ-cover-free property and the fact that there are at most Δ neighbors, can select a color c ∈ C x that is not a candidate for any neighbor.

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 Δ, max. outdegree β, and an input m-coloring, list coloring with lists L v from a color space C and of size |L v | ≥ l 0 = 4eβ 2 (4 log β + log log |C| + log log m + 8) can be solved in 2 rounds in LOCAL. Each node sends l 0 · log |C| + log m bits in the first round and l 0 /4eβ 2 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.

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 Δ-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 ⊆ L. It is not hard to see that such a family does not exist. 7 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 , . . .}, where each C x,L,i ⊆ 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 Δ-cover free family with one communication round, and use it to choose a color in another round.
Problem P 2 depends on parameters 0 < τ ≤ k ≤ l 0 and 0 < τ ≤ k , and each node has a list L v ⊆ 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 , . . .} of sublists of L v , each of size k.

P 2 (low intersecting sublist systems):
Node v has to output a 1-list K v ⊆ P(L v ) s.t. adjacent nodes' 1-lists do not (τ , τ )-conflict and |K v | = k and |C| = k for all C ∈ K v . Two 1-lists K , K ⊆ P(C) do (τ , τ )-conflict if there are two sequences C 1 , . . . , C τ ∈ K and C 1 , . . . , C τ ∈ K , 8 where at least one of the sequences has τ distinct elements, and for every 1 ≤ i ≤ τ , C i and C i τ -conflict.
We prove in Lemma 2 that with a suitable choice of the parameters a solution of P 2 (τ, k, τ , k ) yields a solution of P 1 (τ, 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∈V .

Algorithm
Under the assumptions of Theorem 2, fix the following (globally known) four parameters: 7 Consider lists of size from a colorspace of size C ≥ 10 . All members of such a cover-free family must be distinct and have size at most , so the family cannot be larger than t≤ C t < 2 C . This is less than the size m C we need. 8 The sets in each sequence are not necessarily distinct. τ = 8 log β + 2 log log |C| + 2 log log m + 14 Note that, τ , k, k are determined by τ and β. 9 We have the bound l 0 ≥ 2ek 2 /τ 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∈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 ∈ N out (v), and selects a 0-list C v ∈ K v that does not τ -conflict with the 0-lists in K u , for u ∈ 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) ∈ C v that does not appear in C u , for u ∈ N out (v) (Lemma 2). This solves P 0 . Lemma 2 (P 2 → P 1 → P 0 ) Given a solution (K v ) v∈V of P 2 (a solution (C v ) v∈V of P 1 ), a solution of P 1 (of P 0 , resp.) can be computed in one round.
Proof P 2 → P 1 : As K v and K u do not (τ , τ )-conflict for any u ∈ N out (v), there are at most τ − 1 0-lists C ∈ K v that τ -conflict with a 0-list in K u . By removing all C from K v that τ -conflict with any C ∈ K u for any outneighbor u ∈ N out (v), at least |K v |−β ·(τ −1) = k −β ·(τ −1) ≥ 1 outputs remain; let C v be any such 0-list. As the conflict relation is symmetric, P 1 is solved. P 1 → P 0 : Since C v , C u do not τ -conflict, removing from C v all the colors from the 0-lists of the outneighbors leaves at least k − β · (τ − 1) ≥ 1 colors that v can select as c(v).

Zero round solution to P 2
The results in this section hold for parameters τ, τ , k fixed as in Sect. 3.2, and for any τ ≤ k ≤ βτ . While we set k = βτ 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 ≥ 2ek 2 /τ 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 (τ, k, τ , 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 P 2 that can be solved in zero rounds with Lemma 1. 9 It may also be helpful to note the similarity between this parameter setting and that in Theorem 4.
Reducing P 2 to a conflict coloring instance (no communication): Given input lists (L v ) v∈V and parameters 0 < τ ≤ k ≤ l 0 and 0 < τ ≤ k, the conflict coloring instance P 2 is given by the colorspace P (2) (C), the (τ , τ )conflict relation R 2 on 1-lists, the list family maps l 0 -sized subsets of C to 2-lists and is defined below. The map L 2 , the colorspace, the conflict relation and the set family F 2 are global knowledge and no communication is needed to compute the list L(v) of a node in P 2 .
To define the map L 2 we need another definition. For an integer t ≥ 0 and a 2-list T , a 1-list K ∈ T is (T , t, τ , τ )good if there are less than t 1-lists K ∈ T such that K and K do (τ , τ )-conflict. We define maps L 1 ,L 2 and L 2 , as follows. For S ∈ C l 0 , where d 2 is chosen as in Lemma 5. 10 Due to the definition of the (τ , τ )-conflict relation and the map L 2 , solving P 2 immediately solves P 2 . The sizes of L 1 (S),L 2 (S) and L 2 (S) do not depend on S. Let l 1 = |L 1 (S)| = l 0 k , and l 2 = |L 2 (S)|/2 = l 1 k /2. We will later show that |L 2 (S)| ≥ l 2 . Let F 1 = {L 1 (S) | S ∈ C l 0 }. Some intuition: In the conflict coloring instance P 2 , every node v has a list {K 1 , K 2 , . . .} 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 K s that are "good", as defined above. Since being "good" only depends on L v , node v can also compute its P 2 -list locally.
In Lemmas 4, 5, 6, we show that lists L 2 (L v ) are large and that 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∈V , nodes locally set up the conflict coloring instance P 2 . Lemmas 4 and 5 show that the conflict degree of P 2 is bounded by d R 2 (F 2 ) ≤ d 2 , and that every list in F 2 has size at least l 2 . Note that F 2 is globally known and |F 2 | = |C| l 0 < |C| l 0 , since each element in F can be written as L 2 (S) for some S ∈ C l 0 . Using Lemma 6 we obtain where the second inequality follows by a routine calculation (following hereafter) using the definition of τ and l 0 . Thus, Lemma 1 holds, and P 2 and P 2 can be solved in zero rounds.
Exponentiating (with base 2) both sides twice gives us the claim.
We continue with proving Lemmas 4, 5, 6. First, we bound the conflict degree of P 2 by d 2 (from the definition of L 2 ). Note that it is a property of the list family F 2 and the conflict relation 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 = 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 .
1. For any 0-list C ∈ L 1 (X ), there are at most d 1 0-lists in L 1 (Y ) that τ -conflict with C. 2. For any 1-list K ∈ L 2 (X ), there are at most d 2 1lists in L 2 (Y ) that (τ , τ )-conflict with K . In particular, d R 2 (F 2 ) ≤ 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 ) andX 2 =L 2 (X ), and define Y 1 , Y 2 ,Ȳ 2 similarly. As |X | = |Y |, there is a bijection between X and Y that is the identity on X ∩ Y . Let α : X → Y be an arbitrary such bijection; if c ∈ X ∩ Y then α(c) = c. Further, since X 1 = X k and Y 1 = Y k , we have the bijection β : X 1 → Y 1 given by β ({c 1 , . . . , c k }) = {α(c 1 ), . . . , α(c k )}, and sinceX 2 = X 1 k andȲ 2 = Y 1 k , we have the bijection γ : We show that the claim holds for any t ≥ 0 and for any K ∈X 2 that is (X 2 , t, τ , τ )-good (which demonstrates that the actual value of d 2 is irrelevant). As Y 2 ⊆Ȳ 2 , it suffices to show that K does (τ , τ )-conflict with at most t 1-lists inȲ 2 . Towards a contradiction, let K ∈X 2 (τ , τ )-conflict with each of t distinct 1-lists K 1 , K 2 , . . . , K t ∈Ȳ 2 and define K i = γ −1 (K i ) ∈X 2 . We show that K also (τ , τ )-conflicts with each of the distinct (γ is a bijection) K 1 , . . . , K t ∈ X 2 , which is a contradiction to K being (X 2 , t, τ , τ )-good: To ease notation, let us focus on K and K 1 . Assume that there are τ distinct (case 2: not necessarily distinct) 0-lists C 1 , C 2 , . . . , C τ in K 1 , and τ not necessarily distinct (case 2: distinct) 0-lists C 1 , C 2 , . . . , C τ in K , such that C i and C i τ -conflict. Then β −1 (C i ) and C i τ -conflict, since α is the identity on C i ∩ C i , β −1 (C i ) are all distinct (since β is a bijection) and belong to K 1 , therefore K and K 1 (τ , τ )conflict.
Next, we show that at most half of the elements K ∈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)
Proof Fix S ∈ C l 0 and consider the digraph H = (V H , E H ) over the vertex set V H =L 2 (S), where (K , K ) ∈ E H iff K contains at least τ lists, each in τ -conflict with a list in K (in particular, for every K , (K , K ) ∈ E H ). Note that a 1-list K is (L 2 (S), d 2 , τ , τ )-good iff its undirected degree in H is at most d 2 .

Claim 3 The maximum outdegree of a node K ∈ V H is at most d 2 /4.
Proof Consider a fixed K ∈ V H . Let X ⊆ K be the set of 0-lists in L 1 (S) that τ -conflict with a 0-list in K . By Lemma 4 part 1, every C ∈ K τ -conflicts with at most d 1 of 0-lists, hence |X | ≤ |K | · d 1 = k d 1 . Every 1-list K , such that there are at least τ 0-lists in K that are in τ -conflict with a 0-list in K , can be obtained by first choosing τ 0-lists from X , and adding an arbitrary subset of k −τ other 0-lists. Clearly, this can be done in at most k d 1 τ · l 1 −τ k −τ = d 2 /4 many ways.
The Claim implies that |E H | ≤ |V H | · d 2 /4, hence the undirected average degree of a node in H is at most 2|E H |/|V H | ≤ 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)| ≥ |V H |/2 = |L 2 (S)|/2 = l 2 .

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 ψ v (see the proof of Lemma 1) , so it suffices to send (ψ v , L v ), which can be encoded in l 0 log |C| + log m bits. In the second round, v needs to send C v . Since C v ∈ 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 τ , so v only needs to send τ ≤ l/4eβ 2 bits.

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. · 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 , . . . ,  [41]. In each of the final m rounds i = 1, . . . , 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( √ Δ). The following happens in phase j = 1, . . . , 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 · (4 log Δ + log log |C| + log log m + 8) = O(log Δ) and for j = 0, . . . , t −1 let β j = Δ j /(2X ) and k j = c ·Δ j /β j , where c is the constant in Lemma 7. 11 We partition G[U j−1 ] into β j -outdegree subgraphs H 1 , H 2 , . . . , H k j , using Lemma 7. 11 In order to apply the lemma, we need β j ≥ c. Since β j ≥ β t = Ω( √ Δ/ log Δ), β j ≥ c holds if Δ is large enough. For Δ = O(1), Theorem 3 holds via an O(Δ) + 1/2 log * n round algorithm (see e.g. [12]).
The phase consists of k j stages i = 1, . . . , k j , each consisting of 3 rounds. In stage i, we partially color H i , as follows. For every uncolored vertex v ∈ 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 Color the graph H i [W i ] using Linial for Lists (Theorem 2) with color space C, the β j -outdegree orientation and the m-coloring. This is a valid application of the theorem, by the definition of X , β 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 Δ j ≤ Δ/2 j . We do this by induction, with base j = 0, Δ 0 = Δ. Assume Δ j ≤ Δ/2 j holds for some j ≥ 0. Let v ∈ U j be a node that is uncolored at the end of phase j. We know that |L v, j,i | < β 2 j X = Δ 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 | < Δ j /2 ≤ Δ/2 j+1 neighbors in U j , which proves the induction: Δ j+1 ≤ Δ/2 j+1 .
Recall that X = O(log Δ) and bound the runtime as follows: The second claim easily follows, recalling the message complexity of Linial for Lists.
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) Δ), their reduced list size would be similarly small, and we could no longer apply Theorem 2, which requires lists of size Ω(log log |C|) = Ω(log log Δ), as the color space does not change in the recursion.

Corollary 1
In a graph with max. degree Δ =Õ(log n), (deg +1)-list coloring problem with lists L v ⊆ C from a color space of size |C| = poly(Δ) can be solved iñ O( √ Δ) + 1 2 · 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 Δ + 1, so the number of colors in M is at most Δ + 1. Each color can be encoded in O(log |C|) = O(log Δ) bits. Thus, M can be encoded in O(Δ log Δ) bits. By the assumption of the claim, we have Δ ≤ a log n · (log log n) b , for constants a ≥ 1, b ≥ 0. It follows that Δ log Δ ≤ a log n · (log Δ) b+1 , as otherwise we would have Δ > a log n(log Δ) b > a log n(log log n) b . Thus, each node sends at most O(Δ log Δ/ log n) = O((log Δ) b+1 ) messages more than in the LOCAL algorithm, and the runtime increases by the corresponding factor.

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((Δ/(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 ≥ 0 be an integer. In a graph with max. degree Δ > d and an input m-coloring, d-defective coloring problem with 2e · Δ/(d + 1) 2 · log 2 m 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 β is replaced with Δ. For a consistent notation, let β = Δ. Also, let P 1 (a, b) denote problem P 1 under the parameter setting τ = a and k = b. First, we solve problem P 1 (τ, k) with parameters τ = log m , k = β/(d + 1) τ . As Claim 2 holds for any k ≥ τ ≥ log m and l 0 ≥ 2ek 2 /τ the corresponding P 1 (τ, k) can be solved locally with list size l 0 ≥ 2ek 2 /τ = 2e β/(d + 1) 2 τ , which holds by our theorem assumption. Let (C v ) v∈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 ∩ C u | < τ, for every neighbor of v. For a color c ∈ C v , let f (c) be the number of neighbors u s.t. c ∈ C u . It follows that 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((Δ/(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 ≥ 0 be an integer. In a graph with max. degree Δ > d and an input m-coloring, d-defective list coloring problem with lists L v from a color space C and of size |L v | ≥ l = 4e Δ/(d + 1) 2 · (4 log Δ + log log |C| + log log m + 8) can be solved in 2 rounds in LOCAL, if C, m and Δ 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 β is replaced with Δ. Let β = Δ, as before. First, we solve problems P 2 and P 1 with parameters τ, τ , k as in Sect. 3.3, and k = β/(d + 1) τ (as observed in the beginning of Sect. 3.3, P 2 and P 1 can be solved for any τ ≤ k ≤ βτ ). Thus, we require the list size of each node to be at least l 0 ≥ 2ek 2 /τ , which holds. Given a solution of P 1 , we can obtain the ddefective coloring in the same manner as in Theorem 5.

Discussion
We conclude with several observations on our results, as well as open problems.
1. It is possible to define problems P 3 , . . . , 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β 2 (log β + log (t) |C| + log (t) m), for a constant c > 0. In particular, one can list color in O(log * max{|C|, m}) rounds if lists are at least cβ 2 log β for a sufficiently large constant c > 0. 2. Unlike in [23], our bound on the list size does not depend on Δ. This result implies that, e.g., given a graph with a βoutdegree orientation and an input coloring with 2 poly(β) colors and list sizes of at least cβ 2 · log β from a color space of size 2 poly(β) , 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 β. On the other hand, we do not know how to eliminate the log β 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 (Δ + 1)-vertex coloring problem, this process has only been understood in the special case of Δ = 2, which corresponds to Linial's Ω(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 β term in Theorem 2 while keeping the runtime o( √ log β).
This question is particularly of interest because log β is the source of the √ log Δ factor in in Theorem 3 (note that the terms depending on m, |C| can be reduced, by the remarks above). The non-list O(Δ 2 )-coloring by Linial uses, in addition to his main color reduction, an O(Δ 3 )-to-O(Δ 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.
Funding Open access funding provided by Graz University of Technology.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecomm ons.org/licenses/by/4.0/.

A color reduction via greedy construction of cover-free families
For an integer Δ ≥ 1, a Δ-cover free family F ⊆ 2 U over a universe U is a collection of subsets of U , such that no set in F is contained in the union of Δ others.
To be self contained we quickly repeat how [41] use such families to reduce a coloring: Suppose a graph G of max. degree Δ is m-colored and there is a globally known Δ-cover free family F = {C 1 , C 2 . . . } with |F| ≥ 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 ⊆ U , sends x to its neighbors, after which every node picks a color y ∈ C(v) \ ∪ u∈N (v) C(u): y exists since |N (v)| ≤ Δ and F is Δ-cover free. By the choice of y, the coloring is proper.

Theorem 7
For integers Δ ≥ 2 and m ≥ 3, there is a greedy algorithm that constructs a Δ-cover free set family F of size m over a universe of size at most 5.2Δ 2 log 2 (em).