1 Introduction and Related Work
Distributed graph coloring is one of the core problems and probably also the most extensively studied problem in the area ofdistributed graph algorithms. It is one of the classic problems to study the more general fundamental question of how to efficiently break symmetries in a network in a distributed way. The network is modeled as a -node graph in which the nodes communicate over the edges and the objective is to compute a proper coloring of . If the maximum degree of is , the goal typically is to compute a coloring with colors for some function , where the standard task is to color with colors.111 colors is what can be guaranteed by a simple sequential greedy algorithm. Consequently and maybe even more importantly in the context of distributed algorithms, it is the minimum number of colors necessary such that an arbitrary partial proper coloring can be extend to a proper color of all nodes of . The problem is usually studied in a synchronous message passing model known as the model [Lin92, Pel00]. Each node is equipped with a unique -bit identifier . The nodes operate in synchronous rounds, where in each round each node can send a message to each of its neighbors. Initially, the nodes only know the IDs of their neighbors and at the end, each node needs to know its own color of the computed vertex coloring of . The time complexity of an algorithm is measured as the number of rounds. In the model, the maximum message size is not bounded. The more realistic variant of the model where messages have to be of size at most bits is known as the model [Pel00].
Early Work on Distributed Coloring:
The work on distributed coloring started more than 30 years ago with the early work on solving symmetry breaking problems in the parallel setting [ABI86, CV86, GPS88, Lub86] and most importantly with a seminal paper by Linial [Lin87], which introduced the model for solving graph problems in a distributed setting. Linial in particular showed that a graph can be colored (deterministically) in rounds with colors and that this is tight even for graph of degree : Every deterministic algorithm to color an -node ring with a constant number of colors requires rounds.222The function measures the number of times the function has to applied iteratively in order to obtain a constant value when starting with value . Naor later extended the lower bound to randomized algorithms [Nao91]. To this day, the lower bound is still the only known time lower bound for -coloring in the model. Together with the observation that as long as there are more than colors, one can reduce the number of colors by in a single round (by recoloring the nodes of the largest color), the -coloring algorithm of Linial directly implies a deterministic -time algorithm for -coloring. It was later shown that a refined single-round color reduction scheme improves this running time to [SV93, KW06].
If randomization is allowed, already the early works imply that a -coloring can always be computed in rounds. The result in particular follows from a simple reduction from -coloring to the problem of computing a maximal independent set (MIS) [Lub86, Lin87] and from the classic -time randomized algorithms for computing an MIS [ABI86, Lub86].
Exponential Separation Between Randomized and Deterministic Complexity:
While there are very efficient (and simple) randomized algorithms for solving -coloring, the best known deterministic algorithm is almost exponentially slower an requires time [PS95b]. The algorithm is based on a structure known as a network decomposition, which was introduced by Awerbuch et al. [AGLP89] and decomposes the graph into clusters of small diameter and a coloring of the cluster graph with a small number of colors. The distributed coloring problem is then solved in a brute-force way: One iterates over the cluster colors and for each cluster color, the respective clusters are colored by locally learning the complete cluster topology in time proportional to the cluster diameter. The question of whether there really is an exponential gap between the best randomized and deterministic time complexities for the -coloring problem (and in fact for many more problems) is one of the most fundamental and long-standing open problems in the area of distributed graph algorithms (see, e.g., [Lin87, BE13, GKM17]). In fact, in their book on distributed graph coloring, Barenboim and Elkin [BE13] explicitly state that “perhaps the most fundamental open problem in this field is to understand the power and limitations of randomization.”. In the present paper, we make progress on establishing the deterministic complexity of the distributed -coloring problem. While we do not improve the best time bound for general graphs, we significantly improve the best known bound for a large range of values for . We also give the first -time deterministic -coloring algorithm that does not depend on computing a network decomposition. In fact, our algorithm even works in the model.
Deterministic Distributed Coloring:
As we focus on deterministic distributed coloring algorithms, we first discuss this case in more detail. While as a function of , the -time solution of [PS95b] is still the fastest known deterministic algorithm, there has been extensive work on determining the round complexity of distributed coloring as a function of the maximum degree . The first improvement over the -algorithm mentioned above was obtained independently by Barenboim and Elkin [BE09] and Kuhn [Kuh09], who showed that the problem can be solved in time . The algorithms of [BE09, Kuh09] introduced distributed defective coloring as a new technique. A -defective -coloring of a graph is a coloring with colors such that the subgraph induced by each color class has maximum degree at most . Such a coloring allows to solve the distributed coloring problem in a divide-and-conquer fashion by decomposing the graph into several smaller-degree subgraphs. This basic idea was further developed by Barenboim and Elkin in [BE10], where they showed that for every constant , it is possible to compute an -coloring in time and that a -coloring can be computed in time . The paper introduced arbdefective colorings as a generalization of defective colorings. Such colorings partition the nodes of a graph into subgraphs of small arboricity333The arboricity of a graph is the minimum number of forests into which the edge set of can be decomposed. rather into subgraphs of small degree. Note that while the paper shows that there are very efficient coloring algorithms that use a relatively small number of colors, it does not improve the time required to compute a -coloring. A further improvement for the -coloring problem was obtained by Barenboim [Bar15], who improves the time from to . The key insight of the paper was to consider the more general list coloring problem rather than the ordinary vertex coloring problem. In a -list coloring problem, every node has to choose a color from a list of size , which is given to initially. List colorings in particular allow to extend previously computed partial colorings. Considering list colorings thus allows to recursively decompose the graph and to then color the parts sequentially without having to divide the color space among the different parts. The result of [Bar15] was improved to by Fraigniaud, Heinrich, and Kosowski [FHK16], who introduced a generalized version of list coloring, which they could solve more efficiently. Our algorithms build on the techniques developed in all the above works. From a technical point of view, our main contribution is an extension of the recursive algorithm of [BE10] to list colorings. We then combine this list coloring algorithm with the framework developed in [Bar15, FHK16].
We conclude the discussion on existing deterministic distributed coloring by mentioning a few additional notable results. While except for the original bound, no lower bound for the model has been proven, it was recently shown that in a weak version of the model (called the model), the -coloring problem has a lower bound of [HMKS16]. Further, in [BEG18], an alternative and particularly elegant deterministic -time -coloring algorithm was given. The algorithm reduces the colors iteratively in a round-by-round manner rather than by using defective colorings. The technique also allows to slightly improve the best -coloring bound of [FHK16] to [BEG18]. Finally, some authors also considered the problem of coloring the nodes of a graph with instead of colors. Although this problem has a less local nature, it has been shown that up to factors, -colorings can essentially be computed as fast as a -colorings [PS95a, GHKM18].
Randomized Distributed Coloring:
There has also been a lot of work on understanding the randomized complexity of the distributed coloring problem [KSOS06, SW10, BEPS12, PS13, HSS16, GHKM18, CLP18]. A particularly important contribution was provided by Barenboim, Elkin, Pettie, and Schneider [BEPS12], who introduced the so-called graph shattering technique to the theory of distributed graph algorithms. The paper shows that a -coloring can be computed in time . The basic idea of shattering is to first use an efficient randomized algorithm that solves the problem on most of the graph, has a time complexity that often just depends on , and that essentially only leaves unsolved components of size . In the case of [BEPS12], this randomized part of the algorithm requires rounds. The remaining problems on -size components are then solved by using the most efficient deterministic algorithm for the problem, i.e., in time in the case of distributed coloring. In fact, in [CKP16], Chang, Kopelowitz, and Pettie showed that this shattering technique is essentially necessary and that the randomized complexity of coloring (and many more graph problems) on graphs of size is at least the deterministic complexity of the problem on graphs of size . Note that this adds another very strong motivation to understand the deterministic complexity of the distributed coloring problem. In subsequent work, the time bound of the randomized -coloring problem was improved to in [HSS16] and finally to in [CLP18]. Note that in [CLP18], the time is dominated by the deterministic time for coloring components of size . Hence, the current best randomized time complexity of the -coloring problem can only be improved by at the same time also improving the best deterministic algorithm for the problem.
Distributed Edge Coloring:
A particularly extensively studied special case of distributed coloring is the edge coloring problem. The task corresponding to computing a -vertex coloring is to compute an edge coloring with colors. It was already realized 20 years ago that the distributed edge coloring problem has a simpler structure than the distributed vertex coloring problem and there have been many contributions towards the randomized [PS97, DGP98, EPS15, CHL18] and the deterministic [PR01, CHK01, GS17, FGK17, GHK18, GKMU18, Har18, SV19] complexity of the problem. In both case, we now know efficient algorithms for computing -edge colorings and (under some conditions in the deterministic case) even for computing -edge colorings. Note that by Vizing’s classic theorem, every graph has an edge coloring with colors [Viz64].
A particularly important step was obtained by Fischer et al. [FGK17], who show that the -edge coloring problem can be solved deterministically in rounds. Previously, the best deterministic algorithm for general graphs had a time complexity of and as in the case of the best -vertex coloring algorithm, it was a brute-force algorithm based on first computing a network decomposition [AGLP89, PS95b]. Together with the best known randomized algorithms (which use the shattering technique), the algorithm of [FGK17] also implied that the -edge coloring problem has a randomized complexity of . The current best time complexities for computing an -edge coloring in general graphs are for the deterministic and for the randomized setting [Har18]. For small values of , the best known complexity is [FHK16, BEG18], as for computing a -vertex coloring. As one of our contributions, we improve this last result to .
1.1 Contributions and Main Ideas
We will now describe our contributions and the main ideas that lead to those contributions.
Recursive Distributed List Coloring:
As stated above, from a technical point of view, our main contribution is a recursive solution for the list coloring problem. Our algorithm generalizes the algorithm of Barenboim and Elkin in [BE10]. In [BE10], the node set of is recursively divided into smaller sets and the subgraphs of induced by these node sets are then colored independently by using disjoint sets of colors for the different parts. The recursive partitioning is done by a so-called arbdefective coloring. Given a graph with an edge orientation where the out-degree of each node is at most , a -arbdefective coloring of is a coloring and a new orientation of such that each node has at most out-neighbors (w.r.t. to the new orientation) of its own color. In [BE10], it is shown that in time , it is possible to compute an -arbdefective coloring with colors. Note that this recursive partitioning of the graphs requires the total number of colors to be sufficiently large and it in particular cannot provide a -coloring. In each recursive step, the number of parts grows by a constant factor more than the maximum out-degree is reduced.
When trying to extend the above solution to list coloring, one could try to divide the space of all possible colors into parts and assign each node to one of the parts. If we could find such a partition such that the color list of each node is roughly divided by a factor , we could use the same arbdefective colorings as in [BE10] to recursively divide problem. Finding such a partition of the color space is however a problem that does not have a local solution (whether such a partition is good depends on all the lists). We therefore adapt the solution of [BE10] in a more careful way that is specifically designed to work for the list coloring problem. We consider an arbitrary partition of the global color space into (roughly) equal parts and we partition the nodes by assigning each node to one of the parts. However, instead of equally reducing the out-degrees, we find a partition and a new orientation such that for every node , the size of its list gets smaller at roughly the same rate as the out-degree of (again up to a constant factor). For a formal definition of our generalization of arbdefective colorings, we refer to Definition 2.1. If the initial lists are sufficiently large, this recursive partitioning allows to maintain list coloring problems that are solvable. We formally prove the following main technical result. The construction follows the same basic ideas as the construction in [BE10], carefully adapted to the more general list coloring setting.
Let be a graph where all edges are oriented and for each , let be the out-degree of . Let and be two parameters and assume that each node is assigned a list of size at least consisting of colors from a color space of size at most . Then, there is a deterministic -round algorithm to solve the given list coloring instance. The algorithm requires messages of size .
Note that Theorem 1.1 directly gives a generalization of the results of [BE10] to list colorings. Specifically, for an arbitrary initial edge orientation, the theorem implies that if is a most polynomial in , for every constant , there are deterministic distributed coloring algorithms to solve list coloring instances with lists of size for a sufficiently large constant in rounds and list coloring instances with lists of size in rounds. The two results are obtained by setting and , respectively.
By using the framework developed in [Bar15, FHK16], we can use the list coloring algorithm of Theorem 1.1 to efficiently compute list colorings for lists of size . The basic idea is to first use a defective coloring to partition the nodes of into parts of maximum degree at most . The algorithm then sequentially iterates through the parts and when processing part , it colors the nodes of that part so that the coloring is consistent with the coloring computed for the previous parts. Note that when coloring a part in a consistent way with already colored parts, each node is only allowed to choose a color that has not already been chosen by a neighbor of . Coloring each part is therefore a list coloring problem, even if the original problem is not a list coloring problem. As long as at least half the neighbors of a node are uncolored when processing node , the list of is of length more than . Because each part has maximum degree at most , we are thus in a setting where we can apply Theorem 1.1. After going through the parts, we get a partial list coloring where the maximum degree of the graph induced by the uncolored nodes is at most . Iterating times then gives a -coloring. By setting , we obtain our main theorem, which is stated in the following.
Let be an -node graph with maximum degree and assume that we are given a -list coloring instance with colors from a color space of size . Then, there is a deterministic model algorithm to solve this list coloring problem in time .
Note that by -list coloring we refer to a list coloring instance where the size of the list of each node is at least . The theorem thus in particular implies that the standard -coloring problem can be solved in time in the model. Theorem 1.2 improves the best known deterministic time complexity of for solving -coloring even in the model for all between and . The theorem also extends the range of for with -coloring can be solved in deterministic time from to . It is further notable that our algorithm gives an alternative way of solving -coloring in deterministic time. Our algorithm does not depend on computing a network decomposition and solving the clusters in a brute-force way and the algorithm even works in the model (i.e., with -bit messages).
Bounded Neighborhood Independence:
A graph is said to have neigborhood independence if every node has at most independent (i.e., pairwise non-adjacent) neighbors (see also Section 2). In [BE11], Barenboim and Elkin showed that in graphs of bounded neighborhood independence, the recursive coloring algorithm of [BE10] can be improved: Essentially, they show that the multiplicative factor in all the time bounds of [BE10] can be replaced by an additive term if the neighborhood independence is . We show that the same improvement can also be obtained for list colorings, leading to the following theorem.
Let be an -node graph with maximum degree and neighborhood independence at most . Assume that we are given a -list coloring instance with colors from a color space of size . Then, there is a deterministic model algorithm to solve this list coloring problem in time .
The line graph of any graph has neighborhood independence at most (for each edge of , the adjacent edges can be covered by two cliques in the line graph, defined by the edges incident to and the edges incident to ). Theorem 1.3 thus leads to the following direct corollary for the distributed edge coloring problem.
Let be an -node graph with maximum degree and assume that we are given a lisnt edge coloring instance with lists from a color space of size at most . If the list of each edge is of size at least , there is a deterministic algorithm to solve the given list edge coloring problem in time .
Note that even though on the line graph, the algorithm of Theorem 1.3 can be implemented in the model (i.e., with messages of size bits), it is not immediate whether the same is also true when implementing the algorithm on . The theorem therefore only implies a algorithm for the edge coloring problem.444We believe that it might be possible to actually also implement the algorithm in the model on . The result in particular improves the time for computing a -edge coloring for from to .
Theorem 1.2 has two immediate applications. If is a graph with arboricity , one can use an algorithm from [BE08] to decompose into parts such that every node () has at most neighbors in . The time for computing this decomposition is (deterministically in the model). By sequentially list coloring the sets in reverse order, we get the following corollary of Theorem 1.2.
Let be an -node graph with arboricity and assume that for some , we are given a -list coloring instance with lists from a color space of size at most . Then there is a deterministic model algorithm that solves this list coloring problem in time .
We note that the number of colors is close to optimal as there are graphs with arboricity and chromatic number (see also the more detailed discussion in Section 2).
Finally, we also obtain an improved algorithm for deterministically computing a -coloring of a graph . By a classic result of Brooks from 1941 [Bro09], it is well-known that every graph with maximum degree can be colored with colors unless
is an odd cycle or a complete graph. In[GHKM18], it was shown that for , in the model, the problem of computing a -coloring can be deterministically reduced to instances of computing a -list coloring problem. This implies the following corollary of Theorem 1.2.
Let be an -node graph with maximum degree . If is not a complete graph, a -coloring of can be computed deterministically in rounds in the model.
2 Model and Preliminaries
Let be an undirected graph. For a node , we use to denote the set of neighbors and we use to denote the degree of (if it is clear from the context, we omit the subscript ). The maximum degree of is denoted by and the arboricity of (definition see below) is denoted by . Again, when is clear from the context, we just use and instead of and . The neighborhood independence of a graph is the size of the largest independent set of any subgraph that is induced by the neighbors of some node . For any natural number , we use to denote the set . If not specified otherwise, logarithms are to base , i.e., means .
We assume the standard synchronous communication model in graphs. The network is modeled as an -node graph , where each node hosts a distributed process (which for simplicity will be identified with the node itself). Time is divided into synchronous rounds. In each round, each node can send a possibly different message to each of its neighbors in , receive the messages sent to it by its neighbors in the current round, and perform some arbitrary internal computation. We assume that each node has a unique -bit identifier . Depending on how much information can be sent over each edge of in a single round, one usually distinguishes two variants of this model. In the model, the messages can be of arbitrary size and in the model, messages have to be of size at most bits. To keep the arguments as simple as possible, we assume that all nodes know the number of nodes and the maximum degree of . For algorithms that depend on the arboricity of , we also assume that all nodes know . All our results are relatively straightforward to generalize to the case where the nodes only know a polynomial upper bound on and linear upper bounds on and .555If the IDs are from a possibly larger space , all results still directly hold with an additional additive time cost of as long as we are allowed to also increase the maximum message size to (in order to fit a single ID in a message). Further, with standard “exponential guessing” techniques, it should be possible to get rid of the knowledge of and entirely (see, e.g., [KSV11]).
The arboricity of a graph is the minimum number of forests that are needed to cover all edges of . This implies that the number of edges is at most and more generally, any -node subgraph has at most edges. The arboricity is thus a measure of the sparsity of . A classic theorem of Nash-Williams shows that the arboricity is equal to the smallest integer such that every subgraph of has at most edges [NW64].
Note that every subgraph of a graph of arboricity has a node of degree strictly less than . By iteratively removing a node of degree at most and coloring the nodes in the reverse order, we can therefore always find a vertex coloring with at most colors. Note that this is tight in general as Nash-William’s theorem for example directly implies that the complete graph of size has arboricity . The process of iteratively removing a node of degree at most until the graph is empty also implies that every graph of arboricity has an acyclic orientation of the edges such that each node has out-degree at most . If we drop the requirement that the orientation needs to be acyclic, the edges can be oriented such that the out-degree of each node is at most (by taking an out-degree orientation of each of the forests into which the edge set decomposes).
In a list coloring instance of a graph , every node is initially assigned a list of colors and the objective is to assign a color such that the assigned colors form a proper vertex coloring of . A graph is said to be -list-colorable if any assignment of lists of size for each has a solution. Note that every graph is -list colorable and every graph of arboricity is -list colorable. Some of our algorithms only compute partial colorings. For a given list coloring instance with lists , a partial proper list coloring is an assignment of values to each node such that for any two neighbors and , or (where an assignment of is interpreted as not assigning a color to a node).
For a graph and two integers and , a -defective -coloring is an assignment of a color to each node such that for every , the number of neighbors with is at most . We also use a version of defective coloring where the defect of a node can be a function of the degree . For any and an integer , we define a -relative defective -coloring of as an assignment of colors such that each node has at most neighbors of the same color. We will make frequent use of the following distributed defective coloring result, which was proven in [Kuh09, KS18].
By using an algorithm of Linial [Lin92], it is possible to deterministically compute an -coloring of in rounds in the model. As all our time complexities are lower bounded by , we will generally assume that an -coloring of the network graph is given. In [Kuh09], Theorem 2.1 was proven for the standard defective coloring definition. In [KS18], it was observed and formally proven that the algorithm and proof of [Kuh09] directly extends to the relative defective coloring problem defined above. In [BE10], Barenboim and Elkin defined a generalization of defective coloring that decomposes the graph into subgraphs of small arboricity (rather than into subgraphs of small degree). Formally, for integers and , a -arbdefective -coloring of is an assignment of colors to the nodes in and an orientation of the edges of such that each node has at most out-neighbors of the same color.
List Color Space Reduction:
Defective and arbdefective colorings are a natural way to decompose a given distributed coloring problem into multiple coloring problems on sparser (and thus easier to solve) instances. Over the last 10 years, the technique has been applied successfully in several distributed coloring algorithms [BE09, Kuh09, BE10, BE11, Bar15, FHK16]. In its most basic variant, the technique divides the color space into several disjoint subspaces and it then in parallel solves the resulting coloring problems for each of the smaller color spaces. The main technical contribution of this paper are generalizations of defective and arbdefective colorings that allow to reduce the color space for list colorings. For our main result, we need a generalization of a decomposition into parts of low arboricity, which is defined next. In Section 4, we will also introduce a similar unoriented notion of list color space reduction.
Definition 2.1 (Oriented List Color Space Reduction).
Let be a graph where all edges are oriented. For each , let be the out-degree of . Assume that we are given a list coloring instance on with lists for some (global) color space . Assume also that we are given a partition of the color space. Further, assume that each node is assigned an index and that we are given a new edge orientation . For each , we define new lists and we let be the number of out-neighbors for which (w.r.t. the new orientation ). The assignment together with the edge orientation is called an oriented -list color space reduction for and if
Hence, essentially, a list color space reduction allows to reduce the global color space by a factor while losing a factor of in the list size to out-degree ratio. We will therefore try to find color space reductions where is as large as possible and is as small as possible. When starting with a color space of size and applying -list color space reductions, this will allow to compute a proper coloring as long as the initial list size to degree ratio is larger than .
3 Distributed List Coloring in General Graphs
In this section, we provide our list coloring algorithms for general graphs. In Section 3.1, we describe the basic recursive algorithm that allows to prove Theorem 1.1. In Section 3.2, we show how to combine the scheme with the framework of [Bar15, FHK16] to obtain Theorem 1.2, our main result.
3.1 Basic Recursive Distributed List Coloring
Our scheme is a generalization of a coloring algorithm by Barenboim and Elkin in [BE10]. The algorithm of [BE10] is based on recursively decomposing a given graph of arboricity into parts of arboricity . While this allows to recursively divide the color space of a standard vertex coloring problem, it does not work for list coloring (it is not clear how to evenly divide the color space such that also the lists of all the nodes are divided in a similar way). We will show that by replacing the arbdefective coloring of [BE10] with an oriented list color reduction, a similar algorithm works and it can also be used in an analogous way recursively. The decomposition of the nodes in [BE10] is based on first computing a so-called -partition [BE08], a partition of the nodes of into sets such that for each and every , has at most neighbors in set for . We define a generalized -partition as follows.
Definition 3.1 (Generalized -Partition).
Let be a graph with a given edge orientation such that the out-degree of each node is upper bounded by . A generalized -partition of with parameter and of depth is a partition of into sets such that for every and every , the number of neighbors of in the set is at most .
The following lemma shows that every edge-oriented graph has a generalized -partition of logarithmic depth with a constant parameter and that such a partition can also be computed efficiently in the distributed setting. The construction is a natural adaptation of the standard -partition construction of [BE08].
Let be a graph with a given edge orientation such that for each , denotes the out-degree of . For every , a generalized -partition of of depth and with parameter can be computed deterministically in rounds in the model.
We first define the construction of the partition . In the following, we call the nodes the nodes of level of the construction. We iteratively construct the sets level by level. For each , let be the set of nodes that are not in the first levels and let be the (oriented) subgraph of induced by . We define the set to be the set of nodes that have degree at most in . We stop the construction as soon as . It is clear from the construction that each node has at most neighbors in sets . It is also straightforward to see that a single level can be constructed in rounds in the model and the whole construction therefore requires rounds. It therefore remains to show that the construction ends after constructing levels.
We consider one of the graphs for and for each , we define to be the out-degree of in . We define and . Note that (i.e., layer contains at least all nodes in ). For a set , we define and . We will show that
Equation 1 implies that the set contains at least an -fraction of all the out-degrees of . The sum of the out-degrees in is at most the sum of the out-degrees of the nodes in and thus Equation 1 implies that with each constructed level, the sum of the out-degrees decreases by at least a factor . Equation 1 therefore directly implies and it thus remains to prove Equation 1. We have
By the definition of , we further have
Combining the two inequalities and the fact that for every , , we have
and thus Equation 1 holds. ∎
Based on the generalized -decomposition construction, we can now prove the main technical lemma for general graphs, which proves the existence of efficiently constructible oriented list color space reductions.
Let be an edge-oriented graph, where the out-degree of each node is denoted by . Let us further assume that each node is assigned a list of colors , where for some color space of size . For every integer and every , there is an oriented -list color space reduction that can be computed deterministically in rounds with messages of size .
Let be an arbitrary partition of into parts such that for all , . In order to construct an oriented list color space reduction for the given partition of , we need to provide an orientation of the edges and an assignment of values to all nodes . We define as the new color list of and to be the number of out-neighbors of (w.r.t. the new orientation ) for which . To show that we have computed an oriented -list color space reduction, we need to show that
Let . As a first step, we compute a generalized -partition with parameter and of depth . By using Lemma 3.1, this generalized -partition can be computed in rounds in the model. We then consider the subgraphs induced by all the levels of the generalized -partition. Note that each node has degree at most in its subgraph . For each of the graphs , we (in parallel) compute a -relative defective coloring. By applying Theorem 2.1, such a coloring with colors can be computed in rounds. Based on the generalized -partition and the defective coloring of each of the levels, we now define a partial orientation , which we will later extend to obtain the orientation . Let be the set of edges of such that either and are in different levels of the partition or such that if and are on the same level , the defective coloring of assigns and different colors. Orientation orients all edges in and it leaves all edges in unoriented. For , if the two nodes are in different levels and for , the edge is oriented from to (i.e., from the smaller to the larger level). If and are on the same level but have different colors, the edge is oriented from the larger to the smaller color. Note that by the property of the generalized -partition, every node has at most neighbors for which orients to . Further by the property of the defective colorings, every node has at most neighbors to which the edge is not oriented by .
We are now ready to assign the color subspaces to the nodes, i.e., to assign to each . We do this in phases, each consisting of rounds. In the phases, we iterate through the levels of the partition in reverse order (i.e., we first process the nodes in , then in , and so on). In the phase when processing level , we iterate through the colors of in ascending order. All the nodes on the same level and of the same color are processed in parallel. Note by the construction of , when processing a node , all out-neighbors (w.r.t. ) have already been processed.
Let us now focus on the choice of for a particular node . For each , we define to be the new list size of if we set . We further define as the number of neighbors of for which orients the edge from to and where . In the end, we will define the orientation of all edges of by using orientation for all edges in and by arbitrarily orienting all edges in . If we set , we can therefore upper bound the final number of out-neighbors of (w.r.t. orientation ) for which by . In order to guarantee Equation 2, we thus need to find a value for which , where is defined as in Equation 2. Such an exists because
The first inequality follows because and because is the total number of out-neighbors of w.r.t. orientation and it is thus upper bounded by . The last equation follows because and because . It is clear that for all the nodes that are processed in parallel (the nodes of the same color on the same level), the color subspace assignment can be done in a single communication rounds. The claim of the lemma therefore follows. ∎
Note that for and sufficiently large lists, the above theorem directly solves the given list coloring instance. We remark that for this special case, the time complexity could be improved to by using a more efficient algorithm to compute a proper coloring of each level of the generalized -partition. We can now prove Theorem 1.1. The following is a restated, slightly more general version of the theorem.
Let be an -node graph where all edges are oriented and for each , let be the out-degree of . Let and be two parameters and assume that each node is assigned a list consisting of colors from some color space of size . Then, there is a deterministic distributed -round algorithm that computes a proper partial coloring for the given list coloring instance such that every node with outputs a color. The algorithm uses messages of size .
We start with the original list coloring instance and we apply Lemma 3.2 times to obtain list coloring instances with smaller and smaller color spaces. Each time, we divide the given color space into several disjoint subspaces. For each subspace, we obtain an independent list coloring problem and those independent problems can be then be solved in parallel. For , let be the maximum size of the color spaces after list color space reductions (note that ). For each node, let be the color list of in its list coloring instance after steps and let be ’s out-degree of the corresponding edge orientation after steps. We have and . We set and we get the list coloring instances after steps by applying oriented -list color reductions to the list coloring instances after steps. By induction on , for each , we thus have and . After iterations, we therefore have and therefore all the lists are also of size . That is, each node has picked exactly one color from its original list . If , we have and thus . Nodes for which therefore have no out-neighbor with the same color and if only those nodes keep their colors, no two neighbors get the same color. The total time complexity follows directly from Lemma 3.2 and the fact that we have iterations. ∎
3.2 Solving Degree + 1 List Coloring
The coloring result of Theorem 1.1 gives some trade-off between the list sizes (or number of colors for standard coloring) and the time complexity. The time complexity depends linearly on and the list coloring algorithm is thus only efficient if the value of is sufficiently large. However, the required list size to degree ratio grows exponentially with and for large , we therefore need large lists. In order to reduce the number of colors, we use a framework that has been introduced by Barenboim in [Bar15] and later refined by Fraigniaud, Kosowski, and Heinrich in [FHK16].
The basic idea is as follows. In order to increase the list size to degree ratio, we first compute some defective (or arbdefective) coloring to decompose the graph into graphs of smaller maximum (out-)degree. Let us say we decompose the graph into parts, which reduces the maximum degree by a factor (where is at most linear in ). Unlike in the previous algorithm, we do not divide the lists among the different parts, but we use the same lists for coloring all the parts. If the maximum degree is reduced by a factor of and we can use the same color lists, the list size to degree ratio improves by a factor and thus if is chosen sufficiently large, we can apply Theorem 1.1. However, since now the the different parts are dependent, we have to solve them consecutively and thus the time complexity will grow linearly with the number of parts . The main technical result is given by the following lemma. In order to also be applicable in Section 4, the lemma is stated more generally than what we need in this section.
Let and be two functions from the set of undirected graphs to the positive reals such that for every graph and every subgraph of , we have and . Assume that we are given a distributed algorithm with the following properties. For list coloring instances in graphs with maximum degree , assigns a color to each node of degree and with a list of size . Assume further that the running time of is at most if the lists contain colors from a color space of size at most for an arbitary, but fixed constant . Then, if an -coloring of is given, any -list coloring instance with colors from a color space of size at most can be solved in time . The resulting algorithm is deterministic if is deterministic and it works in the model if works in the model.
By using the same basic idea as in [FHK16], we show that in time , we can reduce the problem to a -list coloring instance on a graph of maximum degree at most . The lemma then follows by repeating times. More formally, we show that given an arbitrary -list coloring instance with lists in a graph of maximum degree at most , we can compute a partial coloring with the following properties in time :
Each node either outputs a color or it outputs .
For any two neighbors and , either or .
The subgraph of induced by the nodes with has maximum degree at most .
Note that because the computed coloring is a proper partial coloring (property (2)), the coloring can be extended to a proper coloring of all nodes by solving a -list coloring problem on the subgraph induced by the nodes for which . By property (3), this subgraph has maximum degree at most . Note further that by the properties of an , we have and and by repeating times, we thus get a proper coloring of in time and the claim of the lemma follows.
In order to construct a partial list coloring algorithm that satisfies properties (1)–(3), we first set and we use Theorem 2.1 to compute an -relative defective -coloring of , where . Since we assume that an initial -coloring of is given, the defective coloring can be deterministically computed in time in the model. For each , let be the set of nodes with color in the defective coloring and let be the subgraph of induced by the nodes with color . We compute the partial coloring for with properties (1)–(3) as follows.
We iterate through the colors of the defective coloring. Initially, we set for all . When processing color , we consider the graph and we assign colors to some nodes . For the assignment of colors in , we consider the following list coloring problem. For each node , we define the list as the set of colors from that have not yet been assigned to a neighbor (in a graph for ). We use algorithm to compute a partial proper coloring of w.r.t. the lists for . We then set the colors accordingly for all to which the partial coloring of assigns a color. The choice of lists guarantees that the partial coloring computed for will be proper and thus property (2) is satisfied. Note that if a node has at least uncolored neighbors in before coloring , the list is of size (because we are given a -list coloring instance). As the degree of in is at most
algorithm is guaranteed to assign a color to node . This proves property (3) of our partial list coloring algorithm for . Since the total number of colors of the defective coloring is , we only need to invoke times and thus also the required time complexity of follows. The proof is completed by observing that the reduction is deterministic and can clearly be implemented with messages of size