Locality of not-so-weak coloring

by   Alkida Balliu, et al.
Max Planck Society

Many graph problems are locally checkable: a solution is globally feasible if it looks valid in all constant-radius neighborhoods. This idea is formalized in the concept of locally checkable labelings (LCLs), introduced by Naor and Stockmeyer (1995). Recently, Chang et al. (2016) showed that in bounded-degree graphs, every LCL problem belongs to one of the following classes: - "Easy": solvable in O(^* n) rounds with both deterministic and randomized distributed algorithms. - "Hard": requires at least Ω( n) rounds with deterministic and Ω( n) rounds with randomized distributed algorithms. Hence for any parameterized LCL problem, when we move from local problems towards global problems, there is some point at which complexity suddenly jumps from easy to hard. For example, for vertex coloring in d-regular graphs it is now known that this jump is at precisely d colors: coloring with d+1 colors is easy, while coloring with d colors is hard. However, it is currently poorly understood where this jump takes place when one looks at defective colorings. To study this question, we define k-partial c-coloring as follows: nodes are labeled with numbers between 1 and c, and every node is incident to at least k properly colored edges. It is known that 1-partial 2-coloring (a.k.a. weak 2-coloring) is easy for any d > 1. As our main result, we show that k-partial 2-coloring becomes hard as soon as k > 2, no matter how large a d we have. We also show that this is fundamentally different from k-partial 3-coloring: no matter which k > 3 we choose, the problem is always hard for d = k but it becomes easy when d ≫ k. The same was known previously for partial c-coloring with c > 4, but the case of c < 4 was open.



There are no comments yet.


page 1

page 2

page 3

page 4


Towards the Locality of Vizing's Theorem

Vizing showed that it suffices to color the edges of a simple graph usin...

Distance-2 Coloring in the CONGEST Model

We give efficient randomized and deterministic distributed algorithms fo...

Hardness of minimal symmetry breaking in distributed computing

A graph is weakly 2-colored if the nodes are labeled with colors black a...

Distributed Recoloring

Given two colorings of a graph, we consider the following problem: can w...

Peacock Bundles: Bundle Coloring for Graphs with Globality-Locality Trade-off

Bundling of graph edges (node-to-node connections) is a common technique...

Local Mending

In this work we introduce the graph-theoretic notion of mendability: for...

Distributed Computing in the Asynchronous LOCAL model

The LOCAL model is among the main models for studying locality in the fr...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

(a) Before this work: (b) After this work:
Table 1: An overview of -partial -coloring in -regular graphs: for each and , the table shows what is the smallest such that the problem is easy. For example, “” means that for these parameters the problem is known to be easy in -regular graphs, while the case of -regular graphs is unknown. The new results are highlighted with a frame. Our main contributions are the new lower bounds for (Theorem 3) and upper bounds for (Theorem 2), which were previously completely open. We also obtain stronger lower bounds for e.g. , (Theorem 7) and stronger upper bounds for (Theorem 2).

There is a broad family of graph problems—so-called locally checkable labelings or LCLs [20]—that exhibits the following dichotomy [9]: 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.

If we look at -regular graphs for constant , then by prior work the following thresholds are known [21, 12, 6, 9]:

  • [noitemsep]

  • 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:

Definition 1.

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 :

  • [noitemsep]

  • -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 least

for 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 [20] 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. [9]. 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 [17]; for brevity, we call these partial colorings.

Weak coloring, .

In graphs without isolated nodes, a -partial -coloring is identical to a weak -coloring [20]. 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, .

In -regular graphs, a -partial -coloring is a proper -coloring. Recall that proper coloring with colors is easy [21, 12], while proper coloring with colors is known to be hard [6, 9].

Hardness of proper -coloring implies the lower bounds in the blue and gray regions of Table 1a.

Partial coloring for .

Barenboim et al. [4] gave an algorithm that computes a -defective -coloring in time , which is essentially a defective variant of Linial’s -coloring algorithm [18]. 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. [11], Fischer and Ghaffari [13], 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 [6].

Other algorithms.

Bonamy et al. [5] 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 [6].

3 Our contributions

To recap, by prior work, we have a good qualitative understanding of -partial -coloring for :

  • [noitemsep]

  • : easy for all .

  • : hard for but easy for .

We complete the picture for . For , we have precisely the same situation as above:

  • [noitemsep]

  • : easy for all .

  • : hard for but easy for .

However, the case of is fundamentally different:

  • [noitemsep]

  • : 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 [4]: 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 [6]. 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.

Theorem 2.

There exists an algorithm running in that is able to compute:

  • [noitemsep]

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

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.

Figure 1: Examples of the output of the -partial -coloring algorithm, running at the central node , in a graph where the degree is . The figure shows 3 cases: keeps the color chosen during the first sweep, switches to the special color in the second sweep, switches to color in the second sweep.

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.

-partial 3-coloring.

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.

  1. . Thus, can keep color , as the nodes above it that have color must then choose a color different from .

  2. . Then can safely choose color .

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

-partial -coloring.

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.

  1. . Then can keep color .

  2. . Then can safely choose color .

  3. 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. [9]. 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.

Theorem 3.

Computing a -partial -coloring in -regular trees in the LOCAL model requires deterministic time and randomized time, for any .

Dc-Local model.

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 [10].

Figure 2: In this example . Algorithm outputs “white” on the root of and “black” on the leftmost child of the root. The gadgets and are trees with depth rooted at and respectively.


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.

Property 4.

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.

Figure 3: In this example, the merged node of and has the same color as node , hence the edge in is oriented from to .

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.

Lemma 5.

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.

Lemma 6.

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

Theorem 7.

Computing a -partial -coloring in -regular graphs, for , requires deterministic time and randomized time.


Assume the problem is easy to solve. Each monochromatic subgraph has a maximum degree , and hence it is easy to color with colors. Hence overall we can easily find a proper coloring of a -regular graph with at most colors, but this is known to be hard [6, 9]. ∎


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

    Proc. 50th ACM Symposium on Theory of Computing (STOC 2018)

    , pages 1307–1318. ACM Press, 2018b.
  • Barenboim and Elkin [2013] Leonid Barenboim and Michael Elkin. Distributed Graph Coloring: Fundamentals and Recent Developments, volume 4. 2013. doi:10.2200/S00520ED1V01Y201307DCT011.
  • Barenboim et al. [2014] 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. [2018] 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. [2016] 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. [2017] 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 [2017] 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. [2016] 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. [2018] 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. [2017] 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 [1986] 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 [2017] 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 [2017] 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 [2009] 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 [1992] Nathan Linial. Locality in Distributed Graph Algorithms. SIAM Journal on Computing, 21(1):193–201, 1992. doi:10.1137/0221015.
  • Naor [1991] 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 [1995] 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 [2001] Alessandro Panconesi and Romeo Rizzi. Some simple distributed algorithms for sparse networks. Distributed Computing, 14(2):97–100, 2001. doi:10.1007/PL00008932.
  • Peleg [2000] David Peleg. Distributed Computing: A Locality-Sensitive Approach. Society for Industrial and Applied Mathematics, 2000. doi:10.1137/1.9780898719772.