In the graph collision problem, the task is to decide whether a known graph on n vertices contains an edge with both endpoints marked, given query access to the input bits specifying the marked vertices. We first refute the conjectured Ω(n2/3) query lower bound with a bounded error quantum algorithm using O(n92/139) queries. We then refine this approach to obtain a O(n11/17) query algorithm. We also obtain a O((nq)11/17) query bound for all (partial) Boolean output functions with positive certificate complexity at most 2 and alphabet size q, contrasting a known Ω(n2/3) lower bound for such problems with large alphabet sizes. We complement these algorithms with an Ω(nlogn) quantum query lower bound for graph collision, exceeding the O(n) certificate complexity barrier for the positive adversary method.
Given a graph G with n vertices and maximum degree Δ, it is known that G admits a vertex coloring with Δ+1 colors such that no edge of G is monochromatic. This can be seen constructively by a 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, Alon Assadi Approx/Random'20]) show randomized algorithms for (ε+1)Δ-coloring in the query model making O~(nn) queries, improving over the greedy strategy on dense graphs. In addition, a lower bound of Ω(nn) for any O(Δ)-coloring is established on general graphs. In this work, we give a simple algorithm for (1+ε)Δ-coloring. This algorithm makes O(ε−1/2nn) queries, which matches the best existing algorithms as well as the classical lower bound for sufficiently large ε. Additionally, it can be readily adapted to a quantum query algorithm making O~(ε−1n4/3) queries, bypassing the classical lower bound. Complementary to these algorithmic results, we show a quantum lower bound of Ω(n) for O(Δ)-coloring.
We study hybrid quantum-classical algorithms in the query model. The computation consists of quantum subroutines that make at most q oracle queries; between subroutines, all qubits are measured and discarded. We prove matching upper and lower bounds for several problems in this model:
(i) (Unbiased) Phase estimation up to a precision ε requires Θ(qε21) queries;
(ii) (Unbiased) Amplitude estimation up to a precision ε requires Θ(qε2p(1−p)) queries;
(iii) Search among N items requires Θ(qN) queries;
(iv) Two level AND-OR tree (AND of m ORs, with n inputs to each OR) requires Θ(qnm) queries.
All of these bounds are optimal up to a constant factor, for all q from 1, corresponding to the classical complexity, to Q(f), the unrestricted quantum query complexity of the respective problem. We also derive a hybrid lower bound for distinguishing two distributions specified by a state-preparation unitary; this bound is tight up to a logarithmic factor.
Besides specific lower bounds, an important contribution is developing methods for proving lower bounds on hybrid quantum algorithms (which have been very ad-hoc up to now). The first two bounds follow from a common framework: we analyze probability distributions over measurement transcripts and bound a progress measure that captures their distinguishability. The AND-OR bound requires a more delicate argument, combining two progress measures that track the information available to the algorithm classically and in quantum form, respectively.
We show that any boolean function can be evaluated optimally by a quantum query algorithm that alternates a certain fixed, input-independent reflection with a second reflection that coherently queries the input string. Originally introduced for solving the unstructured search problem, this two-reflections structure is therefore a universal feature of quantum algorithms. Our proof goes via the general adversary bound, a semi-definite program (SDP) that lower-bounds the quantum query complexity of a function. By a quantum algorithm for evaluating span programs, this lower bound is known to be tight up to a sub-logarithmic factor. The extra factor comes from converting a continuous-time query algorithm into a discrete-query algorithm. We give a direct and simplified quantum algorithm based on the dual SDP, with a bounded-error query complexity that matches the general adversary bound. Therefore, the general adversary lower bound is tight; it is in fact an SDP for quantum query complexity. This implies that the quantum query complexity of the composition f(g,...,g) of two boolean functions f and g matches the product of the query complexities of f and g, without a logarithmic factor for error reduction. It further shows that span programs are equivalent to quantum query algorithms.