- The paper introduces query weights and a structural conjecture, showing that balanced quantum algorithms must concentrate query effort on some variables rather than distribute it uniformly.
- The paper proves that a t-query, d-round quantum algorithm can be simulated on a 1−δ fraction of inputs using 2^{O(d²)}(t log(1/δ)/ε)^{O(d)} classical queries, resolving the conjecture for constant-depth and nonadaptive algorithms.
- The paper connects query-model simulations to random-oracle complexity, establishing conditional equivalences between relativized and unrelativized quantum–classical separations and showing that unstructured exponential speedups require polynomially many rounds.
The simulation conjecture and the need for structure
A longstanding folklore conjecture in quantum complexity theory—formalized by Aaronson in his "semi-grand challenges" list—states that every t-query quantum algorithm can be approximated on most inputs by a classical algorithm making $\poly(t)$ queries. If true, this "simulation conjecture" would imply that any partial function F:{0,1}N→{0,1,∗} admitting a superpolynomial quantum-classical query separation must have a very small domain of defined inputs; that is, superpolynomial speedups require a highly specific promise structure. This would formalize the empirical observation that known dramatic speedups (Simon's problem, Period-Finding, Forrelation) all exploit global structure such as hidden subgroups or Fourier correlations.
The predominant prior approach to the simulation conjecture runs through the Aaronson–Ambainis conjecture about bounded low-degree polynomials: that every bounded degree-t polynomial has a variable with influence at least $\poly(\Var(p)/t)$. Despite nearly two decades of effort, the best known bound remains exp(t), obtained via the DFKO Fourier-tails result, and all known proofs hit an inherent barrier because they rely on hypercontractivity, whose degree dependence is exponential.
Query weights as a whitebox alternative
This paper proposes a different route based on query weights, a technique dating to Bennett–Bernstein–Brassard–Vazirani (BBBV). For a t-query algorithm A with pre-query states ∣ψ(t′)(x)⟩, the weight wi(t′)(x) is the probability mass the state places on the query register equaling $\poly(t)$0, and $\poly(t)$1 summarizes how the algorithm allocates its budget across coordinates.
The authors formulate a new conjecture: for any $\poly(t)$2-query quantum algorithm whose acceptance probability is nontrivially balanced (with $\poly(t)$3 not too small), some variable receives expected query weight at least $\poly(t)$4. Since the average coordinate receives only $\poly(t)$5 weight, this asserts that balanced problems cannot be solved by algorithms that evenly distribute their query budget. Two structural facts frame this conjecture's role:
- It is implied by Aaronson–Ambainis, via the inequality $\poly(t)$6 relating query weights to influences.
- It implies the simulation conjecture, via a regularity lemma showing that any quantum algorithm admits a classical decision tree of depth $\poly(t)$7 whose leaves restrict the algorithm to be $\poly(t)$8-regular; regular algorithms are then approximated by constants under the conjecture.
The approach is thus a "syntactic"/whitebox counterpart to the polynomial method's blackbox framing, and it carries a second advantage: query weights are far easier to estimate algorithmically than influences, which becomes crucial for the random-oracle implications discussed below.
Main result: parallel algorithms
The paper's central contribution settles the simulation conjecture for parallel quantum algorithms. A $\poly(t)$9-parallel F:{0,1}N→{0,1,∗}0-round algorithm makes up to F:{0,1}N→{0,1,∗}1 simultaneous queries per round for F:{0,1}N→{0,1,∗}2 rounds; round complexity abstracts circuit depth and adaptivity. The main theorem shows that any F:{0,1}N→{0,1,∗}3-query F:{0,1}N→{0,1,∗}4-round quantum algorithm can be classically simulated on a F:{0,1}N→{0,1,∗}5 fraction of inputs to additive error F:{0,1}N→{0,1,∗}6 using
F:{0,1}N→{0,1,∗}7
queries. For constant F:{0,1}N→{0,1,∗}8 this confirms the strong version of the simulation conjecture (F:{0,1}N→{0,1,∗}9 dependence), resolving it even for nonadaptive algorithms, which were previously open despite being surprisingly powerful—Simon's problem, Period-Finding, Forrelation, and Yamakawa–Zhandry's unstructured search separation are all nonadaptive. In the superconstant regime, the bound improves on the prior t0 whenever t1, and it implies that exponential separations for unstructured problems require polynomially many rounds. The authors note the resulting practical dilemma: exponential separations are most likely to survive fault-tolerance overheads, yet polynomial-depth circuits are precisely what those overheads make infeasible on near-term hardware.
Proof techniques
The proof proceeds by contrapositive through a regularity-to-bias argument built on Talagrand's convex-distance inequality rather than McDiarmid's bounded differences inequality, because adaptive algorithms induce input-dependent distance measures t2.
For nonadaptive algorithms (t3), the argument is short: the hybrid method gives t4 between accepting and rejecting inputs; averaging over inputs and applying McDiarmid yields t5, so regularity forces bias.
For adaptive algorithms, two difficulties arise: the distance measure depends on the input, and one must convert expected bounds on each t6 into high-probability bounds without losing a factor of t7. The warm-up proof handles both with a corollary of Talagrand's inequality valid for input-dependent metrics, plus an inductive round-by-round tail bound on query weights exploiting the observation that t8 is itself the acceptance probability of an t9-round algorithm. The threshold recurrence $\poly(\Var(p)/t)$0 produces a doubly exponential dependence on $\poly(\Var(p)/t)$1.
The improved bound replaces singleton statistics with $\poly(\Var(p)/t)$2-wise statistics: a distribution $\poly(\Var(p)/t)$3 over queried sets is $\poly(\Var(p)/t)$4-spread if no size-$\poly(\Var(p)/t)$5 set $\poly(\Var(p)/t)$6 satisfies $\poly(\Var(p)/t)$7. Working directly with set-level distances—which the hybrid method bounds more tightly than index-weight distances—and combining rounds into a quadratically weighted product distribution reduces the recurrence to $\poly(\Var(p)/t)$8, yielding the singly-exponential-in-$\poly(\Var(p)/t)$9 final parameters. An exp(t)0-dependence in the regularity parameter is removed generically via the DFKO junta theorem applied to the acceptance polynomial, together with success amplification for the exp(t)1-dependence.
Random-oracle separations
The paper derives new consequences for whether exp(t)2 relative to a random oracle, open since Fortnow–Rogers. Because query-model simulations do not automatically yield time-efficient relativized simulations, the simulation conjecture alone does not settle this. The key additional ingredient is an algorithmic regularity lemma: assuming exp(t)3, there is an efficient classical procedure that, given a quantum oracle circuit, finds the restriction path making it regular. Finding heavy-query-weight variables reduces to estimating sums of query weights, which is in exp(t)4 via exp(t)5-wise independent hash families—a sharp contrast with the influence-based analogue, whose subroutine lies in exp(t)6 and would require exp(t)7.
Under the strong version of the query-weight conjecture, the paper proves that exp(t)8 for a random oracle exp(t)9 if and only if t0 unrelativized—the first natural example, to the authors' knowledge, of an unresolved statement equivalent in the random-oracle and unrelativized worlds. Unconditionally, the same equivalence holds for polylogarithmic-depth circuits: t1 iff t2. Since Cleve–Watrous showed Shor's algorithm lies in t3 with classical preprocessing, this means random-oracle evidence of quantum advantage for such circuits is no easier than an unrelativized separation. Under the standard (weaker) conjecture, one still obtains that a random-oracle separation would imply t4, but loses the equivalence.
Limitations and open questions
Several caveats bear directly on the results. The random-oracle equivalences are conditional on the strong version of the query-weight conjecture, which itself remains open; the unconditional statements cover only parallel circuit classes, not full t5. All promise-problem formulations rely on the existence of t6-complete problems, and no completeness results are known for total languages. The main theorem's exponent t7 in t8 and the t9 factor leave a gap to the conjectured A0 bound for general A1; the full conjecture for highly adaptive algorithms remains unresolved, and any counterexample must now be highly adaptive. The authors also note that their proofs do not combine with the full generality of the adversary method, leaving open whether stronger bounds are obtainable that way. Concurrent independent work by Liu–Mutreja and by Escudero Gutiérrez–Palazuelos–Saucedo gives alternative simulations for restricted classes, and Liu–Mutreja subsequently obtained a A2 bound for A3-round algorithms; the authors' own follow-up note improves the present bound to A4 with a round-preserving simulation.
Conclusion
This paper reframes the simulation conjecture around query weights rather than influences, replacing the polynomial method with the hybrid method and hypercontractivity with Talagrand's convex-distance inequality. It fully resolves the conjecture for constant-round (including nonadaptive) quantum algorithms, establishes that exponential speedups on unstructured problems demand polynomial depth, and converts these query-complexity results into the first known equivalences between random-oracle and unrelativized separations for natural complexity classes. The remaining gap between the proven A5-type simulations and the conjectured A6 bound for arbitrary adaptivity now delineates the precise frontier of the "structure or depth" thesis.