Source-linked AI summary

Promises should be taken seriously: On relativization with promise problems

David Miloschewsky, Supartha Podder, Dorian Rudolph

arXiv:2609.07945v1cs.CCquant-ph

TL;DR

Promise problems leave off-promise queries unconstrained, complicating the transfer of language-level relativization results. The paper studies robust and loose access and proves that every completion of every PromiseBQP-complete problem can lie outside BQP^O for an oracle O.

  • Problem

    Promise problems specify yes- and no-instances but leave off-promise inputs unconstrained, making black-box oracle access noncanonical.

    Source: §1 · p. 1
  • Method

    The paper formalizes robust and loose oracle access and adapts Toda’s theorem to work directly with promise problems.

    Source: §1.1 · p. 3
  • Results

    For some oracle O, every completion of every PromiseBQP-complete promise problem lies outside BQP^O.

    Source: §1 · p. 2
  • Takeaways & Limitations

    Relativized results for languages need not transfer to promise problems.

    Source: §1.1 · p. 2

    Whether the QCPH upper bound can be improved to P^PP to match Toda’s theorem remains open.

    Source: §1.2 · p. 4

Abstract

from arXiv · show

Relativization is concerned with comparing computational models with black-box access to an oracle. For promise problems, black-box access is not canonical due to inputs outside of the promise being unconstrained. We study two semantics for such access. Under robust queries, a machine must correctly answer regardless of the completion of the problem,, while loose access requires that the internal choices of a machine do not change based on off-promise queries. Our first result separates the language and promise settings. Namely, we construct an oracle $O$ such that $\mathsf{P}^O = \mathsf{BQP}^O = \mathsf{AWPP}^O$, but $\mathsf{PromiseBQP}^O\not\subseteq\mathsf{PromiseP}^O_{\mathsf{/poly}}$. In particular, $\mathsf{BPP}^O = \mathsf{BQP}^O$, but $\mathsf{PromiseBQP}^O \neq \mathsf{PromiseBPP}^O$, showing that results for languages need not transfer to promises. Next, we use loose queries to strengthen the upper bound on the Quantum-Classical Polynomial Hierarchy from $\mathsf{P}^{\mathsf{PP}^{\mathsf{PP}}}$ to $\mathsf{QCPH} \subseteq \mathsf{BP\cdot PP} \subseteq \mathsf{PromiseBPP}^{\mathsf{PP}}$. The same proof also shows $\mathsf{PP}^\mathsf{PromiseBQP} = \mathsf{PP}$. Additionally, we show that $\mathsf{PromiseBQP}$, even when given quantum advice, is self-low under robust queries. Finally, we exhibit an obstruction to transferring language-level counting results to promise classes. Although $\mathsf{AWPP}$ and $\mathsf{APP}$ are low for $\mathsf{PP}$, a corresponding promise analogue would collapse the counting hierarchy as $\mathsf{GapP} \subseteq \mathsf{FP}^{\mathsf{PromiseAWPP}}$. This motivates the introduction of $\mathsf{PromisePostBQP^*}$, which restricts $\mathsf{PostBQP}$ to input-indepencent postselection. By showing that it is low for \PP, we obtain $\mathsf{PP}^{\mathsf{PromiseYQP^*}} = \mathsf{PP}$.

1 Introduction

Promise problems leave off-promise inputs unconstrained, so oracle access requires specifying how machines handle them. The paper shows that language-level relativization results need not transfer to promises and develops results using robust and loose access.

1.1 Our results

  • An oracle exists for which every completion of every PromiseBQP-complete promise problem lies outside BQP^O.The proof uses an oracle with no BQP-complete language; the paper also reports BPP^O = BQP^O while PromiseBQP^O and PromiseBPP^O differ.Source: §1 · p. 2, §1.1 · pp. 2–3

1 Introduction

  • Robust access requires correctness for each oracle completion, whereas loose access requires the same internal choice to work across every completion.For probabilistic machines, loose access fixes a random string that succeeds for every completion; robust access only requires the success probability separately for each completion.Source: §1 · p. 2

1.1 Our results

  • The paper improves the QCPH upper bound by adapting Toda’s theorem directly to promise problems rather than replacing PromiseBQP computations with arbitrary BQP completions.The difficulty is that such a completion cannot simply be assumed to lie in BQP.Source: §1.1 · p. 3
  • Under robust queries, PromiseBQP remains self-low even with quantum advice.The proof partitions the off-promise acceptance interval into polynomially many sub-intervals, randomizes the threshold per distinct query, and uses a hybrid argument for simulation error 1/poly(n).Source: §1.1 · p. 3
  • A promise analogue of the AWPP/APP lowness result would collapse the counting hierarchy, since PromiseAWPP ⊆ PromiseAPP and GapP ⊆ FP^PromiseAWPP.This provides evidence that PromiseAWPP and PromiseBQP differ.Source: §1.1 · p. 3
  • PromisePostBQP*, with postselection depending on input length but not the input itself, is low for PP, yielding PP^PromiseYQP* = PP.The paper introduces this intermediate class because the APP-containment route used for YQP* does not work for PromiseYQP*.Source: §1.1 · p. 4

1.2 Discussion

  • The discussion leaves open matching Toda’s P^PP bound for QCPH and whether analogous oracle separations or loose-access results hold for other classes.It also asks whether Result 2 can be improved to P^PP.Source: §1.2 · p. 4

2 Preliminaries

The preliminaries define promise problems and completions, distinguish robust from loose oracle access, and introduce the complexity classes and tools used in the paper. They also define Cohen genericity relative to an oracle.

2 Preliminaries

  • A promise problem specifies disjoint yes and no sets; a completion is a language agreeing with those sets, and robust access requires a machine to solve the problem for every completion.Quantum oracle access to a completion is implemented by an XOR oracle.Source: §2 · p. 4

2.1 Complexity Zoo

  • PromiseBQP uses quantum circuits with a completeness–soundness gap, while QCPH adds alternating quantified witnesses to a PromiseBQP verifier.The hierarchy starts with QCΣ0 = PromiseBQP.Source: §2.1 · pp. 4–5

2.2 Loose oracle access

  • Loose-access computation fixes an internal choice, such as a witness, so it succeeds consistently across every completion of the oracle promise problem.The preliminaries define loose-access BPP and unambiguous polynomial time, where yes-instances have a unique witness that works for all completions.Source: §2.2 · pp. 6–7

2.3 Cohen genericity

  • Cohen genericity relative to an oracle requires meeting every dense set of conditions arithmetically definable relative to that oracle.An increasing sequence of finite conditions can be constructed to meet each set in an enumeration of those dense sets.Source: §2.3 · p. 7

3 Quantum-Classical Toda’s theorem

The section develops a promise-problem version of Toda’s theorem and an exact arithmetization technique. Together, the results place QCPH within randomized polynomial-time reductions to PP.

3.1 Promise-version of the first half of Toda’s theorem

  • A promise-version of the first half of Toda’s theorem is established for quantified threshold problems.The section introduces a hash-based unique-witness promise problem and uses it in the randomized reduction argument.Source: §3.1 · pp. 8–9

3.2 Exact arithmetization

  • Theorem 3.8 reduces quantified threshold problems to randomized access to a promise problem with a uniform GapP representation across completions.The result combines the exact SPP representation with compression of the random seed into the input.Source: §3.2 · pp. 10–11
  • A promise problem Θ has a completion in PP under the conditions of Lemma 3.9.The construction defines CΘ = {z : G(z) > 0}, which contains Θyes and excludes Θno.Source: §3.2 · pp. 11–12

3 Quantum-Classical Toda’s theorem

  • QCPH is shown to lie in BP · PP, giving a promise-problem version of Quantum-Classical Toda’s theorem.The proof combines a randomized reduction to a promise problem with a PP completion.Source: §3.2 · p. 12

4 Promise problems and languages in relativized worlds

The section constructs a relativized promise problem that quantum polynomial-time machines can solve, but deterministic polynomial-time machines with polynomial advice cannot. Its construction encodes Simon instances into a Cohen-generic oracle and uses dense requirements to defeat every such advised machine.

4.1 Simon’s problem

  • The oracle encodes independent Simon-problem instances, which quantum algorithms solve exactly with polynomially many queries while randomized algorithms face a query lower bound.The section uses these instances to separate promise problems even when the relativized language classes coincide.Source: §4 · p. 12, §4.1 · p. 13
  • Simon instances are encoded as oracle blocks, with each block’s bits specifying the function values for an instance.The oracle’s promise problem is built from these encoded instances and is always in PromiseBQP^A.Source: §4.1 · p. 13

4.2 Density requirements

  • For each enumerated advised machine, the construction defines an upward-closed, arithmetically definable dense set of conditions that force failure on some block of instances.The direct-product bound ensures that no advice string solves all instances in the block; a Cohen-generic oracle meets every such requirement.Source: §4.2 · pp. 14–15
  • The oracle construction gives a promise problem in PromiseBQP^A that no deterministic polynomial-time machine with polynomial advice solves.The proof uses a dense requirement for each enumerated machine and advice bound, ensuring every advice string fails on some input.Source: §4.2 · p. 15

5 BQP and its variants under promises

The section studies promise versions of BQP and stronger variants using robust promise queries. It proves self-lowness results, gives a PromiseAWPP simulation consequence, and introduces an input-length-dependent postselection variant that is low for PP.

5.1 Self-lowness

  • Under robust promise queries, PromiseBQP is self-low, and the result also holds when the querying machine has quantum advice.The advice-class extension uses trusted advice, allowing independent copies for repeated simulations.Source: §5.1 · pp. 15–16

5.2 PromiseAWPP versus PromiseBQP

  • Every GapP function is computable in FP with PromiseAWPP oracle access.The interval protocol keeps the function value between its bounds for either oracle answer, including answers to off-promise queries, and shrinks the interval by a constant fraction.Source: §5.2 · p. 17
  • If PromiseAWPP is contained in PromiseBQP/qpoly, then the counting hierarchy equals YQP*.The proof derives PP containment in PromiseBQP/qpoly from the GapP simulation and the advice-class self-lowness result.Source: §5.2 · p. 17

5.3 Stronger variants of BQP

  • PromisePostBQP* restricts postselection so its state-preparation circuit depends on input length, not the input itself.The class is placed between PromiseYQP* and PromiseBQP/qpoly in the section’s discussion.Source: §5.3 · pp. 17–18
  • PP with a PromisePostBQP* oracle equals PP, and the section consequently obtains the same lowness equality for PromiseYQP*.The corollary follows from the PromisePostBQP* lowness result and the preceding relationship between the classes.Source: §5.3 · pp. 18–19
Loading 2609.07945v1…