Time Hierarchieswith

One Bit of Advice

Konstantin Pervyshev

Steklov Mathematics Institute, St. Petersburg, Russia

joint work with

Dieter van Melkebeek

Time Hierarchy

An open question for probabilistic algorithms:

is there a time hierarchy ?

O(n2)

O(n3)

O(n)

(we still can’t disprove this)

Our result

• Previous results– [Barak 02] uses a modified notion of algorithm

• (algorithms with small advice)

– Under the modified notion of algorithm, a time hierarchy for the probabilistic algorithms exists

• Our result– Under the same modified notion of algorithm,

a time hierarchy exists for any class of algorithms• various classes of probabilistic algorithms• Arthur-Merlin and Merlin-Arthur games, other kinds of IP• NP ∩ co-NP

Outline

• Why standard techniques don’t work

• Where advice helps

• How to prove the generic time hierarchy

Diagonalization

• To separate deterministic time na+e from time na, consider a machine M such that– M(k) := not Nk(k), where na steps of Nk are

simulated• M runs in time na+

• M recognizes some languages L• L can’t be recognized in time na

• (!) deterministic algorithms are recursively enumerable

Probabilistic Algortithmsand Diagonalization

• Probabilistic Algorithms– Probabilistic Turing machines that satisfy some

condition on the error probability • Two-sided error (BPP)

– Pr[M(x) = 1] > 2/3 or Pr[M(x) = 0] > 2/3– “machine M is good on input x”– “machine M is good at length n”

• Need to enumerate only good machines• M(k) := not Nk(k) • Pr[Nk(k) = 1] = 1/2 => Pr[M(k) = 1] = 1/2

• It’s not possible

More Failures

• Various classes of probabilistic algorithms– bounded probability of error

• BPP – two-sided error• RR – one-sided error• ZPP – zero-sided error

• NP ∩ co-NP– two machines solve the same language

• Generally speaking, semantic classes• Diagonalization fails

– Nk(k) is bad => M(k) is bad

• To overcome this, M needs advice on whether Nk is good

Algorithms with Advice

• Turing machine M on input x of length n is provided with– some advice a(n) of length l(n)

• Advice is the same for every input of length n

• Depending on the advice provided,– M may recognize several languages– M may satisfy the promise or not

• Advice of length 1 bit• helps with time hierarchies

Time Hierarchies with Advice

• A time hierarchy exists for probabilistic algorithms with advice of length– O(log log n) bits – [Barak 02] – 1 bit – [Fortnow, Santhanam 04]

• Time hierarchy for any class of algorithms with advice of length– O(log n * log log n) bits – [Fortnow, Santhanam, Trevisan 05]– 1 bit – our result

Generic Time Hierarchy

– To separate na+e from na, it’s sufficient to prove that

• for any 1 ≤ a, there exists a language L

solvable in probabilistic polynomial time with 1 bit of advice

– machine M with advice a(n)

not solvable in probabilistic time na with 1 bit of advice

– any machine Nk with any advice b(n)

A Failed Approach

• Construct M with advice a(n) so that– for some inputs x(0) and x(1) of the same length n

M (x(0),a(n)) := not Nk(x(0),0)

M (x(1),a(n)) := not Nk(x(1),1)

• Both Nk(x,0) and Nk(x,1) may be bad

=> M needs 2 bits of advice in order to diagonalize safely

Another Failed Approach

• M can safely simulate Nk via deterministic simulation– needs exponentially more time

• To get exponentially more time,

we use delayed diagonalization

A Step of Delayed Diagonalization

x(0)

x(1)

z(1)

y(0)Advice on whetherN/0 is good on x’s

M(z(1)) = N(x(1),1)

M(y(0)) = “no”

Advice on whetherN/1 is good on x’s

N/0 is badN/1 is good

Tree-Like Delayed Diagonalization

x(00-11)

z(10,11)

y(00,01)

v(01)

w(11) M(z(01)) = N(x(01),1)M(z(11)) = N(x(11),1)

M(v(01)) = N(z(01),0)

M(y(00)) = “no”M(y(01)) = “no”

M(w(11)) = “no”

N/0 is badN/1 is good

N/0 is good N/1 is bad

Towards a Contradiction

– Assume• for some advice b(n), N is good and

solves the same language as M

– Then• N(v(s),b(|v|)) = M(v(s) ,a(|v|)) =• N(z(s),b(|z|)) = M(z(s) ,a(|z|)) =• N(x(s),b(|x|)) = M(x(s) ,a(|x|))

– Therefore,• N(v(s) ,b(|v|)) = M(x(s),a(|x|)) for some s

– So let• M(x(s),a(|x|)) := not N(v(s),b(|v|))• this can be done deterministically

– thus a contradiction

x(s)

z(s)v(s)

|x| ~ 2|v|a

Choice of the Input Lengths

• We need– parent’s length is polynomial in

children’s length• so that M runs in poly-time

– for any leaf v, roots length is greater than 2|v|a

• so that M can deterministically simulate N at leaves

• It’s possible to satisfy these conditions

• QED

x(s)

z(s)v(s)

Summary

• A time hierarchy exists for virtually any kind of algorithms with one bit of advice

• The probabilistic time hierarchy with advice is a property of algorithms with advice

Thank you!

Dieter van Melkebeek, Konstantin Pervyshev“A Generic Time Hierarchy for Semantic Models

with One Bit of Advice”(CCC’06)

Generic Time Hierarchy

– Theorem• for any 1 ≤ a < b, there exists a language L

solvable in probabilistic time nb with 1 bit of advicenot solvable in probabilistic time na with 1 bit of advice

– Only basic properties of algorithms are needed– Approach

• Construct probabilistic M with 1-bit advice a(n) that– works in time nb

– is good

• Prove that for any probabilistic N with any 1-bit advice b(n) that

– works in time na

– is good

• There exists x such that M(x,a(|x|)) ≠ N(x,b(|x|))

Non-Uniform World

• Previous results– [Barak02, FS04, FST05] a time hierarchy exists for 1 bit

non-uniform probabilistic algorithms with two- and one-sided error

• Our result– a time hierarchy exists for any class of 1 bit non-uniform

algorithms• various classes of probabilistic algorithms

• Arthur-Merlin and Merlin-Arthur games, other kinds of IP

• NP ∩ co-NP

Recall Non-deterministicTime Hierarchy

• Non-deterministic time– M can copy (simulate) N

– M can’t negate N

• Our case– M can copy N(x,b(|x|))

– We have no idea of how to negate N trivially

• Delayed diagonalization

x(0)

x(1)

z(1)

y(0)