Transcript The Learnability of Quantum States

Oracles Are Subtle But
Not Malicious
P||
Scott Aaronson
University of Waterloo
Standard Whine
“In the 60 years since Shannon’s counting
Where
argument, we haven’t
proven a superlinear circuit
lower bound for anyexactly
explicit Boolean function!”
Depends whatdo
wethese
mean by “explicit”!
results hit
Kannan 1982: 2  SIZE(n)
a brick
Köbler & Watanabe
1998: ZPPNP  SIZE(n)
wall—and
wePP  SIZE(n)
Vinodchandrancan
2004:
knock it
On the other hand, there are oracles where PNP
down?
and MA have linear-size circuits…
My Whole Paper In One Slide
PP and
Perceptrons
Parallel NP
and
Learning
Oracle Results
Non-Oracle Results
There exists an oracle
relative to which PP
has linear-size circuits
In the real world, PP
doesn’t even have
quantum circuits of size
nk, for any constant k
There’s an oracle where
BPP ||
NP
has linear-size circuits
If P=NP, then we could
exactly learn any polysize circuit C in
P||
NP
C
Oracle Where PPSIZE(n):
Sales Pitch
In the real world, PPSIZE(n)
One of the only nonrelativizing separations we have
I also get an oracle where PEXP  P/poly  PNP  P
(I thereby solve four open problems of
)
Subsumes several previous oracles:
PNP  PP (Beigel)
PP  PSPACE (Aspnes et al.)
MAEXP  P/poly (BF&T) PNP = NEXP (Buhrman et al.)
Same techniques yield a lower bound for k perceptrons
solving k ODDMAXBIT instances
PPBQSIZE(nk):
Sales Pitch
Gives a new, self-contained proof of Vinodchandran’s
result
First nontrivial quantum circuit lower bound (outside
the black-box model)
Along the way, I prove a “Quantum Karp-Lipton
Theorem”:
If PP has small quantum circuits, then the
Counting Hierarchy collapses to QMA
Oracle Where BPP||
NP
 SIZE n  :
Sales Pitch
Bshouty et al. (1994) gave a beautiful algorithm to learn
C
NP
any polynomial-size circuit C in ZPP
My result shows that their algorithm can’t be parallelized
by any relativizing technique
I also get a new result about the ancient problem of
circuit minimization:
There exists an oracle A, such that circuits with
oracle access to A can’t even be approximately
A
NP
minimized in BPP
||
(By contrast, BPP NP suffices)
A
NP
Learning Circuits In P|| If P=NP:
Sales Pitch
Shows that the difficulty of learning circuits in
P||
NP
is “merely” computational (not information-theoretic)
“BATTLE MAP”
BP  PP
BPP
ZPP
NP
PP
Successful
nonrelativizing
incursion
NP
p
S2
P
BPP ||
NP
ZPP ||
NP
P||
NP
BPP path
AM
NP
MA
NP
Alright, enough infomercial.
Time for an oracle where PP
has linear-size circuits…
M1,M2,…: Enumeration of PP machines
(Actually PTIME(nlogn) machines)
Goal: Create an oracle string A such that M 1A ,  , M nA
have small circuits on inputs of size n
Then every Mi will be taken care of on all but finitely many n,
modulo a technicality
n2n columns i,x
25n rows
r
Idea: Pick a random
row, and encode there
what every Mi does on
every input x
Then our linear-size
circuit to simulate
M1,…,Mn will just
hardwire the location
of that row
Problem: The PP machines are also
watching the oracle!
As soon as we write down what the
PP machines do, we might change
what they do, and so on ad infinitum
Call a row r sensitive, if there’s some change to r that
affects whether some PP machine accepts some input
Strategy: Define a “progress measure” Q>0. Show that
(1) As long as every row is sensitive, we can change
the oracle string in a way that at least doubles Q
(2) Q can only double finitely many times
Eventually, then, there must be an insensitive row—
and as soon as there is, we win!
“A WAR OF ATTRITION”
Our Weapon: Polynomials
Let pi,x := | {accepting paths of Mi(x)} |
 | {rejecting paths of Mi(x)} |
Basic Facts:
pi,x(A) is a multilinear polynomial in the oracle bits,
of degree at most nlogn
pi,x(A)  0  Mi(x) accepts
Lemma (follows from Nisan & Szegedy 1994):
Let p be a multilinear polynomial in the bits of A.
Suppose there are (deg(p)2) rows we can modify so
as to change sgn(p(A)). Then there exists a set of
rows we can modify so as to at least double |p(A)|
What should the progress measure Q be?
First idea: Q ( A ) 
pi,x  A 

1 i  n , x0 ,1
n
Suppose every row is sensitive. Then by pigeonhole,
there exists
Mi(x) that’sthat,
sensitive
to 23n rows.
Is an
it possible
whenever
|pi,x(A)| becomes
large, the
3n
Meaning: There are 2 rows we can modify so as to
product
of
all
the
other
terms
change sgn(pi,x(A))
somehow “covers for it” by
Hence, by Nisan-Szegedy, there’s a set of rows we
becoming
small?
can modify so as to double |p (A)|
i,x
Problem: Our goal was to double Q(A)!
Better idea: Q ( A ) 
2

2 k 3

 2   1 p i , x  A 
k
b

2
1  i  n , x   0 ,1  ,
lo g n
b   0 ,1  , 0  k  n
n
As before, there’s some Mi(x) that’s sensitive to 23n rows
Let b=Mi(x) and k=log2|pi,x(A)|. Then we’ll think of Q(A)
as the product of two polynomials:
u  A  : 2
2 k 3

 2   1 p i , x  A 
k
v  A  : Q  A  / u  A 
b

2
u  A  : 2
2 k 3


 2   1 p i , x  A  ,
k
u(A) increases
sharply when we
modify one row
2
b
v  A  : Q  A  / u  A 
By Nisan-Szegedy,
that forces v(A) to
become large later on
v(A)
u(A)
To prevent Q(A)=u(A)v(A) from
doubling, v(A) needs to “nosedive”
This time a “cushion” keeps
u(A) from getting too small
Number of modified rows
The product Q(A)=u(A)v(A) is
thereby forced to double
Open Problems
Prove better nonrelativizing circuit lower bounds!
(duhhhh...)
Does PEXP require exponential-size circuits?
Right now, can show it requires circuits of halfexponential size—i.e. size f(n) where f(f(n))~2n
Bshouty et al.’s algorithm only finds a circuit within
an O(n/log n) factor of minimal. Can we improve
this, or else give evidence that it’s optimal?
NP
Can we learn circuits in P|| , under some
computational assumption that we actually believe?