1 Introduction
Symmetry breaking problems are a cornerstone of distributed graph algorithms in the LOCAL model.^{1}^{1}1In the LOCAL model [Lin92, Pel00] a communication network is abstracted as an node graph with unique bit identifiers. Communications happen in synchronous rounds. Per round, each node can send one (unbounded size) message to each of its neighbors. At the end, each node should know its own part of the output, e.g., its own color. In the CONGEST model, there is a limitation of bits per message. A central question in the area asks: How fast can these problems be solved in terms of the maximum degree , when the dependence on is as mild as ? [BE13]. That is, we are looking for truly local algorithms, with complexity of the form .^{2}^{2}2Not all symmetry breaking problems admit such a runtime, e.g., coloring and sinkless orientation [BFH16]. The term is unavoidable due to the seminal lower bound by Linial [Lin92] that, via simple reductions, applies to most typical symmetry breaking problems. 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 , by the algorithm from [BEK14] and a recent breakthrough lower bound by Balliu et al. [BBH19]. In contrast, the complexity of vertex coloring, despite being among the most studied distributed graph problems [BE13], remains widely open, with the current best upper bound and lower bound . While most work has focused on the coloring problem, recent algorithms, e.g., [Bar16, FHK16, BEG18, Kuh20], rely on the more general list coloring problem as a subroutine, where each vertex of a graph has a list of colors from a colorspace , 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 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 [Lin92], besides the mentioned lower bound, Linial also showed that coloring can be done in rounds. Szegedy and Vishwanathan [SV93] improved the runtime to rounds, and showed that in additional rounds, the coloring could be reduced to coloring. The latter result was rediscovered by Kuhn and Wattenhofer [KW06]. Barenboim, Elkin and Kuhn used defective coloring for partitioning the graph into low degree subgraphs and coloring in a divideandconquer fashion, and brought the complexity of coloring down to [BEK14]. A simpler algorithm with the same runtime but without using defective coloring was obtained recently in [BEG18]. All of these results also hold for list coloring, since given a coloring, one can use it as a “schedule” for computing a list coloring in additional rounds. Meantime, two sublinear in algorithms were already published [Bar16, FHK16]. They both used low outdegree colorings, or arbdefective colorings, introduced by Barenboim and Elkin in [BE11a], for graph partitioning purposes. The basic idea here is similar to the defective coloring approach, with the difference that the graph is partitioned into directed subgraphs with low maximum outdegree. In [BEG18] 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 algorithm in CONGEST needs rounds ([Bar16]+[BEG18]),^{3}^{3}3For more colors, i.e., coloring, [Bar16] gives runtime in CONGEST. while the fastest one in LOCAL needs rounds ([FHK16]+[BEG18]).
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 subgraphs, each equipped with a outdegree orientation, in rounds [BEG18], (2) a list coloring subroutine that gives rise to the following [FHK16]:
Theorem 1.1 ([Fhk16]).
In a directed graph with max. degree , max. outdegree , and an input coloring, list coloring with lists of size from any color space can be solved in rounds in LOCAL.
The two ingredients are combined to give a list coloring of the input graph [FHK16]. First, partition using (1), iterate through the 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 (). With a fine grained choice of it is ensured that every node with (refined) list size greater than is colored. Thus, after iterating through all subgraphs, all uncolored nodes have list size at most , 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 . Thus, we can apply the partitionthenlistcolor 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 Thm. 1.1 is conceptually complicated and uses gigantic messages. This complication might be due to the generality of the addressed setting as, in fact, [FHK16] studies the more general local conflict coloring problem, and Thm. 1.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 Thm. 1.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 Thm. 1.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 [FHK16], 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 1.2 (Linial for Lists).
In a directed graph with max. degree , max. outdegree , and an input coloring, list coloring with lists from a color space and of size can be solved in 2 rounds in LOCAL. Each node sends colors in the first round, and a bit message in the second.
The name “Linial for Lists” stems from the fact that Thm. 1.2 is a “list version” of one of the cornerstones of distributed graph coloring, Linial’s color reduction, which says that an coloring can be reduced to a coloring in a single round [Lin92]. 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 coverfree families (Linial proved their existence using the probabilistic method [Lin92]; he also used an alternative construction from [EFF85] via polynomials over finite fields, which however yields a weaker color reduction for ) (see Sec. 2.3 and Sec. 6).
Compared with Thm. 1.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 round, due to a lower bound of [SV93] (see Sec. 6).
Combining Thm. 1.2 with the partitioning algorithm of [BEG18] as outlined above gives us a list coloring algorithm. Note that any improvement in the list size bound in Thm. 1.2 (with little increase in runtime) would yield a faster list coloring algorithm.
Theorem 1.3 (List Coloring).
In a graph with max. degree , list coloring with lists from a color space of size ^{4}^{4}4We use the notation , for an absolute constant , and . can be solved in rounds in LOCAL. Furthermore, each node only needs to broadcast to its neighbors a single nonCONGEST message consisting of a subset of its list.
The bound on the color space size stems from the color space dependence in Theorem 1.2. As discussed in Sec. 6, it is possible to trade color space dependence with runtime in Theorem 1.2, which could improve or suppress the bound in Theorem 1.3. That, however, comes with the cost of having huge messages.
Theorem 1.3 immediately provides the fastest known truly local coloring algorithm in LOCAL. Below we list further implications of our framework.

CONGEST (see Cor. 4.2): We obtain an improved coloring algorithm in a low degree regime in CONGEST. In particular, if then coloring (more generally, list coloring with colorspace of size ) can be solved in rounds in CONGEST. Generally, if one allows messages of size , this runtime holds for degree up to . On the other hand, if , for an arbitrarily small constant , an algorithm from recent work [Kuh20] achieves runtime in CONGEST (if one recasts their dependency on as a dependency). Thus, only for the regime of we do not have an algorithm with runtime in CONGEST (with the current best being due to [Bar16]).

Defective list coloring (see Thm. 5.2): Our framework extends to defective list coloring, that is, list coloring where each node can have at most neighbors with the same colors as : If lists are of size we can compute a defective list coloring in rounds in LOCAL. The result can be seen as the “list variant” of a defective coloring result in [Kuh09]. While we are not aware of an immediate application, defective list coloring with a better “colors vs. defect” tradeoff ( vs. ) for line graphs has recently been used to obtain a edgecoloring algorithm with complexity [BKO20].
1.2 Technical Overview
At their core, the proofs of Theorems 1.1 and 1.2 are based on three important concepts: conflict coloring, problem amplification and 0round solvability. A conflict coloring problem is a list coloring problem where two colors can conflict even if they are not equal. 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 , each node computes its input to another problem (perhaps by exchanging information along the way), with the property that, 1. having a solution to , a simple one round algorithm computes a solution to , and 2. the listsizetoconflictdegree () ratio of is larger than that of . Note that the first property essentially determines the conflicts in , and usually a color in is a set of colors in . The importance of the second property stems from the concept of 0round solvability: an instance of a problem with large enough ratio can be solved in 0 rounds, i.e., with no communication.
From here, the plan is simple: take problem , which is the list coloring problem, recast it as a conflict coloring problem, and amplify it into problems , so that is 0round solvable. Then we can cascade down to a solution of problem , in rounds. Crucially, in order to do the above, we need to have sufficiently large ratio to begin with (which explains the particular list size requirements in our theorems). The input coloring is used for tiebreaking in the 0round solution of .
In [FHK16], 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 remodeling a problem with an arbitrary colorspace via mapping each list to an interval 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 (given ), in order to maintain manageable conflict degree, nodes exchange messages to filter out colors in that cause too much conflict with any neighboring node. These messages are huge (recall that a color in is a set of colors in ). Thus, the input to is usually the topology, lists and conflicts in the hop neighborhood of a node. The goal towards 0round solvability is then to find a problem whose ratio is larger than the number of all hop neighborhood patterns (i.e., inputs). The complicated nature of the input to also makes the 0round solvability proof rather conceptually involved. The number of problems required is about .
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 . Our key insight (see Section 3.3), which sets Theorems 1.1 and 1.2 apart, is that in our setting nodes do not need to communicate for computing the input to problems . To achieve this, we show that when forming the lists for from the input to , it suffices to drop “universally bad” colors (sets of colors in ), 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 is just its input in . This makes the 0round solution (of ) particularly simple. The only communication happens when we cascade down from a solution of to that of . With , 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 lists of neighbors, while the second one consists of a small auxiliary message). Taking larger would reduce the requirement on the initial list size but increase message size (see Section 6). Since is sufficient for our applications, we limit our exposition to that case. Setting does not give anything nontrivial for list coloring, since the ratio is not large enough, but when all lists are equal, it gives an alternative proof of Linial’s color reduction (Section 2.3). In fact, is essentially the problem of finding a low intersecting set family, which Linial’s algorithm is based on, while is a “higherdimensional” 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 Thm. 1.1. Our result can also be seen as a bridge between the results of [FHK16] and the recently popular concept of speedup (see Section 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 [BE13]. An overview of more recent work can be found in [Kuh20]. 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 dependence. All deterministic algorithms in this category (for general input graphs) involve a factor. From the early 90s until very recently, the complexity of list coloring (and coloring) in terms of was [AGLP89, PS92], with algorithms based on network decomposition (into small diameter components). A recent breakthrough in network decomposition algorithms [RG20] brought the runtime of list coloring down to in LOCAL (it also applies to many other symmetry breaking problems; see [RG20, GKM17, GHK18]). A little later, [BKM20] found a round CONGEST algorithm.
Historically, decompositions into subgraphs that are equipped with low outdegree orientations as used in our results, in [FHK16], and in [Bar16] are closely related to the notion of arboricity. To the best of our knowledge, [BE10] was the first paper to introduce low outdegree orientations as a tool for distributed graph coloring. First, they showed that one can compute outdegree orientations in graphs with arboricity in rounds, and used it to devise several algorithms to color graphs with bounded arboricity. [BE10] is also the first paper to notice that the degree bound of in Linial’s color reduction can be replaced with a bound on the outdegree. Then, [BE11a] devised methods to recursively partition into graphs with small arboricity yielding an round algorithm for coloring and an round algorithm for coloring. Recently, this recursive technique was extended to list coloring, giving a round algorithm [Kuh20]; the runtime of [Kuh20] has a hidden dependence on the color space. While [BE10, BE11a, Kuh20] have an inherent factor in their runtime, [Bar16] showed that one can decompose a graph into small arboricity subgraphs (equipped with a small outdegree orientation) without inferring a factor, yielding the first sublinear in algorithm for coloring. In the aftermath, [BEG18] improved the runtime for computing the underlying decompositions (and also simplified the algorithm). Thus, the best forms of our results, [FHK16] and [Bar16] are obtained by using [BEG18] to compute decompositions into subgraphs of small arboricity (equipped with small outdegree orientations).
Note that our results, [FHK16] and [Bar16] only require a bound on the outdegree of the subgraphs’ orientations and are oblivious to their arboricity. While bounded outdegree in a graph with a given orientation implies bounded arboricity, computing a bounded outdegree orientation in a graph with bounded arboricity requires rounds, as shown in [BE10].
Recent randomized coloring algorithms rely on the graph shattering technique [BEPS16]. 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 (say, ). Then, in the postshattering phase, deterministic list coloring is applied on all uncolored components in parallel. The runtime of the shattering phase has progressed from [BEPS16], over [HSS18] to [CLP18]. Combined with the round list coloring algorithm of [RG20], this gives the current best runtime , for coloring [CLP18], and , for list coloring [BEPS16].
While special graph classes are out of the scope of this paper, we mention the extensively studied case of distributed edge coloring. Here, round algorithms were designed for progressively improving number of colors, from [GS17, GHK17] to [FGK17, Har19], then to [GKMU18, Har19, SV19]. The truly local complexity of edge coloring has improved from [PR01] to [Kuh20] then to [BKO20] (in addition to ). edge colorings can be computed in rounds [BE11b].
Little is known on coloring lower bounds (in contrast to other symmetry breaking problems, e.g., maximal matching, MIS or ruling sets [KMW16, BBH19, BBO20]). Linial’s lower bound is extended to randomized algorithms in [Nao91]. The deterministic bound has recently been reproven in a topological framework [FP20]. A lower bound for coloring holds in a weak variant of the LOCAL model [HKMS16]. Several works characterized coloring algorithms which can only spend a single communication round [SV93, KW06, HKMS16]. None of these results gives anything nontrivial for two rounds. Also, the speedup technique (e.g., [Bra19, BFH16, BBH19, BO20, BBO20, BBE20]), which proved very successful for MIS lower bounds, is poorly understood for graph coloring. We briefly discuss the technique and its relation to our result in Sec. 6. There are lower bounds for more restricted variants of coloring. There is a () lower bound for deterministic [BFH16] (randomized [CKP19]) coloring, as well as for defective coloring [BHL19]. Further, [GKK09] provides a lower bound for greedy coloring. Similar bounds hold for coloring trees and bounded arboricity graphs with significantly fewer than colors [Lin92, BE10].
1.4 Roadmap
Section 2.1 introduces our version of conflict coloring together with the 0round solvability lemma. Section 2.2 defines the problems and and provides further notation. Section 2.3 contains the first result of our framework: an alternative proof of Linial’s algorithm. Theorem 1.2 (Linial for Lists) is proved in Section 3. Theorem 1.3 (list coloring) is proved in Section 4. Theorem 5.2 (Defective list coloring) is proved in Section 5. We conclude with a discussion of the results and open problems in Section 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 and an integer , let and denote the set of all subsets and all size subsets of , respectively. For a map we use to denote the fold application of , e.g., .
2.1 Global Conflict Coloring
A list family is a set of subsets of a color space . Given a symmetric conflict relation , the conflict degree of a family in is the maximum number of colors in a list that conflict with a single color in a list (possibly same as ), i.e. , . An instance of the global conflict coloring problem on the graph is given^{5}^{5}5Formally, is also part of the problem, but we omit it since it is always clear from the context. These definitions crucially differ from local conflict coloring in [FHK16], where a pair of colors can conflict along one edge and not conflict along another. by a color space , a symmetric conflict relation on , a list family , and an assignment of lists of colors to each vertex . The goal is to assign each vertex a color from its list such that no pair of neighboring vertices get conflicting colors . The conflict degree of is . Note that the conflict degree does not depend on or .
Lemma 2.1 (Zero Round Solution).
An instance of the conflict coloring problem on a graph can be solved without communication if is colored, are globally known, and every list in has size at least .
Proof.
Every vertex has a type , which is uniquely determined by its input color and list . Note that adjacent vertices have distinct types, and there are (globally known) possible types. Below, we show how to greedily assign each type a color from its list s.t. different types get nonconflicting 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 be a fixed ordering of . Assign a color arbitrarily. For any , given the colors of preceding types, assign a color from that does not conflict with . This can be done since each of the fixed colors conflicts with at most colors in , i.e., there are at most colors that cannot take, and this is less than the size of , as assumed. ∎
2.2 Basic Problems: and
Let be a fixed and globally known color space (which may depend on the graph ). An list is a subset ; e.g., the initial color list of a vertex is a list. Below, we introduce two problems. Problem is the standard list coloring problem, which we would like to solve via Lemma 2.1. However, the Lemma may not apply, if the lists are not large enough. We then introduce problem , with parameters , which is a low intersecting sublist selection problem. On the one hand, can be reformulated as a conflict coloring problem with larger lists and color space (hence could be solvable via Lemma 2.1), and on the other hand, a solution to can be used to solve . The input of a node in both problems contains its list . Formally, we have, for parameters and ,

(list coloring): Node has to output a color such that adjacent nodes’ colors do not conflict, i.e., they are not equal.

(low intersecting sublists): Node has to output a list such that and adjacent nodes’ lists do not conflict.
Two lists do conflict if .
Note that problems and are not conflict coloring problems in the formal sense defined above (e.g., we do not define a list family or a list assignment ). The aim with such definitions is to have a higher level and more intuitive (but still formal) problem statement. As the name suggests, in each node needs to compute a subset of its list such that the outputs form a low intersecting set family. can be reduced to a formal conflict coloring problem whose solution immediately solves the instance (see Thm. 2.2).
2.3 Warmup: Linial’s Color Reduction (without Lists)
As a demonstration, we use the introduced framework to reprove Linial’s color reduction theorem [Lin92, Thm. 4.1] (which was extended to directed graphs in [BE10]). An coverfree family of size over a set is a collection of subsets such that no set is a subset of the union of others. The obtained algorithm is essentially a greedy construction (via Lemma 2.1) of an coverfree family (with appropriate parameters) whose existence was proved via the probabilistic method in [Lin92]. This greedy construction was first obtained in [HS87] 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 2.2 ([Lin92, Be10]).
Let the graph be colored and oriented, with max outdegree . All nodes have an identical color list from a color space . Further, , , and are globally known. If holds then in 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 with the given lists. To this end, it suffices to solve with parameters and , without communication. Indeed, having selected the sublists , we need only one round to solve : Node learns sublists of its outneighbors and outputs any color . This can be done since for any outneighbor , and do not conflict () and hence .
We recast the given instance with (identical) input lists as a conflict coloring problem with color space and the conflict relation as . The list of a node in consists of all sized subsets of its input list . As each is identical to , we have that maps each node to the same list and the list family consists of that singleton. A solution to immediately solves .
Claim 1.
The conflict degree of is upper bounded by .
Proof.
Consider two arbitrary lists and some list (that is of size ). Each 0list that conflicts with can be constructed by first choosing elements of , and then adding elements from the rest of which is of size . This can be done in at most many ways.
Claim 2.
Let . For any , if then .
Proof.
We have
(1) 
where in the first inequality, we used the wellknown approximation , and the following inequality, applied to : for integers ,
(2) 
which follows as holds for .
Since and the last claim implies , hence we can solve (and thus also ) without communication, using Lemma 2.1.
What we did above is greedily forming a coverfree family of size . The same was done in [Lin92], using the probabilistic method. Having such a family globally known, every vertex of input color picks, in 0 rounds, the set as its candidate output colors (neighboring vertices get distinct sets). Then, every vertex of color learns the sets of its neighbors, and based on the coverfree property and the fact that there are at most neighbors, can select a color that is not a candidate for any neighbor.
3 Linial for Lists
The goal of this section is to prove the following theorem.
Theorem 1.2 (Linial for Lists). In a directed graph with max. degree , max. outdegree , and an input coloring, list coloring with lists from a color space and of size
can be solved in 2 rounds in LOCAL. Each node sends bits in the first round and bits in the second.
Assumption. Throughout this section, we assume that the list of each node is exactly of size ; if a node’s list is larger it can select an arbitrary subset of size .
3.1 The Problem (Low Intersecting Sublist Systems)
Recall that when applying our framework to the case where all lists were equal (Thm. 2.2), we essentially constructed a coverfree family over the color space, and this was sufficient because we only needed a family of size : one set for each possible input pair of a color and list , with the same for all nodes. In order to replicate the construction for list coloring, we would need to construct a coverfree family with a set for every combination of color and list , and such that . It is not hard to see that such a family does not exist. Instead, we introduce problem , whose goal is to assign every input a collection of candidate subsets , where each . 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 , the nodes can compute the desired cover free family with one communication round, and use it to choose a color in another round.
Problem depends on parameters and , and each node has a list in its input. Instead of a color (as in ) or a sublist (as in ), each vertex now needs to output a collection of sublists of , each of size .

(low intersecting sublist systems): Node has to output a list s.t. adjacent nodes’ lists do not conflict and and for all .
Two lists do conflict if there are two sequences and , where at least one of the sequences has distinct elements and for every , and conflict.
We prove in Lemma 3.1 that with a suitable choice of the parameters a solution of yields a solution of and , where we implicitly impose (and throughout this section assume) that and receive the same input lists .
3.2 Algorithm
Under the assumptions of Thm. 1.2, fix the following (globally known) four parameters: , , and . Note that, are determined by and . ^{6}^{6}6It may also be helpful to note the similarity between this parameter setting and that in Thm. 2.2. We have the bound on list size.
The algorithm consists of two phases. In the first phase, nodes locally and without any communication compute a solution of consisting of lists (see Lemma 3.2). The second phase has two rounds of communication. In the first round, each node learns the solution to of each outneighbor , and selects a list that does not conflict with the 0lists in , for , and thus is a solution to (Lemma 3.1). In the second round, node learns the lists of outneighbors, and selects a color that does not appear in , for (Lemma 3.1). This solves .
Lemma 3.1 ().
Given a solution of (a solution of ), a solution of (of , resp.) can be computed in one round.
Proof.
: As and do not conflict for any , there are at most lists that conflict with a list in . By removing all from that conflict with any for any outneighbor at least outputs remain; let be any such list. As the conflict relation is symmetric, is solved.
: Since do not conflict, removing from all the colors from the lists of the outneighbors leaves at least colors that can select as . ∎
3.3 Zero Round Solution to
The results in this section hold for parameters fixed as in Section 3.2, and for any . While we set for solving , we will use another value of for our defective coloring result (see Section 5). Note that we still have the bound on list size, for any such . The goal of this section is to prove the following lemma.
Lemma 3.2 ( in zero rounds).
Under the assumptions of Thm. 1.2, the problem can be solved in zero rounds.
To prove Lemma 3.2, we reduce (without communication) an instance of to a conflict coloring instance that can be solved in zero rounds with Lemma 2.1.
Reducing to a conflict coloring instance (without communication):
Given input lists and parameters and , the
conflict coloring instance is given by the colorspace , the conflict relation on 1lists, the list family and list for node , where maps sized subsets of to lists and is defined below. The map , the colorspace, the conflict relation and the set family are global knowledge and no communication is needed to compute the list of a node in .
To define the map we need another definition. For an integer and a list , a list is good if there are less than lists such that and do conflict. We define maps , and , as follows. For ,
(elements are lists)  
(elements are lists)  
where is chosen as in Lemma 3.4.^{7}^{7}7The precise value is not important to understand how is formed. Due to the definition of the conflict relation and the map , solving immediately solves .
The sizes of and do not depend on . Let , and . We will later show that . Let .
Some intuition: In the conflict coloring instance , every node has a list of lists, each a collection of subsets of its input list . To ensure small conflict degree, but still large list size, it is enough that only takes s that are “good”, as defined above. Since being “good” only depends on , node can also compute its list locally.
In Lemmas 3.5, 3.3 and 3.4, we show that lists are large and that has small conflict degree. Before that, let us see how these lemmas imply 0round solvability of (Lemma 3.2).
Proof of Lemma 3.2.
To solve an instance of on input lists , nodes locally set up the conflict coloring instance . Lemmas 3.4 and 3.3 show that the conflict degree of is bounded by , and that every list in has size at least . Note that is globally known and , since each element in can be written as for some . Using Lemma 3.5 we obtain , where the second inequality follows by a routine calculation using the definition of and (see Appendix B). Thus, Lemma 2.1 holds, and and can be solved in zero rounds. ∎
We continue with proving Lemmas 3.5, 3.3 and 3.4. First, we bound the conflict degree of . Recall that it is a property of the list family and the conflict relation , and is independent of the graph and list assignment. The proof involves establishing an isomorphism between and , for any , which preserves their common elements. For this, it is crucial to have . This is why we need all input lists to have same size .
Lemma 3.3 (Conflict Degrees).
Let be 0lists. Let .

For any list , there are at most lists in that conflict with .

For any list , there are at most lists in that conflict with . In particular, , and this holds irrespective of the value of .
Proof.
The proof of the first claim is along the same lines as the proof of creftypecap 1, so we only prove the second claim here. Let and , and define similarly. As , there is a bijection that is the identity on : if then . Further, since and , we have the bijection given by , and since and , we have the bijection , where .
We show that the claim holds for any and for any that is good (which demonstrates that the actual value of is irrelevant). As , it suffices to show that does conflict with at most 1lists in . Towards a contradiction, let conflict with each of distinct 1lists and define . We show that also conflicts with each of the distinct ( is a bijection) , which is a contradiction to being good: To ease notation, let us focus on and . Assume there are distinct (case 2: not necessarily distinct) 0lists in , and not necessarily distinct (case 2: distinct) 0lists in , such that and conflict. Then and conflict, since is the identity on , are all distinct (since is a bijection) and belong to , therefore and conflict. ∎
Next, we show that at most half of the elements fail to be good; this lemma crucially depends on the value of . Below, we use the conflict degree from Lemma 3.3.
Lemma 3.4 ( is large).
Let