Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2610.34079

Two exact quantum queries use at most six variables

Yaqiao Li

quant-phSubmitted Oct 25, 2026• Announced Oct 27, 2026• 0 citations
arXivHTMLPDF

Abstract

We give a direct analytic proof that every total Boolean function computable exactly with at most two quantum queries depends on at most six input variables. This bound is sharp. A previous derivation relied on a numerical classification of Boolean functions on at most four variables; to the best of our knowledge, ours is the first unconditional proof. The main difficulty beyond the one-query case is that query-path vectors need not be mutually orthogonal, so interference prevents the scalar weight-counting argument from applying. We overcome this difficulty by establishing a rigid support-and-branch decomposition: after the coordinates in the first-query support are fixed, the second query induces a family of exact one-query branches. This structural description may be of independent interest.

AI Summary

How many input variables can a total Boolean function depend on if it is computable exactly with two quantum queries? This paper gives a direct analytic proof that the maximum is $J_{\mathrm E}(2)=6$. The six-variable lower bound was already known. A previous characterization implied the same upper bound but was conditional on numerical classification results for functions on at most four variables; the proof here removes that numerical premise. The argument uses the structure of exact two-query states rather than only the polynomial-method bound $\deg(F)\leq4$. Let $S$ denote the physical coordinates with nonzero first-query weight. Applying the second oracle again to the exactness identity shows that $\deg(x_jF)\leq3$ for every $j\in S$. Consequently, if $F$ has at least five relevant variables, then $|S|\leq4$. Fixing $S$ leaves exact one-query branches, each computing a constant, a signed literal, or a signed two-variable parity. Orthogonality between branches with different relevant-coordinate sets implies that at most two nonconstant branch types occur. If two occur, their assignment cells are complementary sets specified by a literal or two-variable parity constraint. Factoring the projected states reduces each restriction to a normalized degree-one state, yielding the count $2+2+2=6$. The result concerns total Boolean functions and exact computation with at most two queries. No general higher-query bound of the conjectured form is established: the paper proposes $J_{\mathrm E}(k)=2^{k+1}-2$, matching known constructions, while whether three exact queries imply at most $14$ relevant variables remains open.

No sign of AI-generated textIncremental

Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.

Comments
TAMC'2026

Related papers

Exact Quantum Query Complexity of the Five-Bit Symmetric Boolean Function $\Exact^5_{3,4}$

Guoliang Xu, Haoran Zhang, Mengfan Wu +2 more

Let \(f = \text{EXACT}^5_{3,4}\) be the Boolean function that equals 1 exactly on inputs of Hamming weight 3 or 4. Earlier numerical studies reported success probabilities close to one using three queries, but the existence of an exact three-query algorithm had remained unresolved. This paper settles this problem by proving that the exact quantum query complexity of \(f\) is \(4\). For the lower bound, we express every three-query algorithm through layer-by-layer Gram matrices of low-degree Fourier coefficients. We then construct a fixed rational dual certificate whose slack matrices are all positive definite. This certificate separates the necessary Gram-matrix region from the exact-output condition and therefore rules out every exact algorithm using at most three queries in the stated model. The positivity verification reduces to five small rational matrices and Sylvester's criterion. For the upper bound, we invoke the previously known four-query algorithm for the seven-bit function \(\text{EXACT}^7_{3,4}\) and apply the standard padding reduction. To quantify the near-exact behavior, we use the same certificate to derive a valid, though not claimed tight, lower bound \(\frac{25600}{43779488192449}>0\) on the worst-case error of every algorithm using at most three queries. This positive error gap is compatible with the near-unit success probabilities reported in earlier numerical studies, which do not establish exact computation.

quant-pharXiv:2610.24518•Oct 20, 2026•0 citations

How Low Can Approximate Degree and Quantum Query Complexity be for Total Boolean Functions?

Andris Ambainis, Ronald de Wolf

It has long been known that any Boolean function that depends on n input variables has both degree and exact quantum query complexity of Omega(log n), and that this bound is achieved for some functions. In this paper we study the case of approximate degree and bounded-error quantum query complexity. We show that for these measures the correct lower bound is Omega(log n / loglog n), and we exhibit quantum algorithms for two functions where this bound is achieved.

arXiv:1206.0717•Jun 4, 2012•0 citations

Exact quantum query complexity for total Boolean functions

Gatis Midrijānis

We will show that if there exists a quantum query algorithm that exactly computes some total Boolean function f by making T queries, then there is a classical deterministic algorithm A that exactly computes f making O(T^3) queries. The best know bound previously was O(T^4) due to Beals et al.

arXiv:quant-ph/0403168•Mar 23, 2004•42 citations

Partial Boolean Functions With Exact Quantum Query Complexity One

Guoliang Xu, Daowen Qiu

We provide two sufficient and necessary conditions to characterize any n-bit partial Boolean function with exact quantum query complexity 1. Using the first characterization, we present all n-bit partial Boolean functions that depend on n bits and can be computed exactly by a 1-query quantum algorithm. Due to the second characterization, we construct a function F that maps any n-bit partial Boolean function to some integer, and if an n-bit partial Boolean function f depends on k bits and can be computed exactly by a 1-query quantum algorithm, then F(f) is non-positive. In addition, we show that the number of all n-bit partial Boolean functions that depend on k bits and can be computed exactly by a 1-query quantum algorithm is not bigger than an upper bound depending on n and k. Most importantly, the upper bound is far less than the number of all n-bit partial Boolean functions for all efficiently big n.

arXiv:2007.10924•Entropy•Feb 3, 2021•6 citations

How Low Can Approximate Degree and Quantum Query Complexity Be for Total Boolean Functions?

Andris Ambainis, Ronald de Wolf

It has long been known that any Boolean function that depends on n input variables has both degree and exact quantum query complexity of Omega(log n), and that this bound is achieved for some functions. In this paper we study the case of approximate degree and bounded-error quantum query complexity. We show that for these measures the correct lower bound is Omega(log n/log log n), and we exhibit quantum algorithms for two functions where this bound is achieved.

IEEE Conference on Computational Complexity (CCC)•Jun 1, 2013•3 citations

Nonadaptive quantum query algorithms for total functions

Ashley Montanaro

We show that any bounded-error quantum query algorithm that computes some total boolean function depending on n variables, and whose queries to the input do not depend on the result of previous queries, must make Omega(n) queries to the input in total. Thus, in this restricted setting, quantum algorithms can achieve at most a constant factor speed-up over classical query algorithms.

arXiv:1001.0018•Dec 30, 2009•1 citation
We give a direct analytic proof that every total Boolean function computable exactly with at most two quantum queries depends on at most six input variables. This bound is sharp. A previous derivation relied on a numerical classification of Boolean functions on at most four variables; to the best of our knowledge, ours is the first unconditional proof. The main difficulty beyond the one-query case is that query-path vectors need not be mutually orthogonal, so interference prevents the scalar weight-counting argument from applying. We overcome this difficulty by establishing a rigid support-and-branch decomposition: after the coordinates in the first-query support are fixed, the second query induces a family of exact one-query branches. This structural description may be of independent interest.
How many input variables can a total Boolean function depend on if it is computable exactly with two quantum queries? This paper gives a direct analytic proof that the maximum is JE(2)=6J_{\mathrm E}(2)=6JE​(2)=6. The six-variable lower bound was already known. A previous characterization implied the same upper bound but was conditional on numerical classification results for functions on at most four variables; the proof here removes that numerical premise.
The argument uses the structure of exact two-query states rather than only the polynomial-method bound deg⁡(F)≤4\deg(F)\leq4deg(F)≤4. Let SSS denote the physical coordinates with nonzero first-query weight. Applying the second oracle again to the exactness identity shows that deg⁡(xjF)≤3\deg(x_jF)\leq3deg(xj​F)≤3 for every j∈Sj\in Sj∈S. Consequently, if FFF has at least five relevant variables, then ∣S∣≤4|S|\leq4∣S∣≤4. Fixing SSS leaves exact one-query branches, each computing a constant, a signed literal, or a signed two-variable parity. Orthogonality between branches with different relevant-coordinate sets implies that at most two nonconstant branch types occur. If two occur, their assignment cells are complementary sets specified by a literal or two-variable parity constraint. Factoring the projected states reduces each restriction to a normalized degree-one state, yielding the count 2+2+2=62+2+2=62+2+2=6.
The result concerns total Boolean functions and exact computation with at most two queries. No general higher-query bound of the conjectured form is established: the paper proposes JE(k)=2k+1−2J_{\mathrm E}(k)=2^{k+1}-2JE​(k)=2k+1−2, matching known constructions, while whether three exact queries imply at most 141414 relevant variables remains open.
Let f=EXACT3,45f = \text{EXACT}^5_{3,4}f=EXACT3,45​ be the Boolean function that equals 1 exactly on inputs of Hamming weight 3 or 4. Earlier numerical studies reported success probabilities close to one using three queries, but the existence of an exact three-query algorithm had remained unresolved. This paper settles this problem by proving that the exact quantum query complexity of fff is 444. For the lower bound, we express every three-query algorithm through layer-by-layer Gram matrices of low-degree Fourier coefficients. We then construct a fixed rational dual certificate whose slack matrices are all positive definite. This certificate separates the necessary Gram-matrix region from the exact-output condition and therefore rules out every exact algorithm using at most three queries in the stated model. The positivity verification reduces to five small rational matrices and Sylvester's criterion. For the upper bound, we invoke the previously known four-query algorithm for the seven-bit function EXACT3,47\text{EXACT}^7_{3,4}EXACT3,47​ and apply the standard padding reduction. To quantify the near-exact behavior, we use the same certificate to derive a valid, though not claimed tight, lower bound 2560043779488192449>0\frac{25600}{43779488192449}>04377948819244925600​>0 on the worst-case error of every algorithm using at most three queries. This positive error gap is compatible with the near-unit success probabilities reported in earlier numerical studies, which do not establish exact computation.
We provide two sufficient and necessary conditions to characterize any n-bit partial Boolean function with exact quantum query complexity 1. Using the first characterization, we present all n-bit partial Boolean functions that depend on n bits and can be computed exactly by a 1-query quantum algorithm. Due to the second characterization, we construct a function F that maps any n-bit partial Boolean function to some integer, and if an n-bit partial Boolean function f depends on k bits and can be computed exactly by a 1-query quantum algorithm, then F(f) is non-positive. In addition, we show that the number of all n-bit partial Boolean functions that depend on k bits and can be computed exactly by a 1-query quantum algorithm is not bigger than an upper bound depending on n and k. Most importantly, the upper bound is far less than the number of all n-bit partial Boolean functions for all efficiently big n.