|(a) Before this work:||(b) After this work:|
There is a broad family of graph problems—so-called locally checkable labelings or LCLs —that exhibits the following dichotomy : either the problem can be solved in rounds with deterministic distributed algorithms, or any such algorithm requires at least rounds.
Hence, for any parameterized LCL problem there is a sudden jump in complexity, from , which is a very slowly-growing function of , to , which can be already as much as the diameter of the network. We will call these two cases “easy” and “hard” from now on.
Proper vertex coloring with colors: easy for , hard for .
Proper edge coloring with colors: easy for , hard for .
Here the easy cases are exactly those cases that can be solved with a greedy algorithm that picks the colors of the nodes or edges one by one; a straightforward parallelization of this idea then gives an -round distributed algorithm.
In this work, we study colorings that are not necessarily proper:
Let be a graph. Mapping is a -partial -coloring if for each node , there are at least neighbors of with .
By prior work on defective colorings, it is known that e.g. -partial -coloring is hard if and easy if . However, very little was known about partial -coloring and -coloring. In this work we complete the picture and show that the case of is very different from the case :
-partial -coloring for any is always hard, no matter how large a we have,
-partial -coloring for any is hard for but it becomes easy when .
We summarize our contributions in Table 1.
2 Preliminaries and related work
2.1 Local model of computing
We work in the usual LOCAL model of distributed computing [18, 22]. Each node of the input graph is a computer and each edge is a communication link. Computation proceeds in rounds: in one round each node can exchange a message (of any size) with each of its neighbors. Initially each node knows only , and when a node stops, it has to produce its own part of the output—in our case, its own color from . We say that an algorithm runs in time if after rounds all nodes stop and announce their local outputs.
When we study deterministic algorithms, we assume that each node is labeled with a unique identifier from . When we study randomized algorithms, we assume that each node has an unlimited source of random bits. For a randomized algorithm, we require that it solves the problem correctly with high probability,
i.e., with probability at leastfor an arbitrary, but predetermined constant .
Note that if a problem is solvable in rounds in the LOCAL model, it also means that each node can produce its own part of the solution based on the information that is available in its radius- neighborhood.
2.2 Lcl problems and gap theorems
LCL problems were introduced by Naor and Stockmeyer  in 1995. In an LCL problem, the input is a graph of maximum degree , possibly labeled with some node labels from a constant-size set . The task is to find a labeling , for some constant-size set , that satisfies some local constraints—a labeling is globally feasible if it is feasible in all constant-radius neighborhoods.
For our purposes it is enough to note that -partial -coloring in -regular graphs is an LCL problem, for any choice of constants . Hence also everything that we know about LCLs applies here.
In the past four years, we have seen a lot of progress in understanding the computational complexity of LCL problems in the LOCAL model [2, 1, 6, 9, 8, 13, 14, 15, 16, 10, 7]. For us, the most relevant result is the gap theorem by Chang et al. . They show that every LCL problems belongs to one of the following classes, which we will here informally call “easy” and “hard”
solvable in rounds with both deterministic and randomized algorithms.
requires rounds with deterministic algorithms and rounds with randomized algorithms.
In this work, our main goal is to understand for what values of the problem of finding -partial -coloring in -regular graphs is “hard” and when it is “easy”. While we will focus on the case of -regular graphs, most of the results directly generalize to the case of graphs of minimum degree (and maximum degree some constant ).
2.3 Prior work related to partial colorings
Notes on terminology.
In -regular graphs, a -partial -coloring is exactly the same thing as a -defective -coloring [3, Sect. 6]. While defective colorings are more commonly discussed in prior work, for our purposes the concept of a partial coloring is much more convenient, as we will often fix and and see what happens when increases.
Our definition is in essence equal to -partially proper colorings used by Kuhn ; for brevity, we call these partial colorings.
Weak coloring, .
In graphs without isolated nodes, a -partial -coloring is identical to a weak -coloring . Weak -coloring can be solved in rounds: find a maximal independent set using e.g. [21, 12]; then color all nodes of with color and all other nodes with color . Naturally, this also gives a solution for weak -coloring for any . Furthermore, this upper bound is tight: a weak -coloring breaks symmetry everywhere in a regular grid, and the usual lower bounds [18, 19, 20] apply.
Weak coloring corresponds to the first row of Table 1.
Partial coloring for .
Above we have seen that we can find a -partial -coloring by simply finding a maximal independent set (MIS). The same idea can be generalized to -partial -coloring for : Find an MIS , label with color , and remove . Find an MIS , label with color , and remove , etc. We continue this for steps and finally label all remaining nodes with color .
The region where this simple (folklore?) strategy works is indicated with green color in Table 1.
Proper vertex coloring, .
Hardness of proper -coloring implies the lower bounds in the blue and gray regions of Table 1a.
Partial coloring for .
Barenboim et al.  gave an algorithm that computes a -defective -coloring in time , which is essentially a defective variant of Linial’s -coloring algorithm . This algorithm requires at least colors, and for the case it translates to a -partial -coloring. For example, -partial -coloring is therefore easy in -regular graphs, and -partial -coloring is easy in -regular graphs.
This algorithm gives the upper bounds in the blue region of Table 1a.
Partial coloring for .
To our knowledge, no -time algorithms are known for -partial -coloring for , . In particular, it is not known if the problem becomes easy in -regular graphs for sufficiently large values of .
This unknown region is indicated with a gray shading in Table 1a.
Algorithms based on Lovász local lemma.
Chung et al. , Fischer and Ghaffari , and Ghaffari et al. [15, full version] present algorithms for defective coloring (and hence for partial coloring) that are based on the following idea: formulate a defective coloring as an instance of the Lovász local lemma (LLL), and then apply efficient distributed algorithms for LLL.
Unfortunately, this approach is unlikely to lead to an -time algorithm; LLL is known to be a hard problem for a wide range of parameters .
Bonamy et al.  shows that there is an -round algorithm for trees that finds an MIS such that every component induced by non-MIS nodes is of size one or two. This can be interpreted as an algorithm for partial -coloring.
However, this approach cannot lead to an -time algorithm, either: if we color the MIS-nodes with color and the non-MIS nodes with colors and , we obtain a proper -coloring, and finding a -coloring in -regular trees is known to be a hard problem .
3 Our contributions
To recap, by prior work, we have a good qualitative understanding of -partial -coloring for :
: easy for all .
: hard for but easy for .
We complete the picture for . For , we have precisely the same situation as above:
: easy for all .
: hard for but easy for .
However, the case of is fundamentally different:
: easy for all .
: hard for all values of .
3.1 Corollary: locally optimal cuts
Any partial -coloring can be interpreted as a cut; the properly colored edges are cut edges, and the size of the cut is the number of cut edges. Let us look at the problem of maximizing the size of a cut with a simple greedy strategy: start with any cut and change the color of a node if it increases the size of the cut. The process will converge to a locally optimal cut, in which changing the color of any single node does not help.
Now a locally optimal cut in -regular graphs is precisely the same thing as a -partial -coloring. For example, in -regular graphs, any -partial -coloring is also a locally optimal cut, and vice versa.
Locally optimal cuts are easy to find in a centralized, sequential setting. However, previously it was not known if locally optimal cuts can be found efficiently in a distributed setting. As a corollary of our work, we now know that this is a hard problem.
3.2 Key techniques
Upper bound for 3-coloring.
Prior algorithms for e.g. partial -coloring are based on the idea of organizing nodes in layers and doing two sweeps : top to bottom, using colors from palette , and bottom to top using colors from palette . This way we eventually have a -coloring with colors from . This idea generalizes easily to e.g. colors, but it is not possible to use this idea to find a useful coloring with less than colors.
We show how to do two sweeps so that the end result is only colors. In brief, the first sweep uses tentative colors from palette , and the second sweep finalizes the colors, depending on the tentative colors that we chose in the first step. Here the second sweep depends on the result of the first sweep, while in prior algorithms the two sweeps are independent.
Lower bound for 2-coloring.
We show that -partial -coloring in -regular graphs for any constant is at least as hard to solve as sinkless orientation, which is known to be hard . The key obstacle here is that sinkless orientation is known to be hard even if we are given a proper -coloring of the graph, so how could a partial -coloring help with it?
The basic idea is as follows: Assume we have a fast algorithm that finds a -partial -coloring in -regular graphs. Then we can construct algorithm that finds a sinkless orientation in -regular graphs, for a certain constant that depends on the exact running time of . Given a -regular graph , algorithm first replaces all nodes with appropriate gadgets to obtain a -regular graph , applies to , and extracts enough information from the partial coloring so that it can find a sinkless orientation. But sinkless orientation is hard also in -regular graphs, no matter how large a constant is.
4 Partial colorings with more than two colors
In this section we analyze the distributed complexity of -partial -coloring in the case where is at least . More formally, we will prove the following theorem.
There exists an algorithm running in that is able to compute:
A -partial -coloring, if and ;
A -partial -coloring, if and .
In order to prove the theorem, we start by providing an algorithm, and then we will analyze it for the two cases separately.
The algorithm that we propose is inspired by the procedure Refine in [3, Sect. 6]. This procedure starts by first finding an acyclic partial orientation, and then assigns two colors for each node by exploiting the two possible orders given by the orientation. It finally combines the two colors to determine the output color. Our algorithm starts in the same way, but it does not compute two independent colors, allowing us to be slightly more efficient in some cases.
We start by finding an acyclic partial orientation of the edges. That is, we first compute an coloring in rounds. Then, we assign a total order to the colors, and we orient the edges from the node with the smaller color to the node with the bigger one. The obtained directed graph is clearly acyclic, and all directed paths are of length at most . Nodes reachable from through outgoing edges are considered to be above , while the others are considered to be below .
Now, we do two “sweeps” on the obtained acyclic graph, that is, we first process the nodes from above to below, and then we process them in the reverse order. More precisely, we start by processing the sinks, and then we continue by processing all nodes such that all of the nodes above them have already been processed. This is iterated until all nodes have been processed. Then, we repeat the same procedure in reverse order, i.e., from below to above. Each sweep takes rounds.
During the first sweep, we assign to each node a temporary color, by choosing the color that is the least used one among the neighbors above . Crucially, during this phase, the choice is not among the full palette, but only colors from to are allowed. We call color the special color. During the second sweep, each node has three options:
Keep the current color.
Choose to switch to color .
Choose to switch to a color from to . This option is allowed only if no neighbor below is currently using that color.
Different choices give different guarantees. For example, by choosing to not change the color, or by choosing to switch to a color from to , node is ensured that the number of properly colored neighbors does not decrease when the nodes above it will be processed. This property is guaranteed by the fact that a node can switch to a color in only if no node below it is using that color. On the other hand, a node may switch to color even if some neighbor below it is using color as well, but then it loses any guarantee about the nodes above it, which may all decide to switch to color . See Figure 1 for an example of the execution of the algorithm.
The algorithm will make a choice that guarantees that neighbors have different color, regardless of whether the nodes above change their color (subject to the above rules) or not. Accordingly, our task is to prove that such a choice always exists, provided that is large enough.
We now show that the above described algorithm is able to compute a -partial -coloring if and . In order to analyze the algorithm running on node , assume without loss of generality that during the first sweep, picks color and nodes above chose color . Note that there are no more than other nodes above , as picked the color out of that was least used by the nodes above it in the first sweep. Denote by the numbers of nodes below that are colored , , and , respectively, after making their final choice in the second sweep. Thus, the number of nodes above that chose in their first sweep equals .
We make a case distinction.
. Thus, can keep color , as the nodes above it that have color must then choose a color different from .
. Then can safely choose color .
and none of the other cases apply. Thus, is free to switch to color . If it does so, it has nodes of different color below, and nodes above that choose a different color than . As the first case does not apply and , these are at least nodes. Hence, switching to color is indeed a valid choice.
Hence, it suffices to show that one of the cases must apply. Assume for contradiction that this is false. Thus,
yielding the contradiction that
We now show that the above described algorithm is able to compute a -partial -coloring if and . We analyze this case similarly to the case before. Let be the number of nodes above of color different from after the first sweep. Without loss of generality, assume that the color of is , and the special color is . Let , , and be the number of nodes below colored with , with color such that , and with color , respectively. Recall that only colors from to are allowed during the first sweep. As chooses a minority color among its above neighbors’ choices, we have remaining nodes above that choose color in the first sweep.
Let us analyze the second sweep. We make a case distinction.
. Then can keep color .
. Then can safely choose color .
There are “free” colors from that no neighbor below chose and none of the other cases applies. If a free color was picked by at most above neighbors of , it may select it with the guarantee that its other neighbors end up with a different color.
Assuming for contradiction that there is no such free color, observe that the least used free color was picked by at most neighbors above in the first sweep. Accordingly, . Moreover, clearly and, because the first case does not apply, . Thus, we can lower bound the total number of neighbors of by
a contradiction. Therefore, one of the free colors is a valid choice for .
Hence, there is indeed always a valid choice if we can show that the above case distinction is exhaustive. Assuming otherwise, collecting inequalities from the cases and the earlier bound on we obtain that
Together, this implies
yielding the contradiction that (using that ).
5 Two-partial two-coloring
In this section, we show that, in the LOCAL model, -partial -coloring requires deterministic time and randomized time in any -regular tree, where . We show the result by reducing from the sinkless orientation problem, for which we know that its distributed deterministic complexity is rounds in the LOCAL model.
Informally, the proof proceeds in two steps. We first show that, if we can solve 2-partial 2-coloring in constant time in a slightly modified version of the LOCAL model, which we call DC-LOCAL model, then we can solve sinkless orientation in the LOCAL model in rounds. Subsequently, we show that, if we can solve an LCL problem in rounds in the LOCAL model, then we can solve in the DC-LOCAL model in constant time using a simulation similar to that of Chang et al. . Therefore no -round algorithm exists, i.e., the problem is not easy and hence it has to be hard, i.e., it requires deterministic time and randomized time.
Computing a -partial -coloring in -regular trees in the LOCAL model requires deterministic time and randomized time, for any .
Consider the usual LOCAL model with the following modification. Instead of having unique identifiers, nodes are given as input a color from a palette of colors, and this coloring of the nodes guarantees a distance- coloring of the graph. In other words, each node sees different colors in its distance- ball, but it may see repeated colors in its distance- ball. We call this model DC-LOCAL (where stands for distance coloring).
5.1 A lower bound for the Dc-Local model
In this section, we show that -partial -coloring in -regular trees is not solvable in rounds in the DC-LOCAL model. We show this by reducing from the sinkless orientation problem in -colored trees in the LOCAL model. More precisely, we show that, if there is an algorithm solving -partial -coloring in time in the DC-LOCAL model, then we can use it to design an -round algorithm that solves sinkless orientation in -colored trees in the LOCAL model. This would give an lower bound for -partial -coloring in the DC-LOCAL model, since we know that sinkless orientation requires rounds, even in -colored trees, in the LOCAL model .
Let be the algorithm that solves -partial -coloring in time rounds in -regular trees in the DC-LOCAL model. We introduce two gadgets that we will use later for proving the lower bound. Let be an arbitrarily distance- colored -regular tree of depth , and let be the root of . We run algorithm on and on each of its neighbors . We denote with the output of algorithm on a node . Notice that is well-defined on these nodes, since their -radius ball is properly distance- colored and fully contained in . Since algorithm solves -partial -coloring, we are sure that there are two nodes such that . Let be a node for which outputs “black” and be a node for which outputs “white”. Let and be the subtrees of depth rooted at and respectively: these are our gadgets (see Figure 2 for an example). The gadgets and satisfy the following property.
Let be the color of the root of the gadget and let be the opposite color. Among all nodes at distance from the root of the gadget, there must be at least one node for which the algorithm outputs color .
Assume that outputs at all nodes at distance from the root. Then all nodes at distance must have color in order to guarantee a -proper -coloring. This would imply that all nodes at distance have color . By applying this reasoning recursively, we conclude that the root must have color , which is a contradiction. ∎
We now show that if there exists an algorithm that solves -partial -coloring in time rounds (where is even) in -regular trees in the DC-LOCAL model, then we can design an algorithm that solves sinkless orientation on trees of degree in which a -coloring of the tree is given, in rounds in the LOCAL model.
Consider a -regular -colored tree , where and represent the set of nodes belonging to the two color classes. We construct a virtual tree in the following way. Each node pretends to be the root of a -regular tree of depth . We call this tree . Then, each node (resp. ) labels the nodes at distance at most with the same colors of the nodes of the gadget (resp. ). Note that this is possible since and are isomorphic to the subgraph induced by the nodes at distance at most from and . Then, we merge the -th leaf of with the -th leaf of if and only if there is an edge connecting and through port of and port of . We call this node (merged node). In order to make the graph -regular, we attach additional virtual nodes to each merged node. Note that, since the original tree is -regular, and since each virtual tree has leaves, then all the leaves of are merged nodes (except for the case in which the original node is a leaf, where just one leaf of is merged). We then color the nodes that are still uncolored, that is, nodes at distance more than from the root of the virtual trees, using a distance- coloring algorithm. Since the already colored parts are far enough apart, this can be done efficiently, in rounds.
Now, each node in simulates the -round algorithm on all nodes of and gets a color for each node. This requires constant time. Algorithm outputs “white” at all nodes , since they have the same view as the root of up to distance . Similarly, algorithm outputs “black” at all nodes . We then orient an edge of from node to node if and only if has the same color of (see Figure 3 for an example). By Proposition 4, we know that at least one such a leaf exists for each node in , meaning that each node is guaranteed to have at least one outgoing edge. This would solve sinkless orientation on -colored trees in the LOCAL model in rounds. Putting all together, we get the following lemma.
The 2-partial 2-coloring problem requires rounds in the DC-LOCAL model.
5.2 From Dc-Local to Local
We now show that all LCLs solvable in rounds can be solved in a standard manner, that is, first find a distance- coloring, for some constant , and then apply a constant time algorithm running in at most rounds. In particular, we will prove the following lemma.
Any LCL problem that can be solved in rounds in the LOCAL model can be solved in rounds in the DC-LOCAL model.
We prove the lemma by simulation. Let be an LCL problem checkable in rounds, where is some constant. Assume that we have an algorithm for the LOCAL model that solves in rounds on graphs of size in which nodes have unique identifiers in . Let be the maximum degree of the graph.
Fix to be the smallest integer such that and . We show that we can construct an algorithm running in rounds that solves in the DC-LOCAL, model. Note that is constant. In other words, we design an algorithm that solves in constant time given the promise that nodes are labeled with a -coloring of distance . We assume that the diameter of the graph is at least , otherwise nodes can gather the entire graph in constant time and solve by brute force.
Algorithm executed by a node is defined as follows. At first, node gathers its distance- neighborhood . Then, node creates a virtual instance of by renaming the nodes in and setting their identifiers as their assigned colors. Now, node simulates algorithm on , by lying about the size of the graph and setting it to be . Finally, the output of is defined to be the same as the output of algorithm . Notice that this simulation is clearly possible, since , running on instances of size , terminates in strictly less than rounds.
We still need to show that the output is valid for the original LCL. For this purpose, we show that, if the algorithm fails in some neighborhood, then we can construct an instance in which the original algorithm fails as well. Let be the graph in which, given a -coloring of distance , there is a node such that the verifier executed on rejects (after running for rounds). Consider , the subgraph of radius centered at . All nodes in have different colors and the number of nodes is at most , since satisfies . We now modify in order to make it a graph of size exactly . For this purpose, we pick an arbitrary node at distance from (that exists by the diameter assumption), and we connect to it a path of as many nodes as needed. We then complete the coloring of these nodes in some consistent manner.
The identifiers of nodes in are set to be equal to their colors. The ID space in is in . At this point, we run algorithm on . Consider the set of nodes at distance at most from . For every node , the -neighborhood of is the same on and , hence the output of on these nodes must be the same as the output of . Thus, the failure of on implies the failure of on . Theorem 3 follows by combining Lemmas 5 and 6.
6 Additional hardness results
Computing a -partial -coloring in -regular graphs, for , requires deterministic time and randomized time.
This work was supported in part by the Academy of Finland, Grants 285721 and 314888.
- Balliu et al. [2018a] Alkida Balliu, Sebastian Brandt, Dennis Olivetti, and Jukka Suomela. Almost global problems in the LOCAL model. In Proc. 32nd International Symposium on Distributed Computing (DISC 2018), Leibniz International Proceedings in Informatics (LIPIcs). Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2018a. doi:10.4230/LIPIcs.DISC.2018.9.
Balliu et al. [2018b]
Alkida Balliu, Juho Hirvonen, Janne H Korhonen, Tuomo Lempiäinen, Dennis
Olivetti, and Jukka Suomela.
New classes of distributed time complexity.
Proc. 50th ACM Symposium on Theory of Computing (STOC 2018), pages 1307–1318. ACM Press, 2018b. doi:10.1145/3188745.3188860.
- Barenboim and Elkin  Leonid Barenboim and Michael Elkin. Distributed Graph Coloring: Fundamentals and Recent Developments, volume 4. 2013. doi:10.2200/S00520ED1V01Y201307DCT011.
- Barenboim et al.  Leonid Barenboim, Michael Elkin, and Fabian Kuhn. Distributed (+1)-Coloring in Linear (in ) Time. SIAM Journal on Computing, 43(1):72–95, 2014. doi:10.1137/12088848X.
- Bonamy et al.  Marthe Bonamy, Paul Ouvrard, Mikaël Rabie, Jukka Suomela, and Jara Uitto. Distributed recoloring. In Proc. 32nd International Symposium on Distributed Computing (DISC 2018), Leibniz International Proceedings in Informatics (LIPIcs). Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.DISC.2018.12.
- Brandt et al.  Sebastian Brandt, Orr Fischer, Juho Hirvonen, Barbara Keller, Tuomo Lempiäinen, Joel Rybicki, Jukka Suomela, and Jara Uitto. A lower bound for the distributed Lovász local lemma. In Proc. 48th ACM Symposium on Theory of Computing (STOC 2016), pages 479–488. ACM Press, 2016. doi:10.1145/2897518.2897570.
- Brandt et al.  Sebastian Brandt, Juho Hirvonen, Janne H Korhonen, Tuomo Lempiäinen, Patric R J Östergård, Christopher Purcell, Joel Rybicki, Jukka Suomela, and Przemysław Uznański. LCL problems on grids. In Proc. 36th ACM Symposium on Principles of Distributed Computing (PODC 2017), pages 101–110. ACM Press, 2017. doi:10.1145/3087801.3087833.
- Chang and Pettie  Yi-Jun Chang and Seth Pettie. A Time Hierarchy Theorem for the LOCAL Model. In Proc. 58th IEEE Symposium on Foundations of Computer Science (FOCS 2017), pages 156–167. IEEE, 2017. doi:10.1109/FOCS.2017.23.
- Chang et al.  Yi-Jun Chang, Tsvi Kopelowitz, and Seth Pettie. An Exponential Separation between Randomized and Deterministic Complexity in the LOCAL Model. In Proc. 57th IEEE Symposium on Foundations of Computer Science (FOCS 2016), pages 615–624. IEEE, 2016. doi:10.1109/FOCS.2016.72.
- Chang et al.  Yi-Jun Chang, Qizheng He, Wenzheng Li, Seth Pettie, and Jara Uitto. The Complexity of Distributed Edge Coloring with Small Palettes. In Proc. 29th ACM-SIAM Symposium on Discrete Algorithms (SODA 2018), pages 2633–2652. Society for Industrial and Applied Mathematics, 2018. doi:10.1137/1.9781611975031.168.
- Chung et al.  Kai-Min Chung, Seth Pettie, and Hsin-Hao Su. Distributed algorithms for the Lovász local lemma and graph coloring. Distributed Computing, 30(4):261–280, 2017. doi:10.1007/s00446-016-0287-6.
- Cole and Vishkin  Richard Cole and Uzi Vishkin. Deterministic coin tossing with applications to optimal parallel list ranking. Information and Control, 70(1):32–53, 1986. doi:10.1016/S0019-9958(86)80023-7.
- Fischer and Ghaffari  Manuela Fischer and Mohsen Ghaffari. Sublogarithmic Distributed Algorithms for Lovász Local Lemma, and the Complexity Hierarchy. In Proc. 31st International Symposium on Distributed Computing (DISC 2017), pages 18:1–18:16, 2017. doi:10.4230/LIPIcs.DISC.2017.18.
- Ghaffari and Su  Mohsen Ghaffari and Hsin-Hao Su. Distributed Degree Splitting, Edge Coloring, and Orientations. In Proc. 28th ACM-SIAM Symposium on Discrete Algorithms (SODA 2017), pages 2505–2523. Society for Industrial and Applied Mathematics, 2017. doi:10.1137/1.9781611974782.166.
- Ghaffari et al. [2018a] Mohsen Ghaffari, David G Harris, and Fabian Kuhn. On Derandomizing Local Distributed Algorithms. In Proc. 59th IEEE Symposium on Foundations of Computer Science (FOCS 2018), 2018a. doi:10.1109/FOCS.2018.00069. URL http://arxiv.org/abs/1711.02194.
- Ghaffari et al. [2018b] Mohsen Ghaffari, Juho Hirvonen, Fabian Kuhn, and Yannic Maus. Improved Distributed -Coloring. In Proc. 37th ACM Symposium on Principles of Distributed Computing (PODC 2018), pages 427–436. ACM, 2018b. doi:10.1145/3212734.3212764.
- Kuhn  Fabian Kuhn. Weak graph colorings. In Proc. 21st ACM Symposium on Parallelism in Algorithms and Architectures (SPAA 2009), pages 138–144, New York, New York, USA, 2009. ACM Press. doi:10.1145/1583991.1584032.
- Linial  Nathan Linial. Locality in Distributed Graph Algorithms. SIAM Journal on Computing, 21(1):193–201, 1992. doi:10.1137/0221015.
- Naor  Moni Naor. A lower bound on probabilistic algorithms for distributive ring coloring. SIAM Journal on Discrete Mathematics, 4(3):409–412, 1991. doi:10.1137/0404036.
- Naor and Stockmeyer  Moni Naor and Larry Stockmeyer. What Can be Computed Locally? SIAM Journal on Computing, 24(6):1259–1277, 1995. doi:10.1137/S0097539793254571.
- Panconesi and Rizzi  Alessandro Panconesi and Romeo Rizzi. Some simple distributed algorithms for sparse networks. Distributed Computing, 14(2):97–100, 2001. doi:10.1007/PL00008932.
- Peleg  David Peleg. Distributed Computing: A Locality-Sensitive Approach. Society for Industrial and Applied Mathematics, 2000. doi:10.1137/1.9780898719772.