The Power of Quantum Advice

Document Sample
The Power of Quantum Advice Powered By Docstoc
					A Theory of Isolatability

Scott Aaronson Andrew Drucker
        Freeze-Dried Computation

Motivating Question: How much useful computational work
can one “store” in (say) an n-qubit quantum state, or a coin
whose bias is an arbitrary real number?
Potentially a huge amount!
We give a new tool—called “isolatability”—for ruling out the
possibility of such extravagant encodings.
Idea: Take some advice resource (such as a coin or a quantum
state), and simulate it using a short classical string, together
with a polynomial number of untrusted advice resources.
In other words, all the relevant information in the advice
resource gets packed into an ordinary string (which we say
“isolates” the resource), and we're left with just a
computational search problem—of finding coins, quantum
states, etc. that are consistent with the string.
Part I: The Majority-Certificates Lemma
       Our basic tool
Part II: Application to Quantum Advice
       BQP/qpoly  QMA/poly
Part III: Application to Advice Coins
       PSPACE/coin  PSPACE/poly
Part I: The Majority-
Certificates Lemma
Intuition: We’re given a black box

                 x              f             f(x)

that computes some Boolean function f:{0,1}n{0,1} belonging
to a “small” set S (meaning, of size 2poly(n)). Someone wants to
prove to us that f equals (say) the all-0 function, by having us
check a polynomial number of outputs f(x1),…,f(xm).

This is trivially impossible!
                                         f0   f1     f2   f3   f4   f5
But what if we get 3 black          x1   0    1      0    0    0    0
boxes, and are allowed to           x2   0    0      1    0    0    0
simulate f=f0 by taking the         x3   0    0      0    1    0    0
point-wise MAJORITY of              x4   0    0      0    0    1    0
their outputs?                      x5   0    0      0    0    0    1
      Majority-Certificates Lemma
Definitions: A certificate is a partial Boolean function
C:{0,1}n{0,1,*}. A Boolean function f:{0,1}n{0,1} is
consistent with C, if f(x)=C(x) whenever C(x){0,1}. The size of
C is the number of inputs x such that C(x){0,1}.

Lemma: Let S be a set of Boolean functions f:{0,1}n{0,1}, and
let f*S. Then there exist m=O(n) certificates C1,…,Cm, each of
size O(log|S|), such that
(i) Some fiS is consistent with each Ci, and
(ii) If f1S is consistent with C1, f2S is consistent with C2, and
     so on, then MAJ(f1,…,fm)=f*, where MAJ denotes pointwise
                          Proof Idea
   By symmetry, we can assume f* is the all-0 function. Consider a
   two-player, zero-sum matrix game:
                                          Bob picks an input x{0,1}n
           The lemma follows from this claim! Just choose
       certificates C1,…,Cm independently from Alice’s winning
Alice picks a certificate by a Chernoff bound, almost certainly
      distribution. Then
     MAJ(f1 consistent
  C of size k(x),…,fm(x))=0 for all f1,…,fm consistent with C1,…,Cm
         with some fS
      respectively and all inputs x{0,1}n. So clearly there exist
                       C1,…,Cm with this property.

   Alice wins this game if f(x)=0 for all fS consistent with C.

   Crucial Claim: Alice has a mixed strategy that lets her win
   >90% of the time.
                    Proof of Claim
Use the Minimax Theorem! Given a distribution D over x, it’s
enough to create a fixed certificate C such that

     Pr f consistent with C s.t. f x   1  .
     xD                                        10
Stage I: Choose x1,…,xt independently from D, for some
t=O(log|S|). Then with high probability, requiring
f(x1)=…=f(xt)=0 kills off every fS such that
                       Pr  f x   1  .
                       xD               10
Stage II: Repeatedly add a constraint f(xi)=bi that kills at least
half the remaining functions. After ≤ log2|S| iterations, we’ll
have winnowed S down to just a single function fS.
Part II: Application to
  Quantum Advice
BQP/qpoly is the class of problems solvable in quantum
polynomial time, with the help of polynomial-size “quantum
advice states”
   Formally: a language L is in BQP/qpoly if there exists a polynomial
   time quantum algorithm A, as well as quantum advice states {|n}n
   on poly(n) qubits, such that for every input x of size n, A(x,|n)
   decides whether or not xL with error probability at most 1/3

YQP (“Yoda Quantum Polynomial-Time”) is the
same, except we also require that for every alleged
advice state , A(x,) outputs either the right
answer or “FAIL” with probability at least 2/3

BQP  YQP  QMA  BQP/qpoly
    Watrous 2000: For any fixed, finite black-box group Gn and
    subgroup Hn≤Gn, deciding membership in Hn is in BQP/qpoly
           The quantum advice state is just an equal superposition |Hn over
           the elements of Hn
           We don’t know how to solve the same problem in BQP/poly
    A.-Kuperberg 2007: There exists a “quantum oracle”
       separating BQP/qpoly from BQP/poly
    A. 2004: BQP/qpoly  PP/poly = PostBQP/poly
       Quantum advice can be simulated by classical advice, combined with
       postselection on unlikely measurement outcomes

    A. 2006: HeurBQP/qpoly = HeurYQP/poly
       Trusted quantum advice can be simulated on most inputs by trusted
       classical advice combined with untrusted quantum advice
New Result: BQP/qpoly = YQP/poly
 Trusted quantum advice is equivalent in power to trusted
 classical advice combined with untrusted quantum advice.
         (“Quantum states never need to be trusted”)

Let ρ be any quantum state on n qubits. Then for all m,ε, there
exists a 2-local Hamiltonian H=H1+⋯+HL on poly(n,m,1/ε)
qubits, such that any ground state |φ of H can be used to
simulate ρ (with error ε) on all quantum circuits of size at most
m. In other words, there exists an efficient mapping C→C′ such
that for all circuits C of size m,

    PrC '    accepts PrC  accepts   .
            What Does It Mean?
Preparing quantum advice states is no harder than preparing
ground states of local Hamiltonians
        This explains a once-mysterious relationship between
        quantum proofs and quantum advice: efficient
        preparability of ground states would imply both
        QMA=QCMA and BQP/qpoly=BQP/poly
“Quantum Karp-Lipton Theorem”: NP-complete problems are
not efficiently solvable using quantum advice, unless some
uniform complexity classes collapse unexpectedly

QCMA/qpoly  QMA/poly: classical proofs and quantum advice
can be simulated with quantum proofs and classical advice

                   QMA/qpoly               PP/poly

                                 QMA/poly            PP
This work


                               QCMA/poly             QMA

            BQP/poly             YQP             QCMA

                                                              Holevo’s Theorem
  Minimax        Circuit Learning    Covering Lemma
  Theorem        (Bshouty et al.)      (Alon et al.)
                                                               Random Access
                                                              Code Lower Bound
                                      Learning of p-           (Ambainis et al.)
   Safe                             Concept Classes
Winnowing                           (Bartlett & Long)        Fat-Shattering Bound
 Lemma                                                              (A.’06)

              Real Majority-                    (Aharonov & Regev)
            Certificates Lemma

 Cook-Levin Theorem                          HeurBQP/qpoly=HeurYQP/poly

     LOCAL HAMILTONIANS is            BQP/qpoly=YQP/poly
           (Kitaev)                                               Used as lemma
                               Quantum advice no harder
                             than ground state preparation        Generalizes
“Lifting” the Majority-Certificates Lemma
              Boolean Majority-Certificates         BQP/qpoly=YQP/poly Proof
              Set S of Boolean functions            Set S of p(n)-qubit mixed states
              “True” function f*S                  “True” advice state |n
              Other functions f1,…,fm               Other states 1,…,m
              Certificate Ci to isolate fi          Measurement Ei to isolate I

New Difficulty                                       Solution
The class of p(n)-qubit quantum states is            Result of A.’06 on learnability of quantum
infinitely large! And even if we discretize it, it’s states (building on Ambainis et al. 1999)
still doubly-exponentially large
Instead of Boolean functions f:{0,1}n{0,1},         Learning theory has tools to deal with
now we have real functions f:{0,1}n[0,1]           this: fat-shattering dimension, -covers…
representing the expectation values                  (Alon et al. 1997)
How do we verify a quantum witness without           QMA=QMA+ (Aharonov & Regev 2003)
destroying it?
What if a certificate asks us to verify Tr(E)≤a,    “Safe Winnowing Lemma”
but Tr(E) is “right at the knife-edge”?
Majority-Certificates Lemma, Real Case
Lemma: Let S be a set of functions f:{0,1}ⁿ→[0,1], let f∗∈S, and
let ε>0. Then we can find m=O(n/ε²) functions f1,…,fm∈S, sets
X1,…,Xm⊆{0,1}ⁿ each of size
           n                     and                     2     
     k  O 3 fat  / 48 S ,                       n fat S  
                                                               
                                                         / 48 

for which the following holds. All functions g1,…,gm∈S that
satisfy max g i x   f i x    for all i[m] also satisfy
        xX i
                       maxn g x   f * x    ,
                      x0 ,1

          g x  : g1 x     g m x .
where              1
Theorem: BQP/qpoly = YQP/poly.
Proof Sketch: YQP/poly  BQP/qpoly is immediate. For the
other direction, let LBQP/qpoly. Let M be a quantum
algorithm that decides L using advice state |n. Define
                   f   x  : Pr M  x,   accepts
Let S = {f : }. Then S has “fat-shattering dimension” at most
poly(n), by A.’06. So we can apply the real version of the
Majority-Certificates Lemma to S. This yields certificates
C1,…,Cm (for some m=poly(n)), such that any states 1,…,m
consistent with C1,…,Cm respectively satisfy
                                        
              f 1 x     f  m x   f  n   n   x   
for all x{0,1}n (regardless of entanglement). To check the Ci’s,
we use the “QMA+ super-verifier” of Aharonov & Regev.
   Quantum Karp-Lipton Theorem
Karp-Lipton 1982: If NP  P/poly, then coNPNP = NPNP.
Our quantum analogue:
       If NP  BQP/qpoly, then coNPNP  QMAPromiseQMA.

Proof Idea: A coNPNP statement has the form x y R(x,y).
By the hypothesis and BQP/qpoly = YQP/poly, there exists an
advice string s, such that any quantum state  consistent with s
lets us solve NP problems (and some such  is consistent).
In QMAPromiseQMA, first guess an s that’s consistent with some
state . Then use the oracle to search for an x and  such that,
if  is consistent with s, then R(x,Q(x,)) holds, where Q is a
quantum algorithm that searches for a y such that R(x,y).
Part III: Application to
     Advice Coins
Erik Demaine (motivated by a
  computational genetics problem):
  “Suppose a PSPACE machine can flip a
  coin with Bernoulli probability p an
  unlimited number of times. Can it
  extract an exponential amount of
  information (or even more) about p?”
Me: “I’m sure whatever the answer is, it’s

        Didn’t seem too likely there could be
           superpowerful “Advice Coins”
    Indeed, Hellman & Cover proved the
            following in 1970...
Suppose a finite automaton M is trying to decide
whether a coin has p=½ or p=½+. Then even if it can
flip the coin an unlimited number of times, M needs
(1/) states to succeed with probability (say) 2/3.

This result seems to imply PSPACE/coinPSPACE/poly,
since we could take the first poly(n) bits of p as the
advice. But it breaks down if p is close to 0 or 1!
       Furthermore, quantum mechanics
      nullifies the Hellman-Cover Theorem!
 Theorem: For any >0, it’s possible to distinguish a coin
 with p=½ from a coin with p=½+ using a single qubit of
 memory, with error probability independent of .
Halt with probability ~2/100 at each time step the coin.
                                    Keep flipping
                          0 1
                             angle after halting, in coin
Expected difference in final 2      Whenever the p=½
vs. p=½+ cases: 1 radian           lands heads, rotate
Standard deviation in angle:        /100 radians
                               0 counterclockwise.
                                    Whenever it lands tails,
                                    rotate /100 radians
Theorem: Despite these obstacles,
     BQPSPACE/coin = PSPACE/coin = PSPACE/poly.

Proof: Suffices to show BQPSPACE/coin  PSPACE/poly.
Let 0 = quantum operation applied to our memory
             qubits whenever coin lands heads,
      1 = operation applied when it lands tails
Then induced operation at each time step:

We’re interested in a fixed-point of p: a mixed state p
such that
   Fixed-Points of Superoperators

Already studied by [A.-Watrous 2008],
in the context of quantum computing
with closed timelike curves

Our result there: BQPCTC = PCTC = PSPACE
Quantum computers with CTCs have exactly the same
power as classical computers with CTCs, namely PSPACE
(or: “CTCs make time and space equivalent as
computational resources”)
Key Lemma: Let a(p) be the probability that an S-state
quantum finite automaton accepts, if each input bit is 1
with independent probability p. Then a(p) is a degree-S2
rational function of p.

Proof Idea: We can write a(p) as
             1 T
        lim  Acc p  0  Acc  Acc  p Acc .
        T  T
               t 1

Furthermore, each entry of p can be written as a
degree-S2 rational function of p, by using Cramer’s Rule
on S2S2 matrices.
Hence a(p) is itself a degree-S2 rational function of p,
except possibly at a finite number of singularities:


 A further continuity argument rules out the singularities,
 except possibly at p=0 and p=1.
Now, by calculus, a degree-S2 rational function can cross
the line y=½ at most 2S2 times…
Given a BQPSPACE/coin machine M, let ax(p) be its
acceptance probability on input x{0,1}n and a coin with
Bernoulli probability p.
Challenge: How can we describe p well enough to compute
ax(p) for every x, using only poly(n) bits?


  Finishing the Argument (Sketch)
We’ve upper-bounded how many distinct Boolean
functions f:{0,1}n{0,1} can be expressed, as we vary p
from 0 to 1.
So by the Majority-Certificates Lemma, we can simulate
PSPACE/coin using a PSPACE/poly machine, combined
with poly(n) untrusted advice coins.
We then get a computational search problem: finding
coin biases p1,…,pm that are consistent with the /poly
advice string.
We can solve that problem in PSPACE, using NC
algorithms for root-finding developed by Neff and Pan
 When Can An O(1)-State Finite
Automaton Detect an  Change to
      the Bias of a Coin?
                 Open Problems
Find other applications of isolatability
      Circuit complexity? Communication complexity?
      Learning theory? Quantum information?

Optimality of the Majority-Certificates Lemma?

Quantum finite automata: are their limiting acceptance
probabilities continuous functions of p, for p(0,1)?

Prove a classical oracle separation between BQP/poly
and BQP/qpoly=YQP/poly
 Promised Application to “Physics”
By Kitaev et al., we know LOCAL HAMILTONIANS is QMA-complete.
Furthermore, in their reduction, the witness is a “history state”
                    :
                                 t 1
Measuring this state yields the original QMA witness |1 with
(1/poly(n)) probability. Hence |1 can be recovered from
                                    poly n 
                       ' : 
So given any language LBQP/qpoly=YQP/poly, we can use the
Kitaev et al. reduction to get a local Hamiltonian H whose
unique ground state is |’. We can then use |’ to recover
the YQP witness |, and thereby decide L

Shared By: