Graph Coloring via Degeneracy in Streaming and Other Space-Conscious Models

TL;DR

This paper presents space-efficient algorithms for graph coloring based on degeneracy across various big data models, nearly matching the theoretical lower bounds and advancing understanding of the complexity involved.

Contribution

It introduces sublinear algorithms for coloring graphs using degeneracy in multiple models and establishes near-tight lower bounds on their space and query complexity.

Findings

Algorithms color graphs with about κ(G) colors in sublinear time.

Lower bounds show that achieving similar results requires quadratic space or queries.

Results are close to optimal given the degeneracy parameter.

Abstract

We study the problem of coloring a given graph using a small number of colors in several well-established models of computation for big data. These include the data streaming model, the general graph query model, the massively parallel computation (MPC) model, and the CONGESTED-CLIQUE and the LOCAL models of distributed computation. On the one hand, we give algorithms with sublinear complexity, for the appropriate notion of complexity in each of these models. Our algorithms color a graph $G$ using about $\kappa(G)$ colors, where $\kappa(G)$ is the degeneracy of $G$: this parameter is closely related to the arboricity $\alpha(G)$. As a function of $\kappa(G)$ alone, our results are close to best possible, since the optimal number of colors is $\kappa(G)+1$. On the other hand, we establish certain lower bounds indicating that sublinear algorithms probably cannot go much further. In particular, we prove that any randomized coloring algorithm that uses $\kappa(G)+1$ many colors, would require $\Omega(n^2)$ storage in the one pass streaming model, and $\Omega(n^2)$ many queries in the general graph query model, where $n$ is the number of vertices in the graph. These lower bounds hold even when the value of $\kappa(G)$ is known in advance; at the same time, our upper bounds do not require $\kappa(G)$ to be given in advance.

Tables

Table 1. Table 1: Summary of our algorithmic results and basic comparison with most related previous work. In the result marked ( ⋆ ), we require that κ = ω ​ ( log 2 ⁡ n ) 𝜅 𝜔 superscript 2 𝑛 \kappa=\omega(\log^{2}n) . In the first two results, the number of colors can be improved to min ⁡ { Δ + 1 , κ + o ​ ( κ ) } Δ 1 𝜅 𝑜 𝜅 \min\{\Delta+1,\kappa+o(\kappa)\} by running our algorithm alongside that of  [ ACK19 ] ; in the streaming setting, this would require knowing Δ Δ \Delta in advance.

Model	Number of Colors	Complexity Parameters		Source
Streaming	$\Delta +1$	$\tilde{O}\left(n\right)$ space,	$\tilde{O}\left(n\sqrt{\Delta }\right)$ post-processing time	[ACK19]
(one pass)	$\kappa +o\left(\kappa \right)$	$\tilde{O}\left(n\right)$ space,	$\tilde{O}\left(n\right)$ post-processing time	this paper
Query	$\Delta +1$	$\tilde{O}\left(n^{3/2}\right)$ queries		[ACK19]
	$\kappa +o\left(\kappa \right)$	$\tilde{O}\left(n^{3/2}\right)$ queries		this paper
MPC	$\Delta +1$	$O\left(1\right)$ rounds,	$O\left(n{\log }^{3}n\right)$ bits per processor	[ACK19]
	$\kappa +o\left(\kappa \right)$	$O\left(1\right)$ rounds,	$O\left(n{\log }^{2}n\right)$ bits per processor	this paper
Congested Clique	$\Delta +1$	$O\left(1\right)$ rounds		[CFG+18]
	$\kappa +o{\left(\kappa \right)}^{\star }$	$O\left(1\right)$ rounds		this paper
$\mathrm{LOCAL}$	$O\left(\alpha n^{1/k}\right)$	$O\left(k\right)$ rounds,	for   $k\in [\omega \left(\log \log n\right),O\left(\sqrt{\log n}\right)]$	[KP11]
	$O\left(\alpha n^{1/k}\log n\right)$	$O\left(k\right)$ rounds,	for $k\in [\omega \left(\sqrt{\log n}\right),o\left(\log n\right)]$	this paper

Table 2. Table 2: Statistics of several large real-world graphs taken from the application domains of social networks, web graphs, and biological networks, showing that the degeneracy, κ 𝜅 \kappa , is often significantly smaller than the maximum degree, Δ Δ \Delta . Source: %****␣deg-degen-table.tex␣Line␣100␣****http://networkrepository.com   [ RA15 ] .

Graph Name	$\left|V\right|$	$\left|E\right|$	$\Delta$	$\kappa$
soc-friendster	$66$M	$2$B	$5$K	$305$
fb-uci-uni	$59$M	$92$M	$5$K	$17$
soc-livejournal	$4$M	$28$M	$3$K	$214$
soc-orkut	$3$M	$106$M	$27$K	$231$
web-baidu-baike	$2$M	$18$M	$98$K	$83$
web-hudong	$2$M	$15$M	$62$K	$529$
web-wikipedia2009	$2$M	$5$M	$3$K	$67$
web-google	$916$K	$5$M	$6$K	$65$
bio-mouse-gene	$43$K	$14$M	$8$K	$1$K
bio-human-gene1	$22$K	$12$M	$8$K	$2$K
bio-human-gene2	$14$K	$9$M	$7$K	$2$K
bio-WormNet-v3	$16$K	$763$K	$1$K	$165$

Equations

$$N_{G,⊲}(v):=\{w\in V(G):\{v,w\}\in E(G),v⊲w\},$$

$$\ell =\lceil \frac{2nk}{s}\rceil ,\lambda =3\sqrt{\kappa \ell \log n},$$

$$\sum _{i=1}^{\ell }(\kappa (G_i)+1)⩽\ell \left(\frac{\kappa +\lambda }{\ell }+1\right)=\kappa +\lambda +\ell ,$$

$$\frac{n}{\ell }⩾\frac{s}{4k}⩾\frac{Cn\log n}{4k}⩾\frac{C\log n}{4}.$$

$$\mathrm{Pr}\left[|V(G_i)|>\frac{2n}{\ell }\right]⩽\exp \left(-\frac{n}{3\ell }\right)⩽\exp \left(-\frac{C\log n}{12}\right)⩽\frac{1}{n^2},$$

$$\ell ⩽\lceil \frac{2k}{C\log n}\rceil ⩽\frac{4k}{C\log n}⩽\frac{8\kappa }{C\log n},$$

$$\lambda ⩽3\sqrt{\kappa \cdot \frac{8\kappa }{C\log n}\cdot \log n}⩽\kappa .$$

$${\mathrm{odeg}}_{G_j,{⊲}_j}(v)=\sum _{u\in N_{G,⊲(v)}}\text{mathbbm}{1}_{\{\psi (u)=\psi (v)\}}$$

$$\mathrm{Pr}\left[{\mathrm{odeg}}_{G_j,{⊲}_j}(v)>\frac{\kappa +\lambda }{\ell }\right]⩽\exp \left(-\frac{\kappa }{\ell }\frac{{\lambda }^2}{3{\kappa }^2}\right)=\exp \left(-\frac{9\kappa \ell \log n}{3\kappa \ell }\right)⩽\frac{1}{n^3},$$

$$|E(G_1)\cup \cdots \cup E(G_{\ell })|⩽\sum _{i=1}^{\ell }\kappa (G_i)|V(G_i)|⩽\frac{\kappa +\lambda }{\ell }\sum _{i=1}^{\ell }|V(G_i)|=\frac{n(\kappa +\lambda )}{\ell }⩽\frac{2n\kappa }{\ell }⩽s,$$

$$\frac{1}{2}\sum _{i\in [\ell ]}|V(G_i){|}^2⩽\frac{\ell }{2}{\left(\frac{2n}{\ell }\right)}^2⩽\frac{2n^{2}s}{4nk}=\Theta \left(\frac{n^{3/2}\log n}{{\epsilon }^2}\right),$$

$$|E(G_i)|⩽\kappa (G_i)|V(G_i)|⩽\frac{\kappa +\lambda }{\ell }\frac{2n}{\ell }⩽\frac{4n\kappa }{{\ell }^2}⩽\frac{4nk}{(2nk/s{)}^2}=\frac{O({\epsilon }^{-2}n\log n{)}^2}{nk}=O\left(\frac{n{\log }^{2}n}{{\epsilon }^{4}k}\right)=O(n\log n).$$

$$O(n/\log n)\cdot O(\log n)\cdot O(\log n)=O(n\log n)\text{ bits.}$$

$$L\cup R\setminus \{{\ell }_y,r_z\}⊲{\ell }_y⊲\{r_z\}\cup C$$

$$V(G)\setminus S⊲\overline{\ell }⊲S\setminus \{\overline{\ell }\}$$

$$E(H_{ij})=E(H)\setminus\big{\{}\,\{a_{i},a_{j}\},\{b_{i},b_{j}\}\,\big{\}}\cup\big{\{}\,\{a_{i},b_{j}\},\{a_{j},b_{i}\}\,\big{\}}\,.$$

$$\text{textsc}{unique-or}_N(\mathbf{x})=\{\begin{array}{ll}0,& \text{if }\mathbf{x}=0,\\ 1,& \text{if }\mathbf{x}={\mathbf{e}}_i,\text{ for }i\in [N],\\ \star ,& \text{otherwise;}\end{array}\text{textsc}{unique-find}_N(\mathbf{x})=\{\begin{array}{ll}i,& \text{if }\mathbf{x}={\mathbf{e}}_i,\text{ for }i\in [N],\\ \star ,& \text{otherwise.}\end{array}$$

$$J_{n,t}=(A\uplus B,E),\text{where }|A|=t,|B|=n-t,E=\{\{u,v\}:u\in A,v\in A\cup B,u\ne v\}.$$

$${\left(r\cdot \frac{t/r}{t+t/r}\right)}^{|B|}={\left(\frac{r}{r+1}\right)}^{n-t}.$$

$$\frac{2}{3}⩽\frac{r^n}{(r+1{)}^{n-t}}={\left(1-\frac{1}{r+1}\right)}^n(r+1{)}^t⩽\exp \left(-\frac{n}{r+1}+t\ln (r+1)\right).$$

Full text

On the other hand, we establish certain lower bounds indicating that sublinear algorithms probably cannot go much further. In particular, we prove that any randomized coloring algorithm that uses at most $\kappa(G)+1$ colors would require $\Omega(n^{2})$ storage in the one pass streaming model, and $\Omega(n^{2})$ many queries in the general graph query model, where $n$ is the number of vertices in the graph. These lower bounds hold even when the value of $\kappa(G)$ is known in advance; at the same time, our upper bounds do not require $\kappa(G)$ to be given in advance.

1 Introduction

Graph coloring is a fundamental topic in combinatorics and the corresponding algorithmic problem of coloring an input graph with few colors is a basic and heavily studied problem in computer science. It has numerous applications including in scheduling [TZP18, LS86, Lei79], air traffic flow management [BB04], frequency assignment in wireless networks [BB06, PL96], register allocation [Cha82, CH90, CAC*+*81]. More recently, vertex coloring has been used to compute seed vertices in social networks that are then expanded to detect community structures in the network [MOT14].

Given an $n$-vertex graph $G=(V,E)$, the task is to assign colors to the vertices in $V$ so that no two adjacent vertices get the same color. Doing so with the minimum possible number of colors—called the chromatic number, $\chi(G)$—is famously hard: it is NP-hard to even approximate $\chi(G)$ to a factor of $n^{1-\varepsilon}$ for any constant $\varepsilon>0$ [FK96, Zuc06, KP06]. In the face of this hardness, it is algorithmically interesting to color $G$ with a possibly suboptimal number of colors depending upon tractable parameters of $G$. One such simple parameter is $\Delta$, the maximum degree: a trivial greedy algorithm colors $G$ with $\Delta+1$ colors.

We study graph coloring in a number of space-constrained and data-access-constrained settings, including the data streaming model and certain distributed computing models. In such settings, finding a coloring with “about $\Delta$” colors is a fairly nontrivial problem that has been studied from various angles in a flurry of research over the last decade [ACK19, BCHN18, HSS16, CLP18, PS18, Bar16]. In a recent breakthrough (awarded Best Paper at SODA 2019), Assadi, Chen, and Khanna [ACK19] gave sublinear algorithms for $(\Delta+1)$-coloring an input graph in such models.

In this work, we focus on colorings that use “about $\kappa$” colors, where $\kappa=\kappa(G)$ is the degeneracy of $G$, a parameter that improves upon $\Delta$. It is defined as follows: $\kappa=\min\{k:$ every induced subgraph of $G$ has a vertex of degree at most $k\}$. Clearly, $\kappa\leqslant\Delta$. There is a simple greedy algorithm that runs in linear time and produces $(\kappa+1)$-coloring; see Section 2. However, just as before, when processing a massive graph under the constraints of either the space-bounded streaming model or certain distributed computing models, the inherently sequential nature of the greedy algorithm makes it infeasible.

1.1 Our Results and Techniques

We obtain a number of algorithmic results, as well as several lower bound results.

Algorithms.  We give new graph coloring algorithms, parametrized by $\kappa$, in the following models:

(1) the data streaming model, where the input is a stream of edge insertions and deletions (i.e., a dynamic graph stream) resulting in the eventual graph to be colored and we are limited to a work space of $\widetilde{O}(n)$ bits111The $\widetilde{O}(\cdot)$ notation hides factors polylogarithmic in $n$., the so-called semi-streaming setting [FKM*+*05];

(2) the general graph query model [Gol17], where we may access the graph using only neighbor queries (what is the $i$th neighbor of $x$?) and pair queries (are $x$ and $y$ adjacent?);

(3) the massively parallel communication (MPC) model, where each of a large number of memory-limited processors holds a sublinear-sized portion of the input data and computation proceeds using rounds of communication;

(4) the congested clique model of distributed computation, where there is one processor per vertex holding that vertex’s neighborhood information and each round allows each processor to communicate $O(\log n)$ bits to a specific other processor; and

(5) the LOCAL model of distributed computation, where there is one processor per vertex holding that vertex’s neighborhood information and each round allows each processor to send an arbitrary amount of information to all its neighbors.

Table 1 summarizes our algorithmic results and provides, in each case, a basic comparison with the most related result from prior work; more details appear in Section 1.2. As we have noted, $\kappa\leqslant\Delta$ in every case; indeed, $\kappa$ could be arbitrarily better than $\Delta$ as shown by the example of a star graph, where $\kappa=1$ whereas $\Delta=n-1$. From a practical standpoint, it is notable that in many real-world large graphs drawn from various application domains—such as social networks, web graphs, and biological networks—the parameter $\kappa$ is often significantly smaller than $\Delta$. See Table 2 for some concrete numbers. That said, $\kappa+o(\kappa)$ is mathematically incomparable with $\Delta+1$.

The parameter $\kappa$ is also closely related to the arboricity $\alpha=\alpha(G)$, defined as the minimum number of forests into which the edges of $G$ can be partitioned. It is an easy exercise to show that $\alpha\leqslant\kappa\leqslant 2\alpha-1$.

Perhaps even more than these results, our key contribution is a conceptual idea and a corresponding technical lemma underlying all our algorithms. We show that every graph admits a “small” sized low degeneracy partition (LDP), which is a partition of its vertex set into “few” blocks such that the subgraph induced by each block has low degeneracy, roughly logarithmic in $n$. Moreover, such an LDP can be computed by a very simple and distributed randomized algorithm: for each vertex, choose a “color” independently and uniformly at random from a suitable-sized palette (this is not to be confused with the eventual graph coloring we seek; this random assignment is most probably not a proper coloring of the graph). The resulting color classes define the blocks of such a partition, with high probability. Theorem 3.1, the LDP Theorem, makes this precise.

Given an LDP, a generic graph coloring algorithm is to run the aforementioned minimum-degree-based greedy algorithm on each block, using distinct palettes for the distinct blocks. We obtain algorithms achieving our claimed results by suitably implementing this generic algorithm in each computational model.

Lower Bounds.  Recall that a graph with degeneracy $\kappa$ admits a proper $(\kappa+1)$-coloring. As Table 1 makes clear, there are several space-conscious $(\Delta+1)$-coloring algorithms known; perhaps we could aim for improved algorithms that provide $(\kappa+1)$-colorings? We prove that this is not possible in sublinear space in either the streaming or the query model. In fact, our lower bounds prove more. We show that distinguishing $n$-vertex graphs of degeneracy $\kappa$ from those with chromatic number $\kappa+2$ requires $\Omega(n^{2})$ space in the streaming model and $\Omega(n^{2})$ queries in the general graph query model. This shows that it is hard to produce a $(\kappa+1)$-coloring and in fact even to determine the value of $\kappa$. These results generalize to the problems of producing a $(\kappa+\lambda)$-coloring or estimating the degeneracy up to $\pm\lambda$; the corresponding lower bounds are $\Omega(n^{2}/\lambda^{2})$. Furthermore, the streaming lower bounds hold even in the insertion-only model, where the input stream is simply a listing of the graph’s edges in some order; compare this with our upper bound, which holds even for dynamic graph streams.

A possible criticism of the above lower bounds for coloring is that they seem to depend on it being hard to estimate the degeneracy $\kappa$. Perhaps the coloring problem could become easier if $\kappa$ was given to the algorithm in advance? We prove two more lower bounds showing that this is not so: the same $\Omega(n^{2}/\lambda^{2})$ bounds hold even with $\kappa$ known a priori.

Most of our streaming lower bounds use reductions from the index problem in communication complexity (a standard technique), via a novel gadget that we develop here; one bound uses a reduction from a variant of disjointness. Our query lower bounds use a related gadget and reductions from basic problems in Boolean decision tree complexity.

We conclude the paper with a “combinatorial” lower bound that addresses a potential criticism of our main algorithmic technique: the LDP. Perhaps a more sophisticated graph-theoretic result, such as the Palette Sparsification Theorem of Assadi et al. (see below), could improve the quality of the colorings obtained? We prove that this is not so: there is no analogous theorem for colorings with “about $\kappa$” colors.

1.2 Related Work and Comparisons

Streaming and Query Models.  The work closest to ours in spirit is the recent breakthrough of Assadi, Chen, and Khanna [ACK19]: they give a one-pass streaming $(\Delta+1)$-coloring algorithm that uses $\widetilde{O}(n)$ space (i.e., is semi-streaming) and works on dynamic graph streams. Their algorithm exploits a key structural result that they establish: choosing a random $O(\log n)$-sized palette from $\{1,\ldots,\Delta+1\}$ for each vertex allows a compatible list coloring. They call this the Palette Sparsification Theorem. Their algorithm processes each stream update quickly, but then spends $\widetilde{O}(n\sqrt{\Delta})$ time in post-processing. Our algorithm is similarly quick with the stream updates and has a faster $\widetilde{O}(n)$-time post-processing step. Further, our algorithm is “truly one-pass” in that it does not require foreknowledge of $\kappa$ or any other parameter of the input graph, whereas the Assadi et al. algorithm needs to know the precise value of $\Delta$ before seeing the stream.

In the same paper, Assadi et al. also consider the graph coloring problem in the query model. They give a $(\Delta+1)$-coloring algorithm that makes $\widetilde{O}(n^{3/2})$ queries, followed by a fairly elaborate computation that runs in $\widetilde{O}(n^{3/2})$ time and space. Our algorithm has the same complexity parameters and is arguably much simpler: its post-processing is just the straightforward greedy offline algorithm for $(\kappa+1)$-coloring.

Another recent work on coloring in the streaming model is Radhakrishnan et al. [RSV15], which studies the problem of $2$-coloring an $n$-uniform hypergraph. In the query model, there are a number of works studying basic graph problems [GR08, PR07, CRT05] but, to the best of our knowledge, Assadi et al. were the first to study graph coloring in this sense. Also, to the best of our knowledge, there was no previously known algorithm for $O(\alpha)$-coloring in a semi-streaming setting, whereas here we obtain $(\kappa+o(\kappa))$-colorings; recall the bound $\kappa\leqslant 2\alpha-1$.

MPC and Congested Clique Models.  The MapReduce framework [DG04] is extensively used in distributed computing to analyze and process massive data sets. Beame, Koutris, and Suciu [BKS17] defined the Massively Parallel Communication (MPC) model to abstract out key theoretical features of MapReduce; it has since become a widely used setting for designing and analyzing big data algorithms, especially for graph problems. In this model, an input of size $m$ is distributed among $p\approx m/S$ processors, each of which is computationally unbounded and restricted to $S$ bits of space. The processors operate in synchronous rounds; in each round, a processor may communicate with all others, subject to the space constraint. The focus is on using a very small number of rounds.

Another well-studied model for distributed graph algorithms is Congested Clique [LPPP05], where there are $n$ nodes, each holding the local neighborhood information for one of the $n$ vertices of the input graph. The nodes communicate in synchronous rounds; in a round, every pair of processors may communicate, but each message is restricted to $O(\log n)$ bits. Behnezhad et al. [BDH18] show that Congested Clique is equivalent to the so-called “semi-MPC model,” defined as MPC with $O(n\log n)$ bits of memory per machine: there are simulations in both directions preserving the round complexity.

Graph coloring has been studied in these models before. Harvey et al. [HLL18] gave a $(\Delta+o(\Delta))$-coloring algorithm in the MapReduce model; it can be simulated in MPC using $O(1)$ rounds and $O(n^{1+c})$ space per machine for some constant $c>0$. Parter [Par18] gave a Congested Clique algorithm for $(\Delta+1)$-coloring using $O(\log\log\Delta\cdot\log^{\star}\Delta)$ rounds; Parter and Su [PS18] improved this to $O(\log^{\star}\Delta)$. The aforementioned paper of Assadi et al. [ACK19] gives an MPC algorithm for $(\Delta+1)$-coloring using $O(1)$-round and $O(n\log^{3}n)$ bits of space per machine. Because this space usage is $\omega(n\log n)$, the equivalence result of Behnezad et al. [BDH18] does not apply and this doesn’t lead to an $O(1)$-round Congested Clique algorithm. In contrast, our MPC algorithm uses only $O(n\log n)$ bits of space per machine for graphs with degeneracy $\omega(\log^{2}n)$, and therefore leads to such a Congested Clique algorithm. Chang et al. [CFG*+*18] have recently designed two $(\Delta+1)$ list-coloring algorithms: an $O(1)$-round Congested Clique algorithm, and an $O(\sqrt{\log\log n})$-round MPC algorithm with $o(n)$ space per machine and $\widetilde{O}(m)$ space in total. To the best of our knowledge, no $O(\alpha)$-coloring algorithm was previously known, in either the MPC or the Congested Clique model.

The LOCAL Model.  The LOCAL model of distributed computing is “orthogonal” to Congested Clique: the input setup is similar but, during computation, each node may only communicate with its neighbors in the input graph, though it may send an arbitrarily long message. As before, the focus is on minimizing the number of rounds (a.k.a., time). There is a deep body of work on graph coloring in this model. Indeed, graph coloring is one of the most central “symmetry breaking” problems in distributed computing. We refer the reader to the monograph by Barenboim and Elkin [BE13] for an excellent overview of the state of the art. Here, we shall briefly discuss only a few results closely related to our contribution.

There is a long line of work on fast $(\Delta+1)$-coloring in the LOCAL model, in the deterministic as well as the randomized setting [PS96, Bar16, FHK16, Lub86, Joh99, ABI86, SW10, BEPS16] culminating in sublogarithmic time solutions due to Harris [HSS16] and Chang et al. [CLP18]. Barenboim and Elkin [BE10, BE11] studied fast distributed coloring algorithms that may use far fewer than $\Delta$ colors: in particular, they gave algorithms that use $O(\alpha)$ colors and run in $O(\alpha^{\varepsilon}\log n)$ time on graphs with arboricity at most $\alpha$. Recall again that $\kappa\leqslant 2\alpha-1$, so that a $2\alpha$-coloring always exists. They also gave a faster $O(\log n)$-time algorithm using $O(\alpha^{2})$ colors. Further, they gave a family of algorithms that produce an $O(t\alpha^{2})$-coloring in $O(\log_{t}n+\log^{\star}n)$, for every $t$ such that $2\leqslant t\leqslant O(\sqrt{{n}/{\alpha}})$. Our algorithm for the LOCAL model builds on this latter result.

Kothapalli and Pemmaraju [KP11] focused on arboricity-dependant coloring using very few rounds. They gave a randomized $O(k)$-round algorithm that uses $O(\alpha n^{1/k})$ colors for $2\log\log n\leqslant k\leqslant\sqrt{\log n}$ and $O(\alpha^{1+1/k}n^{1/k+3/k^{2}}2^{-2^{k}})$ colors for $k<2\log\log n$. We extend their result to the range k\in\big{[}\omega(\sqrt{\log n}),\,o(\log n)\big{]}, using $O(\alpha n^{1/k}\log n)$ colors.

Ghaffari and Lymouri [GL17] gave a randomized $O(\alpha)$-coloring algorithm that runs in time $O(\log n\cdot\min\{\log\log n,\log\alpha\})$ as well as an $O(\log n)$-time algorithm using $\min\{(2+\varepsilon)\alpha+O(\log n\log\log n),$ $O(\alpha\log\alpha)\}$ colors, for any constant $\varepsilon>0$. However, their technique does not yield a sublogarithmic time algorithm, even at the cost of a larger palette.

The LDP Technique.  As mentioned earlier, our algorithmic results rely on the concept of a low degeneracy partition (LDP) that we introduce in this work. Some relatives of this idea have been considered before. Specifically, Barenboim and Elkin [BE13] define a $d$-defective (resp. $b$-arbdefective) $c$-coloring to be a vertex coloring using palette $[c]$ such that every color class induces a subgraph with maximum degree at most $d$ (resp. arboricity at most $b$). Obtaining such improper colorings is a useful first step towards obtaining proper colorings. They give deterministic algorithms to obtain good arbdefective colorings [BE11]. However, their algorithms are elaborate and are based on construction of low outdegree acyclic partial orientations of the graph’s edges: an expensive step in our space-conscious models.

Elsewhere (Theorem 10.5 of Barenboim and Elkin [BE13]), they note that a useful defective (not arbdefective) coloring is easily obtained by randomly picking a color for each vertex; this is then useful for computing an $O(\Delta)$-coloring.

Our LDP technique can be seen as a simple randomized method for producing an arbdefective coloring. Crucially, we parametrize our result using degeneracy instead of arboricity and we give sharp—not just asymptotic—bounds on the degeneracy of each color class.

Other Related Work.  Other work considers coloring in the setting of dynamic graph algorithms: edges are inserted and deleted over time and the goal is to maintain a valid vertex coloring of the graph that must be updated quickly after each modification. Unlike in the streaming setting, there is no space restriction. Bhattacharya et al. [BCHN18] gave a randomized algorithm that maintains a $(\Delta+1)$-coloring with $O(\log\Delta)$ expected amortized update time and a deterministic algorithm that maintains a $(\Delta+o(\Delta))$-coloring with $O(\operatorname{polylog}\Delta)$ amortized update time. Barba et al. [BCK*+*17] gave tradeoffs between the number of colors used and update time. However, the techniques in these works do not seem to apply in the streaming setting due to fundamental differences in the models.

Estimating the arboricity of a graph in the streaming model is a well studied problem. McGregor et al. [MTVV15] gave a one pass $(1+\varepsilon)$-approximation algorithm to estimate the arboricity of graph using $\widetilde{O}(n)$ space. Bahmani et al. [BKV12] gave a matching lower bound. Our lower bounds for estimating degeneracy are quantitatively much larger but they call for much tighter estimates.

2 Preliminaries

Throughout this paper, graphs are simple, undirected, and unweighted. In considering a graph coloring problem, the input graph will usually be called $G$ and we will put $n=|V(G)|$. The notation “$\log x$” stands for $\log_{2}x$. For an integer $k$, we denote the set $\{1,2,\ldots,k\}$ by $[k]$.

For a graph $G$, we define $\Delta(G)=\max\{\deg(v):\,v\in V(G)\}$. We say that $G$ is $k$-degenerate if every induced subgraph of $G$ has a vertex of degree at most $k$. For instance, every forest is $1$-degenerate and an elementary theorem says that every planar graph is $5$-degenerate. The degeneracy $\kappa(G)$ is the smallest $k$ such that $G$ is $k$-degenerate. The arboricity $\alpha(G)$ is the smallest $r$ such that the edge set $E(G)$ can be partitioned into $r$ forests. When the graph $G$ is clear from the context, we simply write $\Delta$, $\kappa$, and $\alpha$, instead of $\Delta(G)$, $\kappa(G)$, and $\alpha(G)$.

We note two useful facts: the first is immediate from the definition, and the second is an easy exercise.

Fact 2.1**.**

If an $n$-vertex graph has degeneracy $\kappa$, then it has at most $\kappa n$ edges. ∎

Fact 2.2**.**

In every graph, the degeneracy $\kappa$ and arboricity $\alpha$ satisfy $\alpha\leqslant\kappa\leqslant 2\alpha-1$. ∎

In analyzing our algorithms, it will be useful to consider certain vertex orderings of graphs and their connection with the notion of degeneracy, given by Lemma 2.5 below. Although the lemma is folklore, it is crucial to our analysis, so we include a proof for completeness.

Definition 2.3**.**

An ordering of $G$ is a list consisting of all its vertices (equivalently, a total order on $V(G)$). Given an ordering $\mathrel{\lhd}$, for each $v\in V(G)$, the ordered neighborhood

[TABLE]

i.e., the set of neighbors of $v$ that appear after $v$ in the ordering. The ordered degree $\operatorname{odeg}_{G,\mathrel{\lhd}}(v):=|N_{G,\mathrel{\lhd}}(v)|$.

Definition 2.4**.**

A degeneracy ordering of $G$ is an ordering produced by the following algorithm: starting with an empty list, repeatedly pick a minimum degree vertex $v$ (breaking ties arbitrarily), append $v$ to the end of the list, and delete $v$ from $G$; continue this until $G$ becomes empty.

Lemma 2.5**.**

A graph $G$ is $k$-degenerate iff there exists an ordering $\mathrel{\lhd}$ such that $\operatorname{odeg}_{G,\mathrel{\lhd}}(v)\leqslant k$ for all $v\in V(G)$.

Proof.

Suppose that $G$ is $k$-degenerate. Let $\mathrel{\lhd}\,=(v_{1},\ldots,v_{n})$ be a degeneracy ordering. Then, for each $i$, $\operatorname{odeg}_{G,\mathrel{\lhd}}(v_{i})$ is the degree of $v_{i}$ in the induced subgraph $G\setminus\{v_{1},\ldots,v_{i-1}\}$. By definition, this induced subgraph has a vertex of degree at most $k$, so $v_{i}$, being a minimum degree vertex in the subgraph, must have degree at most $k$.

On the other hand, suppose that $G$ has an ordering $\mathrel{\lhd}$ such that $\operatorname{odeg}_{G,\mathrel{\lhd}}(v)\leqslant k$ for all $v\in V(G)$. Let $H$ be an induced subgraph of $G$. Let $v$ be the leftmost (i.e., smallest) vertex in $V(H)$ according to $\mathrel{\lhd}$. Then all neighbors of $v$ in $H$ in fact lie in $N_{G,\mathrel{\lhd}}(v)$, so $\deg_{H}(v)\leqslant\operatorname{odeg}_{G,\mathrel{\lhd}}(v)\leqslant k$. Therefore, $G$ is $k$-degenerate. ∎

A $c$-coloring of a graph $G$ is a mapping $\operatorname{\psi}\colon V(G)\to[c]$; it is said to be a proper coloring if it makes no edge monochromatic: $\operatorname{\psi}(u)\neq\operatorname{\psi}(v)$ for all $\{u,v\}\in E(G)$. The smallest $c$ such that $G$ has a proper $c$-coloring is called the chromatic number $\chi(G)$. By considering the vertices of $G$ one at a time and coloring greedily, we immediately obtain a proper $(\Delta+1)$-coloring. This idea easily extends to degeneracy-based coloring.

Lemma 2.6**.**

Given unrestricted (“offline”) access to an input graph $G$, we can produce a proper $(\kappa+1)$-coloring in linear time.

Proof.

Construct a degeneracy ordering $(v_{1},\ldots,v_{n})$ of $G$ and then consider the vertices one by one in the order $(v_{n},\ldots,v_{1})$, coloring greedily. Given a palette of size $\kappa+1$, by the “only if” direction of Lemma 2.5, there will always be a free color for a vertex when it is considered. ∎

Of course, the simple algorithm above is not implementable directly in “sublinear” settings, such as space-bounded streaming algorithms, query models, or distributed computing models. Nevertheless, we shall make use of the algorithm on suitably constructed subgraphs of our input graph.

We shall use the following form of the Chernoff bound.

Fact 2.7**.**

Let $X$ be a sum of mutually independent indicator random variables. Let $\mu$ and $\delta$ be real numbers such that $\mathbb{E}X\leqslant\mu$ and $0\leqslant\delta\leqslant 1$. Then, $\Pr\left[X\geqslant(1+\delta)\mu\right]\leqslant\exp\left(-\mu\delta^{2}/3\right)$. ∎

3 A Generic Framework for Coloring

In this section, we give a generic framework for graph coloring that we later instantiate in various computational models. As a reminder, our focus is on graphs $G$ with a nontrivial upper bound on the degeneracy $\kappa=\kappa(G)$. Each such graph admits a proper $(\kappa+1)$-coloring; our focus will be on obtaining a proper $(\kappa+o(\kappa))$-coloring efficiently.

As a broad outline, our framework calls for coloring $G$ in two phases. The first phase produces a low degeneracy partition (LDP) of $G$: it partitions $V(G)$ into a “small” number of parts, each of which induces a subgraph that has “low” degeneracy. This step can be thought of as preprocessing and it is essentially free (in terms of complexity) in each of our models. The second phase properly colors each part, using a small number of colors, which is possible because the degeneracy is low. In Section 4, we shall see that the low degeneracy allows this second phase to be efficient in each of the models we consider.

3.1 A Low Degeneracy Partition and its Application

In this phase of our coloring framework, we assign each vertex a color chosen uniformly at random from $[\ell]$, these choices being mutually independent, where $\ell$ is a suitable parameter. For each $i\in[\ell]$, let $G_{i}$ denote the subgraph of $G$ induced by vertices colored $i$. We shall call each $G_{i}$ a block of the vertex partition given by $(G_{1},\ldots,G_{\ell})$. The next theorem, our main technical tool, provides certain guarantees on this partition given a suitable choice of $\ell$.

Theorem 3.1** (LDP Theorem).**

Let $G$ be an $n$-vertex graph with degeneracy $\kappa$. Let $k\in[1,n]$ be a “guess” for the value of $\kappa$ and let $s\geqslant Cn\log n$ be a sparsity parameter, where $C$ is a sufficiently large universal constant. Put

[TABLE]

and let $\psi\colon V(G)\to[\ell]$ be a uniformly random coloring of $G$. For $i\in[\ell]$, let $G_{i}$ be the subgraph induced by $\psi^{-1}(i)$. Then, the partition $(G_{1},\ldots,G_{\ell})$ has the following properties.

1. (i)

If $k\leqslant 2\kappa$, then w.h.p., for each $i$, the degeneracy $\kappa(G_{i})\leqslant(\kappa+\lambda)/\ell$. 2. (ii)

W.h.p., for each $i$, the block size $|V(G_{i})|\leqslant 2n/\ell$. 3. (iii)

If $\kappa\leqslant k\leqslant 2\kappa$, then w.h.p., the number of monochromatic edges $|E(G_{1})\cup\cdots\cup E(G_{\ell})|\leqslant s$.

In each case, “w.h.p.” means “with probability at least $1-1/\operatorname{poly}(n)$.”

It will be convenient to encapsulate the guarantees of this theorem in a definition.

Definition 3.2**.**

Suppose graph $G$ has degeneracy $\kappa$. A vertex partition $(G_{1},\ldots,G_{\ell})$ simultaneously satisfying the degeneracy bound in item (i), the block size bound in item (ii), and the (monochromatic) edge sparsity bound in item (iii) in Theorem 3.1 is called an $(\ell,s,\lambda)$-LDP of $G$.

It will turn out that an $(\ell,s,\lambda)$-LDP leads to a proper coloring of $G$ using at most $\kappa+\lambda+\ell$ colors. An instructive setting of parameters is $s=\Theta((n\log n)/\varepsilon^{2})$, where $\varepsilon$ is either a small constant or a slowly vanishing function of $n$, such as $1/\log n$. Then, a quick calculation shows that when an accurate guess $k\in[\kappa,2\kappa]$ is made, Theorem 3.1 guarantees an LDP that has edge sparsity $s=\widetilde{O}(n)$ and that leads to an eventual proper coloring using $(1+O(\varepsilon))\kappa$ colors. When $\varepsilon=o(1)$, this number of colors is $\kappa+o(\kappa)$.

Recall that the second phase of our coloring framework involves coloring each $G_{i}$ separately, exploiting its low degeneracy. Indeed, given an $(\ell,s,\lambda)$-LDP, each block $G_{i}$ admits a proper $(\kappa(G_{i})+1)$-coloring. Suppose we use a distinct palette for each block; then the total number of colors used is

[TABLE]

as claimed above. Of course, even if our first phase random coloring $\psi$ yields a suitable LDP, we still have to collect each block $G_{i}$ or at least enough information about each block so as to produce a proper $(\kappa(G_{i})+1)$-coloring. How we do this depends on the precise model of computation. We take this up in Section 4.

3.2 Proof of the LDP Theorem

We now turn to proving the LDP Theorem from Section 3.1. Notice that when $k\leqslant(C/2)\log n$, the condition $s\geqslant Cn\log n$ results in $\ell=1$, so the vertex partition is the trivial one-block partition, which obviously satisfies all the properties in the theorem. Thus, in our proof, we may assume that $k>(C/2)\log n$.

Proof of Theorem 3.1.

We start with item (ii), which is the most straightforward. From eq. 1, we have $\ell\leqslant 4nk/s$, so

[TABLE]

Each block size $|V(G_{i})|$ has binomial distribution $\operatorname{Bin}(n,1/\ell)$, so a Chernoff bound gives

[TABLE]

for sufficiently large $C$. By a union bound over the at most $n$ blocks, item (ii) fails with probability at most $1/n$.

Items (i) and (iii) include the condition $k\leqslant 2\kappa$, which we shall assume for the rest of the proof. By eq. 1 and the bounds $s\geqslant Cn\log n$ and $k>(C/2)\log n$,

[TABLE]

whence, for sufficiently large $C$,

[TABLE]

We now turn to establishing item (i). Let $\mathrel{\lhd}$ be a degeneracy ordering for $G$. For each $i\in[\ell]$, let $\mathrel{\lhd}_{i}$ be the restriction of $\mathrel{\lhd}$ to $V(G_{i})$. Consider a particular vertex $v\in V(G)$ and let $j=\psi(v)$ be its color. We shall prove that, w.h.p., $\operatorname{odeg}_{G,\mathrel{\lhd}_{j}}(v)\leqslant(\kappa+\lambda)/\ell$.

By the “only if” direction of Lemma 2.5, we have $\operatorname{odeg}_{G,\mathrel{\lhd}}(v)=|N_{G,\mathrel{\lhd}}(v)|\leqslant\kappa$. Now note that

[TABLE]

is a sum of mutually independent indicator random variables, each of which has expectation $1/\ell$. Therefore, $\mathbb{E}\operatorname{odeg}_{G_{j},\mathrel{\lhd}_{j}}(v)=\operatorname{odeg}_{G,\mathrel{\lhd}}(v)/\ell\leqslant\kappa/\ell$. Since $\lambda\leqslant\kappa$ by eq. 3, we may use the form of the Chernoff bound in 2.7, which gives us

[TABLE]

where the equality follows from eq. 1. In words, with probability at least $1-1/n^{3}$, the vertex $v$ has ordered degree at most $(\kappa+\lambda)/\ell$ within its own block. By a union bound, with probability at least $1-1/n^{2}$, all $n$ vertices of $G$ satisfy this property. When this happens, by the “if” direction of Lemma 2.5, it follows that $\kappa(G_{i})\leqslant(\kappa+\lambda)/\ell$ for every $i$.

Finally, we take up item (iii), which is now straightforward. Assume that the high probability event in item (i) occurs. Then, by 2.1,

[TABLE]

where the final inequality uses the condition $\kappa\leqslant k$ and eq. 1. ∎

4 Specific Sublinear Algorithms for Coloring

We now turn to designing graph coloring algorithms in specific models of computation for big data, where the focus is on utilizing space sublinear in the size of the massive input graph. Such models are sometimes termed space-conscious. In each case, our algorithm ultimately relies on the framework developed in Section 3.

4.1 Data Streaming

We begin with the most intensely studied space-conscious model: the data streaming model. For graph problems, in the basic model, the input is a stream of non-repeated edges that define the input graph $G$: this is called the insertion-only model, since it can be thought of as building up $G$ through a sequence of edge insertions. In the more general dynamic graph model or turnstile model, the stream is a sequence of edge updates, each update being either an insertion or a deletion: the net effect is to build up $G$. Our algorithm will work in this more general model. Later, we shall give a corresponding lower bound that will hold even in the insertion-only model (for a lower bound, this is a strength).

We assume that the vertex set $V(G)=[n]$ and the input is a stream $\sigma$ of at most $m=\operatorname{poly}(n)$ updates to an initially empty graph. An update is a triple $(u,v,c)$, where $u,v\in V(G)$ and $c\in\{-1,1\}$: when $c=1$, this token represents an insertion of edge $\{u,v\}$ and when $c=-1$, it represents a deletion. Let $N=\binom{n}{2}$ and $[[m]]=\mathbb{Z}\cap[-m,m]$. It is convenient to imagine a vector $\mathbf{x}\in[[m]]^{N}$ of edge multiplicities that starts at zero and is updated entrywise with each token. The input graph $G$ described by the stream will be the underlying simple graph, i.e., $E(G)$ will be the set of all edges $\{u,v\}$ such that $x_{u,v}\neq 0$ at the end. We shall say that $\sigma$ builds up $\mathbf{x}$ and $G$.

Our algorithm makes use of two data streaming primitives, each a linear sketch. (We can do away with these sketches in the insertion-only setting; see the end of this section.) The first is a sketch for sparse recovery given by a matrix $A$ (say): given a vector $\mathbf{x}\in[[m]]^{N}$ with sparsity $\|\mathbf{x}\|_{0}\leqslant t$, there is an efficient algorithm to reconstruct $\mathbf{x}$ from $A\mathbf{x}$. The second is a sketch for $\ell_{0}$* estimation* given by a random matrix $B$ (say): given a vector $\mathbf{x}\in[[m]]^{N}$, there is an efficient algorithm that takes $B\mathbf{x}$ and computes from it an estimate of $\|\mathbf{x}\|_{0}$ that, with probability at least $1-\delta$, is a $(1+\gamma)$-multiplicative approximation. It is known that there exists a suitable $A\in\{0,1\}^{d\times N}$, where $d=O(t\log(N/t))$, where $A$ has column sparsity $O(\log(N/t))$; see, e.g., Theorem 9 of Gilbert and Indyk [GI10]. It is also known that there exists a suitable distribution over matrices giving $B\in\{0,1\}^{d^{\prime}\times N}$ with $d^{\prime}=O(\gamma^{-2}\log\delta^{-1}\log N(\log\gamma^{-1}+\log\log m))$. Further, given an update to the $i$th entry of $\mathbf{x}$, the resulting updates in $A\mathbf{x}$ and $B\mathbf{x}$ can be effected quickly by generating the required portion of the $i$th columns of $A$ and $B$.

In our description of Algorithm 1, we use $A_{u,v}$ (resp. $B_{u,v}$) to denote the column of $A$ (resp. $B$) indexed by $\{u,v\}$. The algorithm’s logic results in sketches $\mathbf{y}=A\mathbf{w}$ and $\mathbf{z}=B\mathbf{w}$, where $\mathbf{w}$ corresponds to the subgraph of $G$ consisting of $\psi$-monochromatic edges only (cf. Theorem 3.1), i.e., $\mathbf{w}$ is obtained from $\mathbf{x}$ by zeroing out all entries except those indexed by $\{u,v\}$ with $\psi(u)=\psi(v)$. We choose the parameter $t=2s$, where $s\geqslant Cn\log n$ is the sparsity parameter from Theorem 3.1, which gives $d=O(s\log n)$; we choose $\gamma=1/4$ and $\delta=1/n$, giving $d^{\prime}=O(\log^{3}n)$.

Notice that Algorithm 1 requires a guess for $\kappa:=\kappa(G)$, which is not known in advance. Our final one-pass algorithm runs $O(\log n)$ parallel instances of $\textsc{Color}(\sigma,k)$, using geometrically spaced guesses $k=2,4,8\ldots\,$. It outputs the coloring produced by the non-aborting run that uses the smallest guess.

Theorem 4.1**.**

Set $s=\lceil{\varepsilon^{-2}n\log n}\rceil$, where $\varepsilon>0$ is a parameter. The above one-pass algorithm processes a dynamic (i.e., turnstile) graph stream using $O(\varepsilon^{-2}n\log^{4}n)$ bits of space and, with high probability, produces a proper coloring using at most $(1+O(\varepsilon))\kappa$ colors. In particular, taking $\varepsilon=1/\log n$, it produces a $\kappa+o(\kappa)$ coloring using $\widetilde{O}(n)$ space. Each edge update is processed in $\widetilde{O}(1)$ time and post-processing at the end of the stream takes $\widetilde{O}(n)$ time.

Proof.

The coloring produced is obviously proper. Let us bound the number of colors used. One of the parallel runs of $\textsc{Color}(\sigma,k)$ in 1 will use a value $k=k^{\star}\in(\kappa,2\kappa]$. We shall prove that, w.h.p., (a) every non-aborting run with $k\leqslant k^{\star}$ will use at most $(1+O(\varepsilon))\kappa$ colors, and (b) the run with $k=k^{\star}$ will not abort.

We start with (a). Consider a particular run using $k\leqslant k^{\star}$. By item (i) of Theorem 3.1, each $G_{i}$ has degeneracy at most $(\kappa+\lambda)/\ell$; so if $\mathbf{w}$ is correctly recovered by the sparse recovery sketch (i.e., $\mathbf{w}^{\prime}=\mathbf{w}$ in Algorithm 1), then each $G_{i}$ is correctly recovered and the run uses at most $\kappa+\lambda+\ell$ colors, as in eq. 2. Using the values from eq. 1, this number is at most $(1+O(\varepsilon))\kappa$. Now, if the run does not abort, then the estimate of the sparsity $\|\mathbf{w}\|_{0}$ is at most $5s/4$. By the guarantees of the $\ell_{0}$-estimation sketch, the true sparsity is at most $(5/4)(5s/4)<2s=t$, so, w.h.p., $\mathbf{w}$ is indeed $t$-sparse and, by the guarantees of the sparse recovery sketch, $\mathbf{w}^{\prime}=\mathbf{w}$. Taking a union bound over all $O(\log n)$ runs, the bound on the number of colors holds for all required runs simultaneously, w.h.p.

We now take up (b). Note that $\|\mathbf{w}\|_{0}$ is precisely the number of $\psi$-monochromatic edges in $G$. By item (iii) of Theorem 3.1, we have $\|\mathbf{w}_{0}\|\leqslant s$ w.h.p. By the accuracy guarantee of the $\ell_{0}$-estimation sketch, in this run the estimate of $\|\mathbf{w}\|_{0}$ is at most $5s/4$ w.h.p., so the run does not abort.

The space usage of each parallel run is dominated by the computation of $\mathbf{y}$, so it is $O(d\log m)=O(s\log n\log m)=O(\varepsilon^{-2}n\log^{3}n)$, using our setting of $s$ and the assumption $m=\operatorname{poly}(n)$. The claims about the update time and post-processing time follow directly from the properties of a state-of-the-art sparse recovery scheme, e.g., the scheme based on expander matching pursuit given in Theorem 9 of Gilbert and Indyk [GI10]. ∎

Simplification for Insertion-Only Streams.  Algorithm 1 can be simplified considerably if the input stream is insertion-only. We can then initialize each $G_{i}$ to an empty graph and, upon seeing an edge $\{u,v\}$ in the stream, insert it into $G_{i}$ iff $\psi(u)=\psi(v)=i$. We abort if we collect more than $s$ edges; w.h.p., this will not happen, thanks to Theorem 3.1. Finally, we color the collected graphs $G_{i}$ greedily, just as in Algorithm 1. With this simplification, the overall space usage drops to $O(s\log n)=O(\varepsilon^{-2}n\log^{2}n)$ bits.

The reason this does not work for dynamic graph streams is that the number of monochromatic edges could exceed $s$ by an arbitrary amount mid-stream.

4.2 Query Model

We now turn to the general graph query model, a standard model of space-conscious algorithms for big graphs where the input graph is random-accessible but the emphasis is on the examining only a tiny (ideally, sublinear) portion of it; for general background see Chapter 10 of Goldreich’s book [Gol17]. In this model, the algorithm starts out knowing the vertex set $[n]$ of the input graph $G$ and can access $G$ only through the following types of queries.

• •

A pair query $\operatorname{Pair}(\{u,v\})$, where $u,v\in[n]$. The query returns $1$ if $\{u,v\}\in E(G)$ and [math] otherwise. For better readability, we shall write this query as $\operatorname{Pair}(u,v)$.

• •

A neighbor query $\operatorname{Neighbor}(u,j)$, where $u\in[n]$ and $j\in[n-1]$. The query returns $v\in[n]$ where $v$ is the $j$th neighbor of $u$ in some underlying fixed ordering of vertex adjacency lists; if $\deg(v)<j$, so that there does not exist a $j$th neighbor, the query returns $\bot$.

Naturally, when solving a problem in this model, the goal is to do so while minimizing the number of queries.

By adapting the combinatorial machinery from their semi streaming algorithm, Assadi et al. [ACK19] gave an $\widetilde{O}(n^{3/2})$-query algorithm for finding a $(\Delta+1)$-coloring. Our LDP framework gives a considerably simpler algorithm using $\kappa+o(\kappa)$ colors, where $\kappa:=\kappa(G)$. We remark here that $\widetilde{O}(n^{3/2})$ query complexity is essentially optimal, as Assadi et al. [ACK19] proved a matching lower bound for any $(c\cdot\Delta)$-coloring algorithm, for any constant $c>1$.

Theorem 4.2**.**

Given query access to a graph $G$, there is a randomized algorithm that, with high probability, produces a proper coloring of $G$ using $\kappa+o(\kappa)$ colors. The algorithm’s worst-case query complexity, running time, and space usage are all $\widetilde{O}(n^{3/2})$.

Proof.

The algorithm proceeds in two stages. In the first stage, it attempts to extract all edges in $G$ through neighbor queries alone, aborting when “too many” queries have been made. More precisely, it loops over all vertices $v$ and, for each $v$, issues queries $\operatorname{Neighbor}(v,1),\operatorname{Neighbor}(v,2),\ldots$ until a query returns $\bot$. If this stage ends up making $3n^{3/2}$ queries (say) without having processed every vertex, then it aborts and the algorithm moves on to the second stage. By 2.1, if $\kappa\leqslant\sqrt{n}$, then this stage will not abort and the algorithm will have obtained $G$ completely; it can then $(\kappa+1)$-color $G$ (as in Lemma 2.6) and terminate, skipping the second stage.

In the second stage, we know that $\kappa>\sqrt{n}$. The algorithm now uses a random coloring $\psi$ to construct an $(\ell,s,\lambda)$-LDP of $G$ using the “guess” $k=\sqrt{n}$, with $s=\Theta(\varepsilon^{-2}n\log n)$ and $\ell,\lambda$ given by Equation 1. To produce each subgraph $G_{i}$ in the LDP, the algorithm simply makes all possible queries $\operatorname{Pair}(u,v)$ where $\psi(u)=\psi(v)$. W.h.p., the number of queries made is at most

[TABLE]

where the first inequality uses Item (ii) of Theorem 3.1. We can enforce this bound in the worst case by aborting if it is violated.

Clearly, $k\leqslant 2\kappa$, so Item (i) of Theorem 3.1 applies and by the discussion after Definition 3.2, the algorithm uses $(1+O(\varepsilon))\kappa$ colors. Setting $\varepsilon=1/\log n$, this number is at most $\kappa+o(\kappa)$ and the overall number of queries remains $\widetilde{O}(n^{3/2})$, as required. ∎

4.3 MPC and Congested Clique Models

In the Massively Parallel Communication (MPC) model of Beame et al. [BKS17], an input of size $m$ is distributed adversarially among $p$ processors, each of which has $S$ bits of working memory: here, $p$ and $S$ are $o(m)$ and, ideally, $p\approx m/S$. Computation proceeds in synchronous rounds: in each round, a processor carries out some local computation (of arbitrary time complexity) and then communicates with as many of the other processors as desired, provided that each processor sends and receives no more than $S$ bits per round. The primary goal in solving a problem is to minimize the number of rounds.

When the input is an $n$-vertex graph, the most natural and widely studied setting of MPC is $S=\widetilde{O}(n)$, which enables each processor to hold some information about every vertex; this makes many graph problems tractable. Since the input size $m$ is potentially $\Omega(n^{2})$, it is reasonable to allow $p=n$ many processors. Note that the input is just a collection of edges, distributed adversarially among these processors, subject to the memory constraint.

Theorem 4.3**.**

There is a randomized $O(1)$-round MPC algorithm that, given an $n$-vertex graph $G$, outputs a $(\kappa+o(\kappa))$-coloring of $G$ with high probability. The algorithm uses $n$ processors, each with $O(n\log^{2}n)$ bits of memory.

Proof.

Our algorithm will use $n$ processors, each assigned to one vertex. If $|E(G)|=O(n\log n)$, then all of $G$ can be collected at one processor in a single round using $|E(G)|\cdot 2\lceil{\log n}\rceil=O(n\log^{2}n)$ bits of communication and the problem is solved trivially. Therefore, we may as well assume that $|E(G)|=\omega(n\log n)$, which implies $\kappa=\omega(\log n)$, by 2.1. We shall first give an algorithm assuming that $\kappa$ is known a priori. Our final algorithm will be a refinement of this preliminary one.

*Preliminary algorithm. * Take $k=\kappa$. Each processor chooses a random color for its vertex, implicitly producing a partition $(G_{1},\ldots,G_{\ell})$ that is, w.h.p., an ($\ell,s,\lambda)$-LDP; we take $\ell,\lambda$ as in eq. 1, $s=\Theta(\varepsilon^{-2}n\log n)$, and $\varepsilon=(k^{-1}\log n)^{1/4}$. Note that $\varepsilon=o(1)$. In Round 1, each processor sends its chosen color to all others—this is $O(n\log n)$ bits of communication per machine—and as a result every processor learns which of its vertex’s incident edges are monochromatic. Now each color $i\in[\ell]$ is assigned a unique machine $M_{i}$ and, in Round 2, all edges in $G_{i}$ are sent to $M_{i}$. Each $M_{i}$ then locally computes a $(\kappa(G_{i})+1)$-coloring of $G_{i}$ using a palette disjoint from those of other $M_{i}$s; by the discussion following Definition 3.2, this colors $G$ using at most $(1+O(\varepsilon))\kappa=\kappa+o(\kappa)$ colors.

The communication in Round 2 is bounded by $\max_{i}|E(G_{i})|\cdot 2\lceil{\log n}\rceil$. By 2.1, items (i) and (ii) of Theorem 3.1, and eq. 1, the following holds w.h.p. for each $i\in[\ell]$:

[TABLE]

Thus, the communication per processor in Round 2 is $O(n\log^{2}n)$ bits.

*Final algorithm. * When we don’t know $\kappa$ in advance, we can make geometrically spaced guesses $k$, as in Section 4.1. In Round 1, we choose a random coloring for each such $k$. In Round 2, we determine the quantities $|E(G_{i})|$ for each $k$ and each subgraph $G_{i}$ and thereby determine the smallest $k$ such that eq. 4 holds for every $G_{i}$ corresponding to this $k$. We then run Round 3 for only this one $k$, replicating the logic of Round 2 of the preliminary algorithm.

Correctness is immediate. We turn to bounding the communication cost. For Round 3, the previous analysis shows that the communication per processor is $O(n\log^{2}n)$ bits. For Rounds 1 and 2, let us consider the communication involved for each guess $k$: since each randomly-chosen color and each cardinality $|E(G_{i})|$ can be described in $O(\log n)$ bits, each processor sends and receives at most $O(n\log n)$ bits per guess. This is a total of $O(n\log^{2}n)$ bits, as claimed. ∎

The CONGESTED-CLIQUE model [LPPP05] is a well established model of distributed computing for graph problems. In this model, there are $n$ nodes, each of which holds the local neighborhood information (i.e., the incident edges) of one vertex of the input graph $G$. In each round, every pair of nodes may communicate, whether or not they are adjacent in $G$, but the communication is restricted to $O(\log n)$ bits. There is no constraint on a node’s local memory. The goal is to minimize the number of rounds.

Behnezhad et al. [BDH18] built on results of Lenzen [Len13] to show that any algorithm in the semi-MPC model—defined as MPC with space per machine being $O(n\log n)$ bits—can be simulated in the Congested Clique model, preserving the round complexity up to a constant factor. Based on this, we obtain the following result.

Theorem 4.4**.**

There is a randomized $O(1)$-round algorithm in the Congested Clique model that, given a graph $G$, w.h.p. finds a $(\kappa+O(\kappa^{3/4}\log^{1/2}n))$-coloring. For $\kappa=\omega(\log^{2}n)$, this gives a $(\kappa+o(\kappa))$-coloring.∎

Proof.

We cannot directly use our algorithm in Theorem 4.3 because it is not a semi-MPC algorithm: it uses $O(n\log^{2}n)$ bits of space per processor, rather than $O(n\log n)$. However, with a more efficient implementation of Round 1, a more careful analysis of Round 2, and a slight tweak of parameters for Round 3, we can improve the communication (hence, space) bounds to $O(n\log n)$, whereupon the theorem of Behnezhad et al. [BDH18] completes the proof.

For Round 3, the tweak is to set $\varepsilon=(k^{-1}\log^{2}n)^{1/4}$ but otherwise replicate the logic of the final algorithm from Theorem 4.3. With this higher value of $\varepsilon$, the bound from eq. 4 improves to $|E(G_{i})|=O(n)$. Therefore the per-processor communication in Round 3 is only $O(n\log n)$ bits. The number of colors used is, w.h.p., at most $(1+O(\varepsilon))\kappa=\kappa+O(\kappa^{3/4}\log^{1/2}n)$.

For a tighter analysis of the communication cost of Round 2, note that, for a particular guess $k$, there is a corresponding $\ell$ given by eq. 1 such that each processor need only send/receive $\ell$ cardinalities $|E(G_{i})|$, each of which can be described in $O(\log n)$ bits. Consulting eq. 1, we see that $\ell=O(n^{2}/s)=O(n/\log n)$. Therefore, summing over all $O(\log n)$ choices of $k$, each processor communicates at most

[TABLE]

Round 1 appears problematic at first, since there are $O(\log n)$ many random colorings to be chosen, one for each guess $k$. However, note that these colorings need not be independent. Therefore, we can choose just one random $\lceil{\log n}\rceil$-bit “master color” $\phi(v)$ for each vertex $v$ and derive the random colorings for the various guesses $k$ by using only appropriate length prefixes of $\phi(v)$. This ensures that each processor only communicates $O(n\log n)$ bits in Round 1. ∎

4.4 Distributed Coloring in the LOCAL Model

In the LOCAL model, each node of the input graph $G$ hosts a processor that knows only its own neighborhood. The processors operate in synchronous rounds, during which they can send and receive messages of arbitrary length to and from their neighbors. The processors are allowed unbounded local computation in each round. The key complexity measure is time, defined as the number of rounds used by an algorithm (expected number, for a randomized algorithm) on a worst-case input.

Graph coloring in the LOCAL model is very heavily studied and is one of the central problems in distributed algorithms. Here, our focus is on algorithms that properly color the input graph $G$ using a number of colors that depends on $\alpha:=\alpha(G)$, the arboricity of $G$. Recall that $\alpha\leqslant\kappa\leqslant 2\alpha-1$ (2.2). Unlike in previous sections, our results will give big-$O$ bounds on the number of colors, so we may as well state them in terms of $\alpha$ (following established tradition in this line of work) rather than $\kappa$. Our focus will be on algorithms that run in sublogarithmic time, while using not too many colors. See Section 1.2 for a quick summary of other interesting parameter regimes and Barenboim and Elkin [BE13] for a thorough treatment of graph coloring in the LOCAL model.

Kothapalli and Pemmaraju [KP11] gave an $O(k)$-round algorithm that uses $O(\alpha n^{1/k})$ colors, for all $k$ with $2\log\log n\leqslant k\leqslant\sqrt{\log n}$. We give a new coloring algorithm that, in particular, extends the range of $k$ to which such a time/quality tradeoff applies: for k\in\big{[}\omega(\sqrt{\log n}),\,o(\log n)\big{]}, we can compute an $O(\alpha n^{1/k}\log n)$-coloring in $O(k)$ rounds.

Our algorithm uses our LDP framework to split the input graph into parts with logarithmic degeneracy (hence, arboricity) and then invokes an algorithm of Barenboim and Elkin. The following theorem records the key properties of their algorithm.

Lemma 4.5** (Thm 5.6 of Barenboim and Elkin [BE10]).**

There is a deterministic distributed algorithm in the LOCAL model that, given an $n$-vertex graph $G$, an upper bound $b$ on $\alpha(G)$, and a parameter $t$ with $2<t\leqslant O(\sqrt{{n}/b})$, produces an $O(tb^{2})$-coloring of $G$ in time $O\left({\log_{t}n}+\log^{\star}n\right)$. ∎

Here is the main result of this section.

Theorem 4.6**.**

There is a randomized distributed algorithm in the LOCAL model that, given an $n$-vertex graph $G$, an estimate of its arboricity $\alpha$ up to a constant factor, and a parameter $t$ such that $2<t\leqslant O(\sqrt{n/\log n})$, produces an $O(t\alpha\log n)$-coloring of $G$ in time $O\left({\log_{t}n}+\log^{\star}n\right)$.

Proof.

To simplify the presentation, we assume that $\alpha=\alpha(G)$. We assume that every node (vertex) knows $n$ and $\alpha$. Consider a $(\ell,s,\lambda)$-LDP of $G$, where we put $s=Cn\log n$, for some large constant $C$, as in Theorem 3.1. This setting of $s$ gives $\ell=O(\alpha/\log n)$. First, each vertex $v$ chooses a color $\psi(v)$ uniformly at random from $[\ell]$. Next, we need to effectively “construct” the blocks $G_{i}$, for each $i\in[\ell]$. This is straightforwardly done in a single round: each vertex $v$ sends $\psi(v)$ to all its neighbors.

At this point, each vertex $v$ knows its neighbors in the block $G_{\psi(v)}$. So it’s now possible to run a distributed algorithm on each $G_{i}$. We invoke the algorithm in Lemma 4.5. The algorithm needs each vertex $v$ to know an upper bound $b_{i}$ on $\alpha(G_{i})$, where $i=\psi(v)$. A useful upper bound of $b_{i}=O(\log n)$, which holds w.h.p., is given by item (i) of Theorem 3.1.

By Lemma 4.5, each $G_{i}$ can be colored using $O(t\log^{2}n)$ colors, within another $O\left({\log_{t}n}+\log^{\star}n\right)$ rounds, since $2<t\leqslant O(\sqrt{n/\log n})$. Using disjoint palettes for the distinct blocks, the total number of colors used for $G$ is at most $\ell\cdot O(t\log^{2}n)=O(t\alpha\log n)$, as required. ∎

The particular form of the tradeoff stated in Table 1 is obtained by setting $t=n^{1/k}$ (for some $k\geqslant 3$) in the above theorem.

Corollary 4.7**.**

There is a randomized LOCAL algorithm that, given graph $G$, estimate $\alpha\approx\alpha(G)$, and a parameter $k$ with $2<n^{1/k}\leqslant O(\sqrt{n/\log n})$, finds an $O(\alpha n^{1/k}\log n)$-coloring of $G$ in time $O\left(k+\log^{\star}n\right)$. ∎

5 Lower Bounds

Can we improve the guarantees of our algorithms so that they use at most $\kappa+1$ colors, rather than $\kappa+o(\kappa)$? After all, every graph $G$ does have a proper $(\kappa(G)+1)$-coloring. The main message of this section is that answer is a strong “No,” at least in the data streaming and query models. If we insist on a coloring that good, we would incur the worst possible space or query complexity: $\Omega(n^{2})$. In fact, this holds even if $\kappa$ is known to the algorithm in advance. Moreover, all our streaming lower bounds hold even if the input stream consists of edge insertions alone.

Our lower bounds generalize to the problem of producing a $(\kappa+\lambda)$-coloring. We show that this requires $\Omega(n^{2}/\lambda^{2})$ space or query complexity. Such generalizations are based on the following Blow-Up Lemma.

Definition 5.1**.**

Let $G$ be a graph and $\lambda$ a positive integer. The blow-up graph $G^{\lambda}$ is obtained by replacing each vertex of $G$ with a copy of the complete graph $K_{\lambda}$ and replacing each edge of $G$ with a complete bipartite graph between the copies of $K_{\lambda}$ at its endpoints. More succinctly, $G^{\lambda}$ is the lexicographical product $G[K_{\lambda}]$.

Lemma 5.2** (Blow-Up Lemma).**

For all graphs $G$ and positive integers $\lambda,c$, if $G$ has a $c$-clique, then $G^{\lambda}$ has a $(c\lambda)$-clique. Also, $\kappa(G^{\lambda})\leqslant(\kappa(G)+1)\lambda-1$.

Proof.

The claim about cliques is immediate. The bound on $\kappa(G^{\lambda})$ follows by taking a degeneracy ordering of $G$ and replacing each vertex $v$ by a list of vertices of the clique that replaces $v$ in $G^{\lambda}$, ordering vertices within the clique arbitrarily. ∎

Our lower bounds come in two flavors. The first address the hardness of distinguishing low-degeneracy graphs from high-chromatic-number graphs. This is encapsulated in the following abstract problem.

Definition 5.3** (graph-dist problem).**

Consider two graph families: $\mathcal{G}_{1}:=\mathcal{G}_{1}(n,q,\lambda)$, consisting of $n$-vertex graphs with chromatic number $\chi\geqslant(q+1)\lambda$, and $\mathcal{G}_{2}:=\mathcal{G}_{2}(n,q,\lambda)$, consisting of $n$-vertex graphs with $\kappa\leqslant q\lambda-1$. Then $\textsc{graph-dist}(n,q,\lambda)$ is the problem of distinguishing $\mathcal{G}_{1}$ from $\mathcal{G}_{2}$; note that $\mathcal{G}_{1}\cap\mathcal{G}_{2}=\varnothing$. More precisely, given an input graph $G$ on $n$ vertices, the problem is to decide whether $G\in\mathcal{G}_{1}$ or $G\in\mathcal{G}_{2}$, with success probability at least $2/3$.

We shall prove that graph-dist is “hard” in the insertion-only streaming setting and in the query setting, thereby establishing that in these models it is hard to produce a $(\kappa+\lambda)$-coloring. In fact, our proofs will show that it is just as hard to estimate the parameter $\kappa$; this goes to show that the hardness of the coloring problem is not just because of the large output size.

Lower bounds of the above flavor raise the following question: since estimating $\kappa$ itself is hard, does the coloring problem become easier if the value of $\kappa(G)$ is given in advance, before the algorithm starts to read $G$? In fact, the $(\Delta+1)$-coloring algorithms by Assadi et al. [ACK19] assume that $\Delta$ is known in advance. However, perhaps surprisingly, we prove a second flavor of lower bounds, showing that a priori knowledge of $\kappa$ does not help and $(\kappa+1)$-coloring (more generally, $(\kappa+\lambda)$-coloring) remains a hard problem even under the strong assumption that $\kappa$ is known in advance.

5.1 Streaming Lower Bounds

In this section, we prove both flavors of lower bounds in the one-pass streaming setting. The next section takes up the query model.

Our streaming lower bounds use reductions from the index and int-find (intersection finding, a variant of disjointness) problems in communication complexity. In the $\textsc{index}_{N}$ problem, Alice is given a vector $\mathbf{x}=(x_{1},\ldots,x_{N})\in\{0,1\}^{N}$ and Bob is given an index $k\in[N]$. The goal is for Alice to send Bob a (possibly random) $c$-bit message that enables Bob to output $x_{k}$ with probability at least $2/3$. The smallest $c$ for which such a protocol exists is called the one-way randomized communication complexity, $\operatorname{R}^{\to}(\textsc{index}_{N})$. In $\textsc{int-find}_{N}$, Alice and Bob hold vectors $\mathbf{x},\mathbf{y}\in\{0,1\}^{N}$, interpreted as subsets of $[N]$, satisfying the promise that $|\mathbf{x}\cap\mathbf{y}|=1$. They must find the unique index $i$ where $x_{i}=y_{i}=1$, using at most $c$ bits of randomized interactive communication, succeeding with probability at least $2/3$. The smallest $c$ for which such a protocol exists is the randomized communication complexity, $\operatorname{R}(\textsc{int-find}_{N})$. As is well known, $\operatorname{R}^{\to}(\textsc{index}_{N})=\Omega(N)$ [Abl96] and $\operatorname{R}(\textsc{int-find}_{N})=\Omega(N)$; the latter is a simple extension of the disjointness lower bound [Raz92].

We shall in fact consider instances of $\textsc{index}_{N}$ where $N=p^{2}$, for an integer $p$. Using a canonical bijection between $[N]$ and $[p]\times[p]$, we reinterpret $\mathbf{x}$ as a matrix with entries $(x_{ij})_{i,j\in[p]}$, and Bob’s input as $(y,z)\in[p]\times[p]$. We further interpret this matrix $\mathbf{x}$ as the bipartite adjacency matrix of a $(2p)$-vertex balanced bipartite graph $H_{\mathbf{x}}$. Such graphs $H_{\mathbf{x}}$ will be key gadgets in the reductions to follow.

Definition 5.4**.**

For $\mathbf{x}\in\{0,1\}^{p\times p}$, a realization of $H_{\mathbf{x}}$ on a list $(\ell_{1},\ldots,\ell_{p},r_{1},\ldots,r_{p})$ of distinct vertices is a graph on these vertices whose edge set is $\{\{\ell_{i},r_{j}\}:\,x_{ij}=1\}$.

First Flavor: Degeneracy Not Known in Advance.  To prove lower bounds of the first flavor, we start by demonstrating the hardness of the abstract problem graph-dist, from Definition 5.3.

Lemma 5.5**.**

Solving $\textsc{graph-dist}(n,q,\lambda)$ in one randomized streaming pass requires $\Omega(n^{2}/\lambda^{2})$ space.

*More precisely, there is a constant $c>0$ such that for every integer $\lambda\geqslant 1$ and every sufficiently large integer $q$, there is a setting $n=n(q,\lambda)$ for which every randomized one-pass streaming algorithm for $\textsc{graph-dist}(n,q,\lambda)$ requires at least $cn^{2}/\lambda^{2}$ bits of space. *

Proof.

Put $p=q-1$. We reduce from $\textsc{index}_{N}$, where $N=p^{2}$, using the following plan. Starting with an empty graph on $n=3\lambda p$ vertices, Alice adds certain edges based on her input $\mathbf{x}\in\{0,1\}^{p\times p}$ and then Bob adds certain other edges based on his input $(y,z)\in[p]\times[p]$. By design, solving $\textsc{graph-dist}(n,q,\lambda)$ on the resulting final graph reveals the bit $x_{yz}$, implying that a one-pass streaming algorithm for graph-dist requires at least $\operatorname{R}^{\to}(\textsc{index}_{N})=\Omega(N)=\Omega(p^{2})=\Omega(n^{2}/\lambda^{2})$ bits of memory. The details follow.

We first consider $\lambda=1$. We use the vertex set $L\uplus R\uplus C$ (the notation “$\uplus$” denotes a disjoint union), where $L=\{\ell_{1},\ldots,\ell_{p}\}$, $R=\{r_{1},\ldots,r_{p}\}$, and $|C|=p$. Alice introduces the edges of the gadget graph $H_{\mathbf{x}}$ (from Definition 5.4), realized on the vertices $(\ell_{1},\ldots,\ell_{p},r_{1},\ldots,r_{p})$. Bob introduces all possible edges within $C\cup\{\ell_{y},r_{z}\}$, except for $\{\ell_{y},r_{z}\}$. Let $G$ be the resulting graph.

If $x_{yz}=1$, then $G$ contains a clique on $C\cup\{\ell_{y},r_{z}\}$, whence $\chi(G)\geqslant p+2$. If, on the other hand, $x_{yz}=0$, then we claim that $\kappa(G)\leqslant p$. By Lemma 2.5, the claim will follow if we exhibit a vertex ordering $\mathrel{\lhd}$ such that $\operatorname{odeg}_{G,\mathrel{\lhd}}(v)\leqslant p$ for all $v\in V(G)$. We use an ordering where

[TABLE]

and the ordering within each set is arbitrary. By construction of $H_{\mathbf{x}}$, each vertex in $L\cup R\setminus\{\ell_{y},r_{z}\}$ has total degree at most $p$. For each vertex $v\in\{r_{z}\}\cup C$, we trivially have $\operatorname{odeg}_{G,\mathrel{\lhd}}(v)\leqslant p$ because $|C|=p$. Finally, since $x_{yz}=0$, the vertex $r_{z}$ is not a neighbor of $\ell_{y}$; so $\operatorname{odeg}_{G,\mathrel{\lhd}}(\ell_{y})=|C|=p$. This proves the claim.

When $\lambda\geqslant 1$, Alice and Bob introduce edges so as to create the blow-up graph $G^{\lambda}$, as in Definition 5.1. By Lemma 5.2, if $x_{yz}=1$, then $G^{\lambda}$ has a $(p+2)\lambda$-clique, whereas if $x_{yz}=0$, then $\kappa(G^{\lambda})\leqslant(p+1)\lambda-1$. In the former case, $\chi(G^{\lambda})\geqslant(p+2)\lambda=(q+1)\lambda$, so that $G^{\lambda}\in\mathcal{G}_{1}(n,q,\lambda)$; cf. Definition 5.3. In the latter case, $\kappa(G^{\lambda})\leqslant q\lambda-1$, so that $G^{\lambda}\in\mathcal{G}_{2}(n,q,\lambda)$. Thus, solving $\textsc{graph-dist}(n,q,\lambda)$ on $G^{\lambda}$ reveals $x_{yz}$. ∎

Our coloring lower bounds are straightforward consequences of the above lemma.

Theorem 5.6**.**

Given a single randomized pass over a stream of edges of an $n$-vertex graph $G$, succeeding with probability at least $2/3$ at either of the following tasks requires $\Omega(n^{2}/\lambda^{2})$ space, where $\lambda\geqslant 1$ is an integer parameter:

1. (i)

produce a proper $(\kappa+\lambda)$-coloring of $G$; 2. (ii)

produce an estimate $\hat{\kappa}$ such that $|\hat{\kappa}-\kappa|\leqslant\lambda$.

Furthermore, if we require \lambda=O\bigl{(}\kappa^{\frac{1}{2}-\gamma}\bigr{)}, where $\gamma>0$, then neither task admits a semi-streaming algorithm.

Proof.

An algorithm for either task (i) and or task (ii) immediately solves graph-dist with appropriate parameters, implying the $\Omega(n^{2}/\lambda^{2})$ bounds, thanks to Lemma 5.5. For the “furthermore” statement, note that the graphs in the family $\mathcal{G}_{2}$ constructed in the proof of Lemma 5.5 have $\kappa=\Theta(n)$, so performing either task with the stated guarantee on $\lambda$ would require $\Omega(n^{1+2\gamma})$ space, which is not in $\widetilde{O}(n)$. ∎

Combining the above result with the algorithmic result in Theorem 4.1, we see that producing a $(\kappa+o(\kappa))$-coloring is possible in semi-streaming space whereas producing a (\kappa+O\bigl{(}\kappa^{\frac{1}{2}-\gamma}\bigr{)})-coloring is not. We leave open the question of whether this gap can be tightened.

Second Flavor: Degeneracy Known in Advance.  We now show that the coloring problem remains just as hard even if the algorithm knows the degeneracy of the graph before seeing the edge stream.

Theorem 5.7**.**

Given as input an integer $\kappa$, followed by a stream of edges of an $n$-vertex graph $G$ with degeneracy $\kappa$, a randomized one-pass algorithm that produces a proper $(\kappa+\lambda)$-coloring of $G$ requires $\Omega(n^{2}/\lambda^{2})$ bits of space. Furthermore, if we require \lambda=O\bigl{(}\kappa^{\frac{1}{2}-\gamma}\bigr{)}, where $\gamma>0$, then the task does not admit a semi-streaming algorithm.

Proof.

We reduce from $\textsc{index}_{N}$, where $N=p^{2}$, using a plan analogous to the one used in proving Lemma 5.5. Alice and Bob will construct a graph on $n=5\lambda p$ vertices, using their respective inputs $\mathbf{x}\in\{0,1\}^{p\times p}$ and $(y,z)\in[p]\times[p]$.

First, we consider the case $\lambda=1$. We use the vertex set $L\uplus R\uplus\overline{L}\uplus\overline{R}\uplus C$, where $L=\{\ell_{1},\ldots\ell_{p}\}$, $R=\{r_{1},\ldots,r_{p}\}$, $\overline{L}=\{\overline{\ell}_{1},\ldots,\overline{\ell}_{p}\}$, $\overline{R}=\{\overline{r}_{1},\ldots,\overline{r}_{p}\}$, and $|C|=p$. Let $\overline{\mathbf{x}}$ be the bitwise complement of $\mathbf{x}$. Alice introduces the edges of the gadget graph $H_{\mathbf{x}}$ (from Definition 5.4), realized on $L\cup R$, and the edges of $H_{\overline{\mathbf{x}}}$ realized on $\overline{L}\cup\overline{R}$. For ease of notation, put $\ell:=\ell_{y}$, $r:=r_{z}$, $\overline{\ell}:=\overline{\ell}_{y}$, $\overline{r}:=\overline{r}_{z}$, and $S:=C\cup\{\ell,r,\overline{\ell},\overline{r}\}$. Bob introduces all possible edges within $S$, except for $\{\ell,r\}$ and $\{\overline{\ell},\overline{r}\}$. Let $G$ be the resulting graph.

We claim that the degeneracy $\kappa(G)=p+2$. To prove this, we consider the case $x_{yz}=1$ (the other case, $x_{yz}=0$, is symmetric). By construction, $G$ contains a clique on the $p+3$ vertices in $C\cup\{\ell,r,\overline{\ell}\}$; therefore, by definition of degeneracy, $\kappa(G)\geqslant p+2$. To show that $\kappa(G)\leqslant p+2$, it will suffice to exhibit a vertex ordering $\mathrel{\lhd}$ such that $\operatorname{odeg}_{G,\mathrel{\lhd}}(v)\leqslant p+2$ for all $v\in V(G)$. To this end, consider an ordering where

[TABLE]

and the ordering within each set is arbitrary. Each vertex $v\in V(G)\setminus S$ has $\operatorname{odeg}_{G,\mathrel{\lhd}}(v)\leqslant\deg(v)\leqslant p$ and each vertex $v\in S\setminus\{\overline{\ell}\}$ has \operatorname{odeg}_{G,\mathrel{\lhd}}(v)\leqslant\big{|}S\setminus\{\overline{\ell}\}\big{|}-1=p+2. As for the vertex $\overline{\ell}$, since $\overline{x}_{yz}=1-x_{yz}=0$, by the construction in Definition 5.4, $\overline{r}$ is not a neighbor of $\overline{\ell}$; therefore, \operatorname{odeg}_{G,\mathrel{\lhd}}(\overline{\ell})\leqslant\big{|}S\setminus\{\overline{\ell},\overline{r}\}\big{|}=p+2.

Let $\mathcal{A}$ be a streaming algorithm that behaves as in the theorem statement. Recall that we are considering $\lambda=1$. Since $\kappa(G)=p+2$ for every instance of $\textsc{index}_{N}$, Alice and Bob can simulate $\mathcal{A}$ on their constructed graph $G$ by first feeding it the number $p+2$, then Alice’s edges, and then Bob’s. When $\mathcal{A}$ succeeds, the coloring it outputs is a proper $(p+3)$-coloring; therefore it must repeat a color inside $S$, as $|S|=p+4$. But $S$ has exactly one pair of non-adjacent vertices: the pair $\{\ell,r\}$ if $x_{yz}=0$, and the pair $\{\overline{\ell},\overline{r}\}$ if $x_{yz}=1$. Thus, an examination of which two vertices in $S$ receive the same color reveals $x_{yz}$, solving the $\textsc{index}_{N}$ instance. It follows that $\mathcal{A}$ must use at least $\operatorname{R}^{\to}(\textsc{index}_{N})=\Omega(N)=\Omega(p^{2})$ bits of space.

Now consider an arbitrary $\lambda$. Alice and Bob proceed as above, except that they simulate $\mathcal{A}$ on the blow-up graph $G^{\lambda}$. Since $G$ always has a $(p+3)$-clique and $\kappa(G)=p+2$, the two halves of Lemma 5.2 together imply $\kappa(G^{\lambda})=(p+3)\lambda-1$. So, when $\mathcal{A}$ succeeds, it properly colors $G^{\lambda}$ using at most $(p+4)\lambda-1$ colors. For each $A\subseteq V(G)$, abusing notation, let $A^{\lambda}$ denote its corresponding set of vertices in $G^{\lambda}$ (cf. Definition 5.1). Since $|S^{\lambda}|=(p+4)\lambda$, there must be a color repetition within $S^{\lambda}$. Reasoning as above, this repetition must occur within $\{\ell,r\}^{\lambda}$ when $x_{yz}=0$ and within $\{\overline{\ell},\overline{r}\}^{\lambda}$ when $x_{yz}=1$. Therefore, Bob can examine the coloring to solve $\textsc{index}_{N}$, showing that $\mathcal{A}$ must use $\Omega(N)=\Omega(p^{2})=\Omega(n^{2}/\lambda^{2})$ space.

The “furthermore” part follows by observing that \kappa(G^{\lambda})=\Theta\bigl{(}|V(G^{\lambda})|\bigr{)}. ∎

Multiple Passes.  The streaming algorithm from Section 4.1 is one-pass, as are the lower bounds proved above. Is the coloring problem any easier if we are allowed multiple passes over the edge stream? We now give a simple argument showing that, if we slightly generalize the problem, it stays just as hard using multiple ($O(1)$ many) passes.

The generalization is to allow some edges to be repeated in the stream. In other words, the input is a multigraph $\hat{G}$. Clearly, a coloring is proper for $\hat{G}$ iff it is proper for the underlying simple graph $G$, so the relevant algorithmic problem is to properly $(\kappa+\lambda)$-color $G$, where $\kappa:=\kappa(G)$. Note that our algorithm in Section 4.1 does, in fact, solve this more general problem.

Theorem 5.8**.**

Given as input an integer $\kappa$, followed by a stream of edges of an $n$-vertex multigraph $\hat{G}$ whose underlying simple graph has degeneracy $\kappa$, a randomized $p$-pass algorithm that produces a proper $(\kappa+\lambda)$-coloring of $G$ requires $\Omega(n^{2}/(\lambda^{2}p))$ bits of space. This holds even if the stream is insertion-only, with each edge appearing at most twice.

Proof.

As usual, we prove this for $\lambda=1$ and appeal to the Blow-Up Lemma (Lemma 5.2) to generalize.

We reduce from $\textsc{int-find}_{N}$, with $N=\binom{n}{2}$. Let Alice and Bob treat their inputs as $(x_{ij})_{1\leqslant i<j\leqslant n}$ and $(y_{ij})_{1\leqslant i<j\leqslant n}$ in some canonical way. Alice (resp. Bob) converts their input into an edge stream consisting of pairs $(i,j)$ such that $i<j$ and $x_{ij}=0$ (resp. $y_{ij}=0$). The concatenation of these streams defines the multigraph $\hat{G}$ given to the coloring algorithm. Let $(h,k)$ be the unique pair such that $x_{hk}=y_{hk}=1$. Note that the underlying simple graph $G$ is $K_{n}$ minus the edge $\{h,k\}$. Therefore, $\kappa=n-2$ and so, in a proper $(n-1)$-coloring of $\hat{G}$, there must be a repeated color and this can only happen at vertices $h$ and $k$.

Thus, a $p$-pass $(\kappa+1)$-coloring algorithm using $s$ bits of space leads to a protocol for $\textsc{int-find}_{N}$ using $(2p-1)s$ bits of communication. Therefore, $s=\Omega(N/p)=\Omega(n^{2}/p)$. ∎

5.2 Query Complexity Lower Bounds

We now turn to the general graph query model [Gol17]. Recall that our algorithm from Section 4.2 produces a $(\kappa+o(\kappa))$-coloring while making at most $\widetilde{O}(n^{3/2})$ queries, without needing to know $\kappa$ in advance. Here, we shall prove that the number of colors cannot be improved to $\kappa+1$: that would preclude sublinear complexity. In fact, we prove more general results, similar in spirit to the streaming lower bounds from the previous section. For these lower bounds, we use another family of gadget graphs.

Definition 5.9**.**

Given a large integer $p$ (a size parameter), the gadgets for that size are $(2p+1)$-vertex graphs on vertex set $A\uplus B$, where $A=\{a_{1},\ldots,a_{p+1}\}$ and $B=\{b_{1},\ldots,b_{p}\}$. Let $H$ be the graph consisting of a clique on $A$ and a clique on $B$, with no edges between $A$ and $B$. For $1\leqslant i<j\leqslant p$, let $H_{ij}$ be a graph on the same vertex set obtained by slightly modifying $H$ as follows (see Figure 1(c)):

[TABLE]

Notice that the vertex $a_{p+1}$ is not touched by any of these modifications. The relevant properties of these gadget graphs are as follows.

Lemma 5.10**.**

For all $1\leqslant i<j\leqslant p$, $\kappa(H_{ij})=p-1$, whereas the chromatic number $\chi(H)=p+1$.

Proof.

The claim about $\chi(H)$ is immediate.

Consider a particular graph $H_{ij}$. The subgraph induced by $A\setminus\{a_{i}\}$ is a $p$-clique, so $\kappa(H_{ij})\geqslant p-1$.

Now consider the following ordering $\mathrel{\lhd}$ for $H_{ij}$: $B\mathrel{\lhd}a_{i}\mathrel{\lhd}A\setminus\{a_{i}\}$, where the order within each set is arbitrary. For each $v\in B$, $\operatorname{odeg}_{H_{ij},\mathrel{\lhd}}(v)\leqslant\deg(v)=p-1$. For each $v\in A\setminus\{a_{i}\}$, $\operatorname{odeg}_{H_{ij},\mathrel{\lhd}}(v)\leqslant|A\setminus\{a_{i}\}|-1=p-1$. Finally, $a_{i}$ has exactly $p-1$ neighbors in $A\setminus\{a_{i}\}$ (by construction, $a_{j}$ is not a neighbor), so $\operatorname{odeg}_{H_{ij},\mathrel{\lhd}}(a_{i})=p-1$. By Lemma 2.5, it follows that $\kappa(H_{ij})\leqslant p-1$. ∎

Our proofs will use these gadget graphs in reductions from a pair of basic problems in decision tree complexity. Consider inputs that are vectors in $\{0,1\}^{N}$: let $\mathbf{0}$ denote the all-zero vector and, for $i\in[N]$, let $\mathbf{e}_{i}$ denote the vector whose $i$th entry is $1$ while all other entries are [math]. Let $\textsc{unique-or}_{N}$ and $\textsc{unique-find}_{N}$ denote the following partial functions on $\{0,1\}^{N}$:

[TABLE]

Informally, these problems capture, respectively, the tasks of (a) determining whether there is a needle in a haystack under the promise that there is at most one needle, and (b) finding a needle in a haystack under the promise that there is exactly one needle. Intuitively, solving either of these problems with high accuracy should require searching almost the entire haystack. Formally, let $\operatorname{R}^{\mathrm{dt}}_{\delta}(f)$ denote the $\delta$-error randomized query complexity (a.k.a. decision tree complexity) of $f$. Elementary considerations of decision tree complexity lead to the bounds below (for a thorough discussion, including formal definitions, we refer the reader to the survey by Buhrman and de Wolf [BdW02]).

Fact 5.11**.**

For all $\delta\in(0,\frac{1}{2})$, we have $\operatorname{R}^{\mathrm{dt}}_{\delta}(\textsc{unique-or}_{N})\geqslant(1-2\delta)N$ and $\operatorname{R}^{\mathrm{dt}}_{\delta}(\textsc{unique-find}_{N})\geqslant(1-\delta)N-1$. ∎

With this setup, we turn to lower bounds of the first flavor.

Lemma 5.12**.**

Solving $\textsc{graph-dist}(n,p,\lambda)$ in the general graph query model requires $\Omega(n^{2}/\lambda^{2})$ queries.

More precisely, there is a constant $c>0$ such that for every integer $\lambda\geqslant 1$ and every sufficiently large integer $p$, there is a setting $n=n(p,\lambda)$ for which every randomized query algorithm for $\textsc{graph-dist}(n,p,\lambda)$ requires at least $cn^{2}/\lambda^{2}$ queries in the worst case.

Proof.

We reduce from $\textsc{unique-or}_{N}$, where $N=\binom{p}{2}$, using the following plan. Put $n=(2p+1)\lambda$. Let $\mathcal{C}$ be a query algorithm for $\textsc{graph-dist}(n,p,\lambda)$. Based on $\mathcal{C}$, we shall design a $\frac{1}{3}$-error algorithm $\mathcal{A}$ for $\textsc{unique-or}_{N}$ that makes at most as many queries as $\mathcal{C}$. By 5.11, this number of queries must be at least $N/3=\Omega(p^{2})=\Omega(n^{2}/\lambda^{2})$.

As usual, we detail our reduction for $\lambda=1$; the Blow-up Lemma (Lemma 5.2) then handles general $\lambda$. By Lemma 5.10, $H\in\mathcal{G}_{1}$ whereas each $H_{ij}\in\mathcal{G}_{2}$ (cf. Definition 5.3, taking $q=p$).

We now design $\mathcal{A}$. Let $\mathbf{x}\in\{0,1\}^{N}$ be the input to $\mathcal{A}$. Using a canonical bijection, let us index the bits of $\mathbf{x}$ as $x_{ij}$, where $1\leqslant i<j\leqslant p$. Algorithm $\mathcal{A}$ simulates $\mathcal{C}$ and outputs $1$ iff $\mathcal{C}$ decides that its input lies in $\mathcal{G}_{2}$. Since $\mathcal{C}$ makes queries to a graph, we shall design an oracle for $\mathcal{C}$ whose answers, based on query answers for input $\mathbf{x}$ to $\mathcal{A}$, will implicitly define a graph on vertex set $V:=A\uplus B$, as in Definition 5.9. The oracle answers queries as follows.

• •

For $i,j\in[p]$, it answers $\operatorname{Pair}(a_{i},a_{j})$ and $\operatorname{Pair}(b_{i},b_{j})$ with $1-x_{ij}$.

• •

For $i,j\in[p]$, it answers $\operatorname{Pair}(a_{i},b_{j})$ and $\operatorname{Pair}(a_{j},b_{i})$ with $x_{ij}$.

• •

For $i\in[p]$, it answers $\operatorname{Pair}(a_{p+1},a_{i})$ with $1$ and $\operatorname{Pair}(a_{p+1},b_{i})$ with [math].

• •

For $i\in[p]$ and $d\in[p-1]$, it answers $\operatorname{Neighbor}(a_{i},d)$ with $a_{j}$ if $x_{ij}=0$ and $b_{j}$ if $x_{ij}=1$, where $j=d$ if $d<i$, and $j=d+1$ otherwise.

• •

For $i,d\in[p]$, it answers $\operatorname{Neighbor}(a_{i},p)$ with $a_{p+1}$ and $\operatorname{Neighbor}(a_{p+1},d)$ with $a_{d}$.

• •

For $i\in[p]$ and $d\in[p-1]$, it answers $\operatorname{Neighbor}(b_{i},d)$ with $b_{j}$ if $x_{ij}=0$ and $a_{j}$ if $x_{ij}=1$, where $j=d$ if $d<i$, and $j=d+1$ otherwise.

• •

For all other combinations of $v\in V$ and $d\in\mathbb{N}$, it answers $\operatorname{Neighbor}(v,d)=\bot$.

By inspection, we see that the graph defined by this oracle is $H$ if $\mathbf{x}=\mathbf{0}$ and is $H_{ij}$ if $\mathbf{x}=\mathbf{e}_{ij}$. Furthermore, the oracle answers each query by making at most one query to the input $\mathbf{x}$. It follows that $\mathcal{A}$ makes at most as many queries as $\mathcal{C}$ and decides $\textsc{unique-or}_{N}$ with error at most $\frac{1}{3}$. This completes the proof for $\lambda=1$.

To handle $\lambda>1$, we modify the oracle in the natural way so that the implicitly defined graph is $H^{\lambda}$ when $\mathbf{x}=\mathbf{0}$ and $H_{ij}^{\lambda}$ when $\mathbf{x}=\mathbf{e}_{ij}$. We omit the details, which are routine. ∎

As an immediate consequence of Lemma 5.12, we get the following query lower bounds.

Theorem 5.13**.**

Given query access to an $n$-vertex graph $G$, succeeding with probability at least $2/3$ at either of the following tasks requires $\Omega(n^{2}/\lambda^{2})$ queries, where $\lambda\geqslant 1$ is an integer parameter:

1. (i)

produce a proper $(\kappa+\lambda)$-coloring of $G$; 2. (ii)

produce an estimate $\hat{\kappa}$ such that $|\hat{\kappa}-\kappa|\leqslant\lambda$. ∎

We now prove a lower bound of the second flavor, where the algorithm knows $\kappa$ in advance.

Theorem 5.14**.**

Given an integer $\kappa$ and query access to an $n$-vertex graph $G$ with $\kappa(G)=\kappa$, an algorithm that, with probability $\frac{2}{3}$, produces a proper $(\kappa+\lambda)$-coloring of $G$ must make $\Omega(n^{2}/\lambda^{2})$ queries.

Proof.

We focus on the case $\lambda=1$; the general case is handled by the Blow-up Lemma, as usual.

Let $\mathcal{C}$ be an algorithm for the coloring problem. We design an algorithm $\mathcal{A}$ for $\textsc{unique-find}_{N}$, where $N=\binom{p}{2}$, using the same reduction as in Lemma 5.12, changing the post-processing logic as follows: $\mathcal{A}$ outputs $(i,j)$ as its answer to $\textsc{unique-find}_{N}(\mathbf{x})$, where $1\leqslant i<j\leqslant p$ is such that $a_{i}$ and $a_{j}$ are colored the same by $\mathcal{C}$.

To prove the correctness of this reduction, note that when $\mathbf{x}=\mathbf{e}_{ij}$, the graph defined by the simulated oracle is $H_{ij}$ and $\kappa(H_{ij})=p-1$ (Lemma 5.10). Suppose that $\mathcal{C}$ is successful, which happens with probability at least $\frac{2}{3}$. Then $\mathcal{C}$ properly $p$-colors $H_{ij}$. Recall that $V(H_{ij})=A\uplus B$, where $|A|=p+1$; there must therefore be a color repetition within $A$. The only two non-adjacent vertices inside $A$ are $a_{i}$ and $a_{j}$, so $\mathcal{A}$ correctly answers $(i,j)$. By 5.11, $\mathcal{A}$ must make $\Omega(N)=\Omega(p^{2})$ queries. ∎

5.3 A Combinatorial Lower Bound

Finally, we explore a connection between degeneracy based coloring and the list coloring problem. In the latter problem, each vertex has a list of colors and the goal is to find a corresponding list coloring—i.e., a proper coloring of the graph where each vertex receives a color from its list—or to report that none exists. Assadi et al. [ACK19] proved a beautiful Palette Sparsification Theorem, a purely graph-theoretic result that connects the $(\Delta+1)$-coloring problem to the list coloring problem.

Define a graph $G$ to be $[\ell,r]_{\delta}$-randomly list colorable (briefly, $[\ell,r]_{\delta}$-RLC) if choosing $r$ random colors per vertex, independently and uniformly without replacement from the palette $[\ell]$, permits a list coloring with probability at least $1-\delta$ using these chosen lists.222When $r\geqslant l$, this procedure simply produces the list $[\ell]$ for every vertex. Their theorem can be paraphrased as follows.

Fact 5.15** (Assadi et al.[ACK19], Theorem 1).**

There exists a constant $c$ such that every $n$-vertex graph $G$ is $[\Delta(G)+1,\,c\log n]_{1/n}$-RLC. ∎

Indeed, this theorem is the basis of the various coloring results in their work. Let us outline how things work in the streaming model, focusing on the space usage. Given an input graph $G$ that is promised to be $[\ell,r]_{1/3}$-RLC, for some parameters $\ell,r$ that may depend on $G$, we sample $r$ random colors from $[\ell]$ for each vertex before reading the input. Chernoff bounds imply that the conflict graph—the subgraph of $G$ consisting only of edges between vertices whose color lists intersect—is of size $O(|E(G)|r^{2}/\ell)$, w.h.p.. Using $|E(G)|\leqslant n\Delta/2$, taking $\ell=\Delta+1$ and $r=O(\log n)$ bounds this size by $\widetilde{O}(n)$, so a semi-streaming space bound suffices to collect the entire conflict graph. (For full details, see Lemma 4.1 in [ACK19].) Finding a list coloring of the conflict graph (which exists with probability at least $2/3$) yields an $\ell$-coloring of $G$.

For a similar technique to work in our setting, we would want $\ell\approx\kappa$. Recalling that $|E(G)|\leqslant n\kappa$, for the space usage to be $\widetilde{O}(n)$, we need $r=O(\operatorname{polylog}n)$. This raises the following combinatorial question: what is the smallest $\lambda$ for which we can guarantee that every graph is $[\kappa+\lambda,O(\operatorname{polylog}n)]_{1/3}$-RLC?

By the discussion above, our streaming lower bound in Theorem 5.7 already tells us that such a result is not possible with $\lambda=O(\kappa^{\frac{1}{2}-\gamma})$. Our final result (Theorem 5.17 below) proves that we can say much more.

Let $J_{n,t}$ denote the graph $K_{t}+\overline{K}_{n-t}$, i.e., the graph join of a $t$-clique and an $(n-t)$-sized independent set. More explicitly,

[TABLE]

Lemma 5.16**.**

For integers $0<r\leqslant t<n$, if $J_{n,t}$ is $[\kappa+\kappa/r,\,r]_{\delta}$-RLC, then $\delta\geqslant 1-r^{n}/(r+1)^{n-t}$.

Proof.

Take a graph $J_{n,t}$ with vertices partitioned into $A$ and $B$ as in eq. 6. An ordering with $B\lhd A$ shows that $\kappa=\kappa(J_{n,t})=t$. We claim that for every choice of colors lists for vertices in $A$, taken from the palette $[t+t/r]$, the probability that the chosen lists for $B$ permit a proper list coloring is at most $p:=r^{n}/(r+1)^{n-t}$. This will prove that $\delta\geqslant 1-p$.

To prove the claim, consider a particular choice of lists for $A$. Fix a partial coloring $\psi$ of $A$ consistent with these lists. If $\psi$ is not proper, there is nothing to prove. Otherwise, since $A$ induces a clique, $\psi$ must assign $t$ distinct colors to $A$. In order for a choice of lists for $B$ to permit a proper extension of $\psi$ to the entire graph, every vertex of $B$ must sample a color from the remaining $t/r$ colors in the palette. Since $r$ colors are chosen per vertex, this event has probability at most

[TABLE]

The claimed upper bound on $p$ now follows by a union bound over the $r^{t}$ possible partial colorings $\psi$. ∎

This easily leads to our combinatorial lower bound, given below. In reading the theorem statement, note that the restriction on edge density strengthens the theorem.

Theorem 5.17**.**

Let $n$ be sufficiently large and let $m$ be such that $n\leqslant m\leqslant n^{2}/\log^{2}n$. If every $n$-vertex graph $G$ with $\Theta(m)$ edges is $[\kappa(G)+\lambda,\,c\log n]_{1/3}$-RLC for some parameter $\lambda$ and some constant $c$, then we must have $\lambda>\kappa(G)/(c\log n)$.

Proof.

Suppose not. Put $t=\lceil{m/n}\rceil$, $r=c\log n$, and consider the graph $J_{n,t}$ defined in eq. 6. By the bounds on $m$, $|E(J_{n,t})|=t(t-1)/2+t(n-t)=\Theta(nt)=\Theta(m)$. Put $\kappa:=\kappa(J_{n,t})$. By assumption, $J_{n,t}$ is $[\kappa+\kappa/r,\,r]$-RLC, so Lemma 5.16 implies that

[TABLE]

Since $t=O(n/\log^{2}n)$ and $r=c\log n$, this is a contradiction for sufficiently large $n$. ∎

We remark that the above result rules out the possibility of using a palette sparsification theorem along the lines of Assadi et al. [ACK19] to obtain a semi-streaming coloring algorithm that uses fewer colors than Algorithm 1 (with the setting $\varepsilon=1/\log n$).

More generally, suppose we were willing to tolerate a weaker notion of palette sparsification by sampling $O(\log^{d}n)$ colors per vertex, for some $d\geqslant 1$: this would increase the space complexity of an algorithm based on such sparsification by a $\operatorname{polylog}n$ factor. By Lemma 5.16, arguing as in Theorem 5.17, we would need to spend at least $\kappa+\kappa/\Theta(\log^{d}n)$ colors. This is no better than the number of colors obtained using Algorithm 1 with the setting $\varepsilon=1/\log^{d}n$, which still maintains semi-streaming space. In fact, palette sparsification does not immediately guarantee a post-processing runtime that is better than exponential, because we need to color the conflict graph in post-processing. Meanwhile, recall that Algorithm 1 has $\widetilde{O}(n)$ post-processing time via a straightforward greedy algorithm. Furthermore, since there exist “hard” graphs $J_{n,t}$ at all edge densities from $\Theta(n)$ to $\Theta(n^{2}/\log^{2}n)$, we cannot even hope for a semi-streaming palette-sparsification-based algorithm that might work only for sparse graphs or only for dense graphs.

Acknowledgement

We gratefully acknowledge several helpful discussions we have had with Sepehr Assadi (especially those that called to our attention a nuance with the Congested Clique algorithm) and Deeparnab Chakrabarty.