Distributed Coloring of Graphs with an Optimal Number of Colors

This paper studies sufficient conditions to obtain efficient distributed algorithms coloring graphs optimally (i.e. with the minimum number of colors) in the LOCAL model of computation. Most of the work on distributed vertex coloring so far has focused on coloring graphs of maximum degree Delta with at most Delta+1 colors (or Delta colors when some simple obstructions are forbidden). When Delta is sufficiently large and c >= Delta-k_Delta+1, for some integer k_Delta ~~ sqrt{Delta}-2, we give a distributed algorithm that given a c-colorable graph G of maximum degree Delta, finds a c-coloring of G in min{O((log Delta)^{13/12}log n), 2^{O(log Delta+sqrt{log log n})}} rounds, with high probability. The lower bound Delta-k_Delta+1 is best possible in the sense that for infinitely many values of Delta, we prove that when chi(G) = Delta-k_Delta deciding whether chi(G) <= c is in P, while Embden-Weinert et al. proved that for c <= Delta-k_Delta-1, the same problem is NP-complete. Note that the sequential and distributed thresholds differ by one. Our first result covers the case where the chromatic number of the graph ranges between Delta-sqrt{Delta} and Delta+1. Our second result covers a larger range, but gives a weaker bound on the number of colors: For any sufficiently large Delta, and Omega(log Delta) 0, with a randomized algorithm running in O(log n/log log n) rounds with high probability

Local Conflict Coloring

Locally finding a solution to symmetry-breaking tasks such as vertex-coloring, edge-coloring, maximal matching, maximal independent set, etc., is a long-standing challenge in distributed network computing. More recently, it has also become a challenge in the framework of centralized local computation. We introduce conflict coloring as a general symmetry-breaking task that includes all the aforementioned tasks as specific instantiations --- conflict coloring includes all locally checkable labeling tasks from [Naor\&Stockmeyer, STOC 1993]. Conflict coloring is characterized by two parameters $l$ and $d$, where the former measures the amount of freedom given to the nodes for selecting their colors, and the latter measures the number of constraints which colors of adjacent nodes are subject to.We show that, in the standard LOCAL model for distributed network computing, if l/d \textgreater{} \Delta, then conflict coloring can be solved in $\tilde O(\sqrt{\Delta})+\log^*n$ rounds in $n$-node graphs with maximum degree $\Delta$, where $\tilde O$ ignores the polylog factors in $\Delta$. The dependency in~$n$ is optimal, as a consequence of the $\Omega(\log^*n)$ lower bound by [Linial, SIAM J. Comp. 1992] for $(\Delta+1)$-coloring. An important special case of our result is a significant improvement over the best known algorithm for distributed $(\Delta+1)$-coloring due to [Barenboim, PODC 2015], which required $\tilde O(\Delta^{3/4})+\log^*n$ rounds. Improvements for other variants of coloring, including $(\Delta+1)$-list-coloring, $(2\Delta-1)$-edge-coloring, $T$-coloring, etc., also follow from our general result on conflict coloring. Likewise, in the framework of centralized local computation algorithms (LCAs), our general result yields an LCA which requires a smaller number of probes than the previously best known algorithm for vertex-coloring, and works for a wide range of coloring problems

Locality of not-so-weak coloring

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(\log^* n)$ rounds with both deterministic and randomized distributed algorithms. - "Hard": requires at least $\Omega(\log n)$ rounds with deterministic and $\Omega(\log \log 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 \ge 1$. As our main result, we show that $k$-partial $2$-coloring becomes hard as soon as $k \ge 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 \ge 3$ we choose, the problem is always hard for $d = k$ but it becomes easy when $d \gg k$. The same was known previously for partial $c$-coloring with $c \ge 4$, but the case of $c < 4$ was open

Distributed Deterministic Edge Coloring using Bounded Neighborhood Independence

We study the {edge-coloring} problem in the message-passing model of distributed computing. This is one of the most fundamental and well-studied problems in this area. Currently, the best-known deterministic algorithms for (2Delta -1)-edge-coloring requires O(Delta) + log-star n time \cite{PR01}, where Delta is the maximum degree of the input graph. Also, recent results of \cite{BE10} for vertex-coloring imply that one can get an O(Delta)-edge-coloring in O(Delta^{epsilon} \cdot \log n) time, and an O(Delta^{1 + epsilon})-edge-coloring in O(log Delta log n) time, for an arbitrarily small constant epsilon > 0. In this paper we devise a drastically faster deterministic edge-coloring algorithm. Specifically, our algorithm computes an O(Delta)-edge-coloring in O(Delta^{epsilon}) + log-star n time, and an O(Delta^{1 + epsilon})-edge-coloring in O(log Delta) + log-star n time. This result improves the previous state-of-the-art {exponentially} in a wide range of Delta, specifically, for 2^{Omega(\log-star n)} \leq Delta \leq polylog(n). In addition, for small values of Delta our deterministic algorithm outperforms all the existing {randomized} algorithms for this problem. On our way to these results we study the {vertex-coloring} problem on the family of graphs with bounded {neighborhood independence}. This is a large family, which strictly includes line graphs of r-hypergraphs for any r = O(1), and graphs of bounded growth. We devise a very fast deterministic algorithm for vertex-coloring graphs with bounded neighborhood independence. This algorithm directly gives rise to our edge-coloring algorithms, which apply to {general} graphs. Our main technical contribution is a subroutine that computes an O(Delta/p)-defective p-vertex coloring of graphs with bounded neighborhood independence in O(p^2) + \log-star n time, for a parameter p, 1 \leq p \leq Delta

Local Multicoloring Algorithms: Computing a Nearly-Optimal TDMA Schedule in Constant Time

The described multicoloring problem has direct applications in the context of wireless ad hoc and sensor networks. In order to coordinate the access to the shared wireless medium, the nodes of such a network need to employ some medium access control (MAC) protocol. Typical MAC protocols control the access to the shared channel by time (TDMA), frequency (FDMA), or code division multiple access (CDMA) schemes. Many channel access schemes assign a fixed set of time slots, frequencies, or (orthogonal) codes to the nodes of a network such that nodes that interfere with each other receive disjoint sets of time slots, frequencies, or code sets. Finding a valid assignment of time slots, frequencies, or codes hence directly corresponds to computing a multicoloring of a graph $G$. The scarcity of bandwidth, energy, and computing resources in ad hoc and sensor networks, as well as the often highly dynamic nature of these networks require that the multicoloring can be computed based on as little and as local information as possible