Oracles Are Subtle But Not Malicious Scott Aaronson University of Waterloo.

Oracles Are Subtle But Not Malicious

Scott Aaronson

University of Waterloo

||P

Standard Whine

“In the 60 years since Shannon’s counting argument, we haven’t proven a superlinear circuit lower bound for any explicit Boolean function!”

Kannan 1982: 2 SIZE(n)

Köbler & Watanabe 1998: ZPPNP SIZE(n)

Vinodchandran 2004: PP SIZE(n)

On the other hand, there are oracles where PNP and MA have linear-size circuits…

Depends what we mean by “explicit”!

Where exactly

do these results hit

a brick wall—and

can we knock it down?

My Whole Paper In One Slide

Oracle Results Non-Oracle Results

PP and Perceptrons

Parallel NP and

Learning

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

If P=NP, then we could exactly learn any poly-

size circuit C inCNPP||

There’s an oracle where

has linear-size circuits

NPBPP||

Oracle Where PPSIZE(n):Sales Pitch

Subsumes several previous oracles:PNP PP (Beigel) PP PSPACE (Aspnes et al.)MAEXP P/poly (BF&T) PNP = NEXP (Buhrman et al.)

I also get an oracle where PEXP P/poly PNP P

Same techniques yield a lower bound for k perceptrons solving k ODDMAXBIT instances

In the real world, PPSIZE(n)One of the only nonrelativizing separations we have

(I thereby solve four open problems of )

PPBQSIZE(nk):Sales Pitch

First nontrivial quantum circuit lower bound (outside the black-box model)

Gives a new, self-contained proof of Vinodchandran’s result

Along the way, I prove a “Quantum Karp-Lipton Theorem”:

If PP has small quantum circuits, then theCounting Hierarchy collapses to QMA

Oracle Where :Sales Pitch

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 withoracle access to A can’t even be approximatelyminimized in

ANPBPP||

nSIZEBPPNP ||

Bshouty et al. (1994) gave a beautiful algorithm to learn any polynomial-size circuit C in CNPZPP

ANPBPP(By contrast, suffices)

Learning Circuits In If P=NP:Sales Pitch

NPP||

Shows that the difficulty of learning circuits in

is “merely” computational (not information-theoretic)

NPP||

NP

MA

AM

NPP||

NPZPP||

NPBPP||NPP

NPZPP

NPBPP

pS2

pathBPP

PPBP

Successful nonrelativizing

incursion

BLACK-B

OX B

ARRIER

RELATIVIZ

ATION B

ARRIER

“BATTLE MAP”

PP

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 thathave small circuits on inputs of size nThen every Mi will be taken care of on all but finitely many n, modulo a technicality

25n rows r

n2n columns i,x

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

An

A MM ,,1

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

Strategy: Define a “progress measure” Q>0. Show that

(1) As long as every row is sensitive, we can changethe oracle string in a way that at least doubles Q

(2) Q can only double finitely many times

Call a row r sensitive, if there’s some change to r that affects whether some PP machine accepts some input

Eventually, then, there must be an insensitive row—and as soon as there is, we win!

“A WAR OF ATTRITION”

Our Weapon: PolynomialsLet 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)|

nxni

xi ApAQ1,0,1

,)(First idea:

Suppose every row is sensitive. Then by pigeonhole, there exists an Mi(x) that’s sensitive to 23n rows.

Meaning: There are 23n rows we can modify so as to change sgn(pi,x(A))

Hence, by Nisan-Szegedy, there’s a set of rows we can modify so as to double |pi,x(A)|

Problem: Our goal was to double Q(A)!

What should the progress measure Q be?

Is it possible that, whenever |pi,x(A)| becomes large, the

product of all the other terms somehow “covers for it” by

becoming small?

n

n

nkbxni

xibkk ApAQ

log0,1,0,1,0,1

2

,32 122)(Better idea:

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:

AuAQAv

ApAu xibkk

/:

122:2

,32

u(A)

This time a “cushion” keeps u(A) from getting too small

v(A)

To prevent Q(A)=u(A)v(A) from doubling, v(A) needs to “nosedive”

u(A) increases sharply when we modify one row

Number of modified rows

By Nisan-Szegedy, that forces v(A) to

become large later on

The product Q(A)=u(A)v(A) is thereby forced to double

AuAQAvApAu xibkk /:,122:

2

,32

Open ProblemsProve better nonrelativizing circuit lower bounds!

(duhhhh...)

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?

Does PEXP require exponential-size circuits?Right now, can show it requires circuits of half-exponential size—i.e. size f(n) where f(f(n))~2n

Can we learn circuits in , under some computational assumption that we actually believe?

NPP||