Simple vertex coloring algorithms
SSimple vertex coloring algorithms
Jackson Morris
Department of Mathematics, University of California Los [email protected]
Fang Song
Department of Computer Science, Portland State [email protected]
Abstract
Given a graph G with n vertices and maximum degree ∆, it is known that G admits a vertex coloringwith ∆ + 1 colors such that no edge of G is monochromatic. This can be seen constructively bya simple greedy algorithm, which runs in time O ( n ∆). Very recently, a sequence of results (e.g.,[Assadi et. al. SODA’19, Bera et. al. ICALP’20, AlonAssadi Approx/Random’20]) show randomizedalgorithms for ( (cid:15) + 1)∆-coloring in the query model making ˜ O ( n √ n ) queries, improving over thegreedy strategy on dense graphs. In addition, a lower bound of Ω( n √ n ) for any O (∆)-coloring isestablished on general graphs.In this work, we give a simple algorithm for (1+ (cid:15) )∆-coloring. This algorithm makes O ( (cid:15) − / n √ n )queries, which matches the best existing algorithms as well as the classical lower bound for sufficientlylarge (cid:15) . Additionally, it can be readily adapted to a quantum query algorithm making ˜ O ( (cid:15) − n / )queries, bypassing the classical lower bound.Complementary to these algorithmic results, we show a quantum lower bound of Ω( n ) for O (∆)-coloring. Theory of computation → Design and analysis of algorithms;Theory of computation → Quantum computation theory
Keywords and phrases graph coloring, quantum algorithms, query model
Digital Object Identifier © ;licensed under Creative Commons License CC-BYLeibniz International Proceedings in InformaticsSchloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany a r X i v : . [ c s . D S ] F e b Simple vertex coloring algorithms
Graph coloring is a fundamental problems in discrete algorithms and graph theory. It haswide applications in scheduling, resource allocation, compiler optimization, and logisticssettings. In this problem, one aims to assign every vertex a color such that no edge is monochromatic , i.e., both endpoints having the same color. Finding such a valid coloringwith k ≥ k -coloring problem. A critical graph parameter χ ( G ) isthe minimum number of colors necessary to guarantee a valid coloring. In Karp’s renownedresult, 3-coloring as well as deciding χ ( G ) in general are proven NP-complete [12]. On theother hand, it is known that for any graph G , χ ( G ) ≤ ∆ + 1 where ∆ is the maximum degreeof G . This follows from a simple greedy algorithm for ∆ + 1-coloring. The basic observationis that any valid partial ∆ + 1-coloring of G can be extended to a complete ∆ + 1-coloring.This is because every vertex has at most ∆ neighbors, there must be at least one choice ofcolor for that vertex that does not conflict with any of its neighbors.For quite some time, the O ( n ∆) greedy algorithm is the best known algorithm for ∆ + 1vertex coloring on general graphs. Very recently, authors of [2] give a new ˜ O ( n √ n ) algorithmin the query model, where the graph’s adjacency matrix is given as a black-box. Thisalgorithm relies on a tool called palette sparsification, in which a small number of colors aresampled at every vertex and a valid coloring is found from there. These tools are ingeniousbut at the same time rather complicated, when compared to the vanilla greedy algorithmand looking ahead the algorithms presented in this paper. Additionally, the authors of [1]have extended this theory of palette sparsification, achieving improved results for when G is triangle free and for (1 + (cid:15) )∆-coloring in general. Another important line of researchconcerns solving these problems in a space-efficient manner: [2 ,
5] develop algorithms for∆ + 1-coloring and related problems using a (near) linear amount of space. Meanwhile Analmost matching lower bound of Ω( n √ n ) is also known, implying that their algorithm isoptimal up to polylog( n ) factors. Our Contribution.
In this work, we revisit the graph coloring problem, in both classicaland quantum query models. We give a new randomized algorithm for (1 + (cid:15) )∆ coloringwhich is optimal for sufficiently large (cid:15) , and a quantum variant of this algorithm followsreadily that bypasses the classical lower bound in [2]. The most appealing feature of ouralgorithms is their simplicity. Basically, we are inspired by the ∆ + 1 greedy algorithm,where the algorithms progresses by extending a partial solution locally , and it is suitableto speed up “local” search subroutine by quantum unstructured search. In particular, wedo not need the heavy machinery such as palette sparsification and list-coloring in existingclassical algorithms. We overview our results below, and see also Table 1 for a summary.
Result 1 : A randomized algorithm for (1 + (cid:15) )∆-coloring which makes O ( (cid:15) − / n √ n )queries in expectation and always returns a valid coloring.This basic idea inherits the same general “local search” strategy. For each vertex,we sample a random color and check if it conflicts with any of its neighbors that hasbeen assigned already. This simple approach is surprisingly efficient We show that thisalgorithm has expected query complexity O ( n (cid:15) ∆ ), and as in existing works we then justneed to choose between our algorithm and the vanilla greedy algorithm, which gives thedesired O (min { n ∆ , n (cid:15) ∆ } ) = O ( (cid:15) − / n √ n ) expected query complexity. This is optimal for (cid:15) − / = O (1) as we show in Corollary 1, and its Monte Carlo variant improves upon existing . Morris and F. Song XX:3 algorithms [1] by a factor of (cid:15) − . This algorithm also serves a template for designing ourefficient quantum algorithm. Our new algorithm only needs oracle access to the adjacencymatrix (i.e., pair queries), and the vanilla greedy algorithm needs access to the adjacencylist (i.e., neighbor queries). Therefore the final algorithm assumes both kinds of oracles areavailable.A central subroutine in our algorithm, which is again extremely simple, is what we call Find-Conflict . It takes a vertex v , a set of vertices S such that v S and uses the graphoracle to determine if there are any edges of the form ( u, v ) actually present in E ( G ) for anyof the u ∈ S . Classically, this amounts to an exhaustive search on all such vertices s ∈ S . Result 2 : A quantum algorithm which makes ˜ O ( (cid:15) − n / ) queries and returns a valid(1 + (cid:15) )∆-coloring with high probability.Achieving this result essentially has the same strategy as that of result 1, while noting that Find-Conflict can be instantiated by (variants of) Grover’s quantum search algorithm [11,15, 7], under the standard quantum query model where the adjacency matrix can be queriedin quantum superposition. The analysis nonetheless requires more care to carefully containthe errors.We remark that although we rely on well-known quantum algorithmic techniques, itis crucial that they get employed in the right place. For instance, one may be temptedto perform a search over just the color palette, thus requiring O ( √ ∆ log ∆) queries, butsuch an approach would need a rather powerful “color validity” oracle for every vertex,which needs to be dynamically updated as various colors become forbidden for some vertices.Maintaining these oracles from standard oracles (adjacency matrix or adjacency list) wouldincur a significant overhead that would wipe out possible quantum speedup. Result 3 : Quantum query lower bound of Ω( n ) for O (∆) coloring, when (quantum)pair queries are allowed.This is shown by concocting specific graph instances and reducing the unstructured searchproblem to them, when only adjacency matrix queries are available. Therefore the Ω( √ n )quantum query lower bound for unstructured search [4] will transfer. Problem Quantum Algorithm Classical Algorithm ClassicalLower Bound2∆-coloring ˜ O ( n / ) ˜ O ( n √ n ), ˜ O ( n √ n ) [2] Ω( n √ n ) [2](1 + (cid:15) )∆-coloring ˜ O ( (cid:15) − n / ) O ( (cid:15) − / n √ n log n ), O ( (cid:15) − / n √ n log n ) [1] Ω( n √ n ) [2] Table 1
Summary of results - no reference indicates a result from this work. The 2∆-coloringproblem occurs when (cid:15) = 1 and we include this case to demonstrate the quantum advantage. Sinceany ∆ + 1-coloring is also a 2∆-coloring by definition, we use [2] for classical 2∆-coloring, but thiscomparison is not of great importance. While our randomized algorithm is given as a Las Vegasalgorithm, it can easily be converted to Monte-Carlo with success probability at least 1 − /n k forany k using only O ( (cid:15) − / n √ n log n ) queries. Note that prior to this work the best know algorithmfor (1 + (cid:15) )∆-coloring from [1] has query complexity O ( (cid:15) − / n √ n log n ) compared to our algorithm’s O ( (cid:15) − / n √ n log n ). Note that the former performs better for (cid:15) − ≤ √ log n , while the latter performsbetter for (cid:15) − ≥ √ log n . Further discussion.
One immediate problem left open by our results in to close the gapbetween the algorithmic bounds and the lower bound. Some other well studied graph
Simple vertex coloring algorithms problems that are likely to admit similar quantum speedups are variants of coloring (defectivecoloring, edge coloring, etc) and potentially some dynamic graph problems.A problem that has received considerable study in the quantum query model is trianglefinding. Here one aims to either output a triangle if one exists or determine that the graph istriangle free with bounded error (or other variants such as listing all triangles). For a generalgraph this may require Ω( n ) queries to the adjacency matrix oracle. However, a modifiedGrover search can be used, searching over triples of vertices, to achieve an ˜ O ( n √ n ) quantumalgorithm for triangle finding as in [9]. More sophisticated arguments in [10] improve uponthis resulting, bring the query complexity down to ˜ O ( n / ). Conversely, the best knowlower bound for triangle finding in the quantum query model is the immediate Ω( n ) boundestablished in [3]. Just as in triangle finding, a gap persists between the best known quantumlower bound and the best known quantum algorithm for O (∆) coloring as shown in our work.In addition, the problem of maximum matching in which one wishes to find the largestmaximal matching, has been studied in the quantum query model. The very recent results of[13] gives an improved quantum algorithm for maximum matching in the adjacency matrixmodel which makes O ( n / ) queries. However, a lower bound of Ω( n / ) queries in theadjacency matrix model established in [6] show that a gap persists between the best knownalgorithm and lower bound for this problem as well. Other structural graph problems such asthose relating to connected components and spanning forests have also been studied. A recentwork [14], surprisingly, shows exponential quantum speedup for these problem, assuming amore sophisticated oracle model that can answer “cut queries”. In this paper the notation [ n ] will refer to the set { , , . . . n } for any positive integer n .For a positive integer L , the L -coloring problem is as follows: given a graph G = ( V, E )and n = | V | we wish to find an assignment c : [ L ] = { , . . . L } → V such that for any edge( x, y ) ∈ E we have c ( x ) = c ( y ). L will be referred to as the palette throughout. Such anassignment is called a valid L -coloring of G . Let ∆ be the maximum degree of any vertex in G . As previously stated a simple greedy algorithm can be shown to always produce a validcoloring and runs in time O ( n ∆). Rather than time complexity, the results in this paperwill mostly be stated in terms of query complexity. The main models of computation in thispaper are the graph query model and the quantum graph query model. In the standardgraph query model, we assume that n and the degrees of the vertices is the only knowledgeavailable about G before any queries have been made. The standard query model for graphssupports the following types of queries:Pair Queries: we can query the oracle if the edge ( v i , v j ) is present in the graph for any i, j ∈ { , . . . n } . This will be denoted as M [ v i , v j ] = ( v i , v j ) ∈ E M i,j ).Neighbor Queries: we can query the oracle for the j th neighbor of vertex v i for any i ∈ { , . . . n } and j ∈ { , . . . deg v i } . When j > deg v i the query returns N ull .Similarly this is equivalent to granting oracle access to the adjacency list of the graph.The classic greedy ∆ + 1-coloring algorithm can easily be implemented in the graph querymodel via neighbor queries. Explicitly, we can determine which colors are valid at any vertex v ∈ V with deg v neighbor queries. . Morris and F. Song XX:5 In the quantum setting, we assume standard quantum query access to the adjacencymatrix. Namely we allow “pair queries” in superposition. More precisely, we encode eachvertex i in a O (log n )-qubit register | i i , and assume a black-box unitary operation O M : | i, j i 7→ ( − M ( i,j ) | i, j i , ∀ i, j ∈ V ( G ) . Each application of this unitary transformation will be referred to as a quantum query.Quantum “neighbor query” oracle can be defined similarly (i.e., black-box unitarycomputing the adjacency list). However, all our algorithms will only require classical neighbor queries, and hence we do not specify the quantum oracle explicitly.Throughout this paper we use the phrase with high probability to mean with probabilityat least 1 − n k for a sufficiently large constant k . In this section we give a simple optimal randomized algorithm for (1 + (cid:15) )∆-Coloring. Thisalgorithm serves as a "warm-up" and as the inspiration for the quantum algorithms presentedlater. We start by transforming a bound on Monte Carlo algorithms for O (∆)-Coloringto one on Las Vegas algorithms for the same class of problems. From the lower boundsestablished in [2]: (cid:73) Corollary 1.
Any randomized algorithm which always returns a valid coloring requires Ω( n √ n ) queries in expectation. Proof of corollary 1.
Lemma 5.6 of [2] implies that any Monte Carlo algorithm for 2∆coloring which makes fewer than n √ n queries returns an invalid coloring with probabilityat least . So, suppose that some Las Vegas algorithm which makes O ( n / T ( n ) ) queries inexpectation for some T : N → N with lim n →∞ T ( n ) = ∞ . Now, consider a Monte Carlovariant of this algorithm which runs until a valid 2∆-coloring is found or until n √ n querieshave been made. The probability that this Monte Carlo variant fails to return a valid coloringis equal to the probability that the Las Vegas algorithm makes n √ n queries or more on thesame input. Let Q denote the number of queries made by the Las Vegas algorithm. FromMarkov’s inequality, we have P ( Q ≥ n √ n ≤ E [ Q ] a ≤ n √ n/T ( n ) n √ n/ T ( n )Since T ( n ) → ∞ as n → ∞ , there must exist some N such that for all n > N , T ( n ) ≥ n > N P ( Q ≥ n √ n ≤ T ( n ) ≤ and makes at most n √ n queries for sufficiently large n . This contradicts lemma 5.6 of [2],proving the stated lower bound. (cid:74) This result will guide us in our search for randomized algorithms.
Simple vertex coloring algorithms (1 + (cid:15) )∆ -Coloring We begin this section by providing a Las Vegas algorithm for (1+ (cid:15) )∆-coloring in the standardquery model. (cid:73)
Theorem 2.
There exists a randomized algorithm which returns a valid (1 + (cid:15) )∆ vertexcoloring and makes O ( (cid:15) − / n √ n ) queries in expectation. Proof of theorem 2.
Recall that the greedy algorithm for ∆ + 1-coloring algorithm makes O ( n ∆) queries, so when ∆ (cid:28) n this algorithm performs very well. This helps us on our searchfor sublinear algorithms since we can use this just greedy algorithm when ∆ is sufficientlysmall, allowing us to restrict our attention to larger ∆ i.e. ∆ ≥ √ n - this is the case inprevious work [1, 2]. Since ∆ is not given, we must solve for it. This can be done withneighbor queries by binary searching at each vertex, i.e. we binary search at v to find themaximum i such that the neighbor query ( v, i ) does not return N ull . Doing this at everyvertex and then taking the maximum uses O ( n log n ) queries.Both the classical and quantum coloring algorithms in this paper will have the samegeneral strategy: when coloring a vertex choose a random color, test whether that color is avalid choice, if it is we move on, otherwise repeat. While this is a simple approach with someobvious limitations, it yields some surprisingly efficient algorithms. The only data structurewe maintain in all of our algorithms is defined as follows:For every c ∈ [(1 + (cid:15) )∆] we maintain a set called χ ( c ) of all vertices which we have beencolored with color c . Let χ t ( c ) denote the collection of vertices with color c after havingcolored t − Algorithm 1 (1 + (cid:15) )∆-Color( G ( V, E ) , (cid:15) ) for v ∈ V while v is not coloredChoose a color c uniformly at random from [(1 + (cid:15) )∆] for u ∈ χ ( c )Query M [ u, v ] if M [ u, v ] = 1 break choose a new colorAssign color c to v and update χ ( c ) with v return The coloring assignment { χ (1) , . . . χ ((1 + (cid:15) )∆) } Note that this algorithm always returns a valid (1+ (cid:15) )∆-coloring since a color c ∈ [(1+ (cid:15) )∆]is only ever assigned to v if no edge of the form ( u, v ) for u ∈ χ ( c ) is present in the graph.Every vertex has at least one valid color since a vertex v has at most ∆ neighbors andtherefore at least (1 + (cid:15) )∆ − ∆ = (cid:15) ∆ ≥ (cid:15) )∆-Color makes O ( (cid:15) − / n √ n ) queries in expectation, forsufficiently large ∆. Let Q ( G ) denote the number of queries made by this algorithm for agraph G and let Q t denote the number of queries made when coloring vertex v t . Observethat E [ Q ( G )] = E (cid:18) n X t =1 Q t (cid:19) = n X t =1 E [ Q t ]So, bounding E [ Q t ] will allow us to bound the total expected number of queries. . Morris and F. Song XX:7 (cid:73) Lemma 3.
For ∆ ≥ p n/(cid:15) and any t ≤ n E [ Q t ] = O ( p n/(cid:15) ) Proof of lemma 3.
Let c be the first color that is chosen for the vertex we are currentlylooking at. There are two possibilities: 1) c is valid at v t or 2) it is not. Let p = P [ c is valid at v t ], we have: E [ Q t ] = p E [ | χ ( c ) | : c is valid at v t ] + (1 − p )( E [ | χ ( c ) | : c is invalid at v t ] + E [ Q t ])= p E [ | χ ( c ) | : c is valid at v t ] + (1 − p ) E [ | χ ( c ) | : c is invalid at v t ] + (1 − p ) E [ Q t ]= E [ | χ ( c ) | ] + (1 − p ) E [ Q t ]When c is chosen uniformly at random from [(1 + (cid:15) )∆], E [ | χ ( c ) | ] ≤ n (1+ (cid:15) )∆ . Also, recall thatthere are at least (cid:15) ∆ colors valid colors for v t , so p ≥ (cid:15) ∆(1+ (cid:15) )∆ = (cid:15) (cid:15) . From these facts itfollows that E [ Q t ] = 1 p E [ | χ ( c ) | ] ≤ (cid:15)(cid:15) n (1 + (cid:15) )∆ = n(cid:15) ∆Hence, when ∆ ≥ p n/(cid:15) E [ Q t ] ≤ p n/(cid:15) . (cid:74) From Lemma 3 we have that n X t =1 E [ Q t ] = O ( (cid:15) − / n √ n )when ∆ ≥ p n/(cid:15) . So, (1 + (cid:15) )-Color makes O ( (cid:15) − / n √ n ) queries in expectation for ∆ ≥ p n/(cid:15) and the greedy algorithm suffices for ∆ ≤ p n/(cid:15) . This concludes the proof of Theorem 2. (cid:74) Whenever (cid:15) − / = O (1) we have that E [ Q ( G )] = O ( n √ n ). Hence this algorithm achievesthe query lower bound for Las Vegas algorithms established in corollary 1 for sufficientlylarge values of (cid:15) - this is somewhat surprising given the exceedingly simple nature of thisrandomized algorithm. However, this procedure is not useful when (cid:15) − = ∆ (∆ + 1-coloring),so finding an O ( n √ n ) algorithm (Las Vegas or Monte Carlo) for ∆ + 1 coloring remains asan open problem. Also, note that this algorithm can readily be converted to have a fixedquery complexity with error bounded by O (1 /n k ) for any constant k via Markov’s inequality.Doing so incurs a multiplicative cost of an additional O (log n It would be interesting to seeif the randomness used here could be combined with the palette sparsification technique of[2] to achieve an improved algorithm for ∆ + 1-coloring.
The simple randomized algorithm explored in the previous section involved repeatedly solvingthe following sub-problem: Given a vertex v ∈ V and a collection of vertices S ⊂ V \ v determine if { ( u, v ) : u ∈ S } ∩ E ( G ) = ∅ . In other words, does v have any neighbors in S ? Ineffect, this is just an instance of unstructured search. However, we do not know how many(if any) such edges are actually present, so a standard Grover search algorithm will not workhere. Luckily, a slight modification of Grover search resolves this problem. Simple vertex coloring algorithms v Figure 1
Here, we query all edges whose existence would prevent us from coloring v red (cid:66) Claim 4.
There is a quantum algorithm which given a set of vertices S ⊂ V and v ∈ V \ S determines whether or not v is adjacent to any vertex in S and returns such a vertex in S if it exists using O ( p | S | ) queries to the oracle with success probability at least , withoutprior knowledge of |{ ( v, s ) ∈ E | s ∈ S }| .This is a restatement of Theorem 3 of [8], whose algorithm is sketched in the appendix. Thisresult was originally proven in [7]. This 2 / − n via O (log n ) additional runs. So, we will let Find-Conflict ( v, S ) be the algorithmwhich determines if v is adjacent to s ∈ S with failure probability at most n and uses O ( p | S | log n ) queries. We can additionally guarantee that Find-Conflict does not returnfalse positives (concluding there is a conflict when no such conflict exists) by having it returna proposed neighbor of v , s ∈ S , and then make the classical query ( v, s ) to ensure thisedge is actually present in the graph. Thus, the only chance of error is when we incorrectlyconclude there is no conflict, which happens with probability at most n . A detailed versionof this algorithm is included in Appendix A.In (1 + (cid:15) )∆-Color we needed to spend | χ ( c ) | queries in the worst case in order to determineif c is valid at v , but by using Find-Conflict we are able to achieve a quantum speed up.Another change in the case of the quantum algorithm is that we wish only have one typeof randomness (accuracy or query complexity). To simplify the analysis we only allow thealgorithm to test "small" color classes; explicitly, we only look at color classes of size at most n(cid:15) ∆ . We did not do this in the case of the randomized algorithm since the expected size of auniformly random color class gives the desired asymptotic. Since we now wish to bound theerror of the algorithm, we fix the total number of queries at T = 9 (cid:15) − / log n q n ∆ . (cid:73) Theorem 5.
There exists a quantum algorithm which returns a valid (1 + (cid:15) )∆ − vertexcoloring with high probability and makes ˜ O ( (cid:15) − n / ) queries. Proof of theorem 5.
Consider the algorithm below: . Morris and F. Song XX:9
Algorithm 2
Quantum-Color( G ( V, E ), (cid:15) ) t ← while t ≤ T for v ∈ V : while v is not coloredChoose a color k uniformly at random from [(1 + (cid:15) )∆] if | χ ( k ) | > n(cid:15) ∆ break choose a new color elseif Find-Conflict ( v, χ ( k )) t ← t + 2 p n(cid:15) ∆ log n break choose a new color else Assign k to v and update χ ( k ) return The coloring assignment { χ (1) , . . . χ ((1 + (cid:15) )∆) } (cid:73) Lemma 6.
Quantum-Color returns valid (1 + (cid:15) )∆ -coloring of G with high probability. Proof of lemma 6.
First, note that that in this algorithm
Find-Conflict is only ever calledwhen | χ ( c ) | ≤ n(cid:15) ∆ , so every call makes at most 2 p n(cid:15) ∆ log n queries and has failure probabilityat most 1 /n . This algorithm fails to produce a valid coloring in two cases: Some vertex is assigned an invalid color Not all of the vertices are colored by the time 9 (cid:15) − / log n q n ∆ queries have been madeFor the first case, note that any v ∈ V is assigned an invalid color only when Find-Conflict returns false when it should return true . This occurs with probability at most n whena color which is invalid at v is chosen. So a union bound shows that when all vertices areassigned a color, the coloring is valid with probability at least 1 − n .Now, we will show that with high probability every vertex is assigned some color beforeusing too many queries. Let Q t be the number of queries made when attempting to color vertex v t . Additionally, let K t be the number of times that a small random color ( | χ ( k ) | ≤ n(cid:15) ∆ ) istested when attempting to color v t . Note that K t is the number of times that Find-Conflict is called on v t . Let ‘ = 9 (cid:15) − / log n p n ∆ . Then, P [ Q t ≥ ‘ ] ≤ P [ K t ≥ (cid:15) − log n ]Since Find-Conflict cannot have false positives, K t only depends on the number of invalidcolors that we test with Find-Conflict . In other words, we are guaranteed to stop once avalid small color is chosen and we will use this to upper bound K t .Now, note that there are at most (cid:15) ∆2 colors k such that | χ ( k ) | ≥ n(cid:15) ∆ and since thereare at least (cid:15) ∆ valid colors for v , there must be at least (cid:15) ∆2 colors which are both smalland valid. For a color k which is randomly chosen among all small colors, it is valid withprobability at least (cid:15) ∆ / (cid:15) ∆) = (cid:15) (cid:15) ) ≥ (cid:15) . Thus, P [ Q t ≥ ‘ ] ≤ P [ K t ≥ (cid:15) − log n ] ≤ (cid:18) − (cid:15) (cid:19) (cid:15) − log n Now, note that for (cid:15) > (cid:18) − (cid:15) (cid:19) (cid:15) − < √ e , so P [ Q t ≥ ‘ ] ≤ (cid:18) √ e (cid:19) n ≤ (cid:18) (cid:19) n = 1 n By union bound, we get P (cid:20) n X t =1 Q t ≥ (cid:15) − / log n r n ∆ (cid:21) ≤ n X t =1 P [ K t ≥ (cid:15) − log n ] ≤ nn = 1 n Taking both failure cases into account, we can see O ( (cid:15) − / log n q n ∆ ) queries are madeand that a valid (1 + (cid:15) )∆-coloring is obtained with probability at least 1 − Θ( n − ) forsufficiently large n and this can be boosted to 1 − Θ( n − k ) by altering the constants used forany k > (cid:74) Now, note that whenever ∆ ≥ n / (cid:15) − this algorithm makes ˜ O ( (cid:15) − n / ) queries and thegreedy algorithm suffices whenever ∆ ≤ n / . (cid:74) In this section, we establish some lower bounds for coloring and maximal matching with avery simple argument relying on the optimality of Grover’s algorithm [8]: (cid:73)
Theorem 7. Ω( n ) queries are necessary to obtain an O (∆) - coloring on graphs with exactlyone edge using only (quantum) adjacency matrix queries. Proof of theorem 12.
Finding a 2-coloring for these graphs, given the promise that thereis exactly one edge is the same as determining for which i, j ∈ [ n ] with i = j we have M [ i, j ] = 1. Clearly, we can see this as an instance of unstructured search with exactly onemarked element among the (cid:0) n (cid:1) = O ( n ) possible edges. Since unstructured search requiresΩ( √ N ) quantum queries, ∆ + 1 coloring requires Ω( n ) quantum queries in general. Thisalso implies that Ω( n ) queries are necessary for 2∆ coloring on general graphs since findinga 2 − coloring for graphs with exactly one edge is also equivalent to finding a 2∆ coloring(∆ = 1). (cid:74) It would be very interesting to see if more advanced techniques could yield a tighter lowerbound, especially one which includes classical neighbor queries. We suspect that when alltypes of queries are available the same bound holds.
A Details of Find-Conflict
Here, we will give an explicit description of the quantum subroutine
Find-Conflict forcompleteness. Recall that for a given set S ⊂ V and some v ∈ V we wish to determine . Morris and F. Song XX:11 if there exists u ∈ S such that ( u, v ) ∈ E with probability at least . This algorithm isdescribed in [8]. Algorithm 3
Find-Conflict ( v, S ) Let U O be the unitary oracle transformation for t = 1 , | φ i ← √ | S | P u ∈ S | uv i U φ = 2 | φ ih φ | − I Apply U O and then U φ to | φ i each π q Nt timesObserve | φ i resulting in candidate edge ( u, v )Make the classical edge query ( u, v ) if M [ u, v ] = 1: return Truereturn False Proof.
If there are exactly 1 or 2 conflicting neighbors for v in S then u will be one of themwith high probability when t = 1 or t = 2 respectively. When there are no conflicts thealgorithm will always return False . The only worrisome case is when there are 3 or moreconflicts for v in S . However, when there are t > t = 1 , /
2, resulting in an error probability of atmost . O ( p | S | ) queries are used every iteration, so O ( p | S | ) queries are used in total. SeeTheorem 3 of [8] for more details and [7] for general reference. (cid:74) References Noga Alon and Sepehr Assadi. Palette Sparsification Beyond (∆+1) Vertex Coloring. In
Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques(APPROX/RANDOM 2020) , volume 176 of
Leibniz International Proceedings in Informatics(LIPIcs) , pages 6:1–6:22. Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.APPROX/RANDOM.2020.6 . Sepehr Assadi, Yu Chen, and Sanjeev Khanna. Sublinear algorithms for (∆+ 1) vertex coloring.In
Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms , pages767–786. SIAM, 2019. doi:10.1137/1.9781611975482.48 . Aleksandrs Belovs and Ansis Rosmanis. On the power of non-adaptive learning graphs. , Jun 2013. URL: http://dx.doi.org/10.1109/CCC.2013.14 , doi:10.1109/ccc.2013.14 . Charles H. Bennett, Ethan Bernstein, Gilles Brassard, and Umesh Vazirani. Strengths andweaknesses of quantum computing.
SIAM Journal on Computing , 26(5):1510–1523, Oct 1997.URL: http://dx.doi.org/10.1137/S0097539796300933 , doi:10.1137/s0097539796300933 . Suman K. Bera, Amit Chakrabarti, and Prantar Ghosh. Graph coloring via degeneracyin streaming and other space-conscious models.
CoRR , abs/1905.00566, 2019. URL: http://arxiv.org/abs/1905.00566 , arXiv:1905.00566 . Aija Berzina, Andrej Dubrovsky, Rusins Freivalds, Lelde Lace, and Oksana Scegulnaja.Quantum query complexity for some graph problems. In Peter Van Emde Boas, JaroslavPokorný, Mária Bieliková, and Július Štuller, editors,
SOFSEM 2004: Theory and Practice ofComputer Science , pages 140–150, Berlin, Heidelberg, 2004. Springer Berlin Heidelberg. Michel Boyer, Gilles Brassard, Peter Høyer, and Alain Tapp. Tight bounds on quantumsearching.
Fortschritte der Physik , 46(4-5):493–505, Jun 1998. URL: http://dx.doi.org/10.1002/(SICI)1521-3978(199806)46:4/5<493::AID-PROP493>3.0.CO;2-P , doi:10.1002/(sici)1521-3978(199806)46:4/5<493::aid-prop493>3.0.co;2-p . H. Buhrman, R. Cleve, R. De Wolf, and C. Zalka. Bounds for small-error and zero-errorquantum algorithms. In , pages 358–368, 1999. doi:10.1109/SFFCS.1999.814607 . Harry Buhrman, Christoph Dürr, Mark Heiligman, Peter Høyer, Frédéric Magniez, MiklosSantha, and Ronald de Wolf. Quantum algorithms for element distinctness.
SIAMJournal on Computing , 34(6):1324–1330, Jan 2005. URL: http://dx.doi.org/10.1137/S0097539702402780 , doi:10.1137/s0097539702402780 . Francois Le Gall. Improved quantum algorithm for triangle finding via combinatorial arguments. , Oct 2014. URL: http://dx.doi.org/10.1109/FOCS.2014.31 , doi:10.1109/focs.2014.31 . Lov K. Grover. A fast quantum mechanical algorithm for database search, 1996. arXiv:arXiv:quant-ph/9605043 . Richard M Karp. Reducibility among combinatorial problems. In
Complexity of computercomputations , pages 85–103. Springer, 1972. doi:10.1007/978-1-4684-2001-2_9 . Shelby Kimmel and R. Teal Witter. A query-efficient quantum algorithm for maximummatching on general graphs. 2020. arXiv:2010.02324 . Troy Lee, Miklos Santha, and Shengyu Zhang. Quantum algorithms for graph problems withcut queries. arXiv:2007.08285, 2020. https://arxiv.org/abs/2007.08285 . Frédéric Magniez, Ashwin Nayak, Jérémie Roland, and Miklos Santha. Search via quantumwalk.
SIAM journal on computing , 40(1):142–164, 2011. doi:10.1137/090745854doi:10.1137/090745854