Circuit Complexity and Derandomization

Tokyo Institute of TechnologyAkinori Kawachi

Layout

• Randomized vs Determinsitic Algorithms– Primality Test

• General Framework for Derandomization– Circuit Complexity Derandomization

• Circuits– Circuit Complexity and NP vs. P

• Necessity of Circuit Complexity for Derandomization• Summary

Deterministic v.s. Randomized Algorithmsfor (Decision) Problems

Randomness is useful for real-world computation!

Decision problem: PRIME

Input: n-bit number x (0 x < 2n)

Output: “Yes” if x PRIME (x is prime) “No” otherwise

Elementary Det. algorithm: O(2n/2) time [Eratosthenes, B.C. 2c]

Rand. algorithm: O(n3) time w/ succ. prob. 99% [Miller 1976, Rabin 1980]

Exponential-time speed-up!

n = input length

Deterministic v.s. Randomized Algorithmsfor (Decision) Problems

How much randomness make computation strong?

Det. algorithm: O(n12) time [Agrawal, Kayal & Saxena 2004 Gödel Prize]

Rand. algorithm: O(n3) time w/ succ. prob. 99% [Miller 1976, Rabin 1980]

Input: n-bit number x (0 N < 2n)

Output: “Yes” if x PRIME (x is prime) “No” otherwise

Polynomial-time slow-down

Decision problem: PRIME

Derandomization Conjecture

BPP = PRandomization yields NO exponential speed-up!

Always poly-time derandomization possible?

Conjecture

P = {problem: poly-time det. TM computes}BPP = {problem: poly-time prob. TM computes w/ bounded errors}

Class BPP

Class BPP (Bounded-error Prob. Poly-time)

L BPP∈x L∊x L∉Def

Prr[A(x,r) = Yes] > 2/3

r is uniform over {0,1}m

m = |r| = poly(|x|)A( ・ , ・ ): poly-time det. TM

Prr[A(x,r) = No] > 2/3

Nondeterministic Version

AM = NPConjecture

Class AM (Arthur-Merlin Games)

L AM∈x L∊x L∉Def

Prr[w: A(x,w,r) = Yes] > 2/3

|r|,|w| = poly(|x|)A( ・ , ・ , ・ ): poly-time det. TM

Prr[w: A(x,w,r) = No] > 2/3

Hardness vs. Randomness Trade-offs[Yao ’82, Blum & Micali ’84]

• Hard problem exists Good Pseudo-Random Generator (PRG) exists.• Simulate randomized algorithms det.ly with PRG!

Theorem [Impagliazzo & Wigderson 1998]

2O()-time computable decision problem Hs.t. no 20.1-size circuit can compute for every

BPP = P(L is computed in prob. poly-time w/ bounded errors

L is computed in det. poly-time)

Similar theorem holds in nondet. version (AM=NP)

[Klivans & van Melkebeek 2001]

Circuit

x3

∧

x1 x2 0

￢∨∧

∧

∨Gate set = { , , ∧ ∨ ￢ , 0, 1}

Gate set = { , , ∧ ∨ ￢ , 0, 1}

Circuit

0

∧

1 1

￢∨∧

∧

∨

1 1 = 1∧

1

1

1

1

0 0

0

1

10

￢ 0 = 1

1 0 = 0∧ 0 1 = 1∨

0 1 = 0∧0

1 0 = 1∨

1

Input = (1,1,0) 0

Size = 7Depth = 5

Circuit ComplexitySize of circuits is measure for computational resource!

Circuit complexity of L:= min { size of circuit family computing L }

s(n)-size circuit family {Cn:{0,1}n→{0,1}}n computes L

Definition

Defx L C|x|(x) = 1x L C|x|(x) = 0

& size of Cn s(n)

Computational Power of Circuits

Circuit complexity of any problem = O(2n/n)

Theorem [Lupanov 1970]

any (even non-recursive) problem can be computed by some O(2n/n)-size circuit family.

P SIZE(poly)

Theorem [Fisher & Pippenger 1979]

Poly-time TM can be simulated by poly-size circuit family.

SIZE(poly) = {problem: poly-size circuit family can compute}

NP vs. P and Circuits

NP ≠ PConjecture

Some NP problem cannot be computed by any poly-time TM.

NP SIZE(poly)⊄Conjecture

Some NP problem has superpoly circuit complexity.

Note: NP SIZE(poly) ⊄ NP ≠ P

Proving super-poly circuit complexity in NPsolves NP vs. P!

NEXP SIZE(poly)⊄

MA-EXP SIZE(poly)⊄

Current StatusTheorem (Buhrman, Fortnow, & Thierauf 1998)

NEXP ACC⊄ 0(poly)Theorem (Williams 2011)

Randomized version of NEXP

Const-depth poly-size w/ Modulo gates

Grand Challenge

Cf. H-R tradeoff for BPP=P requires at least EXP SIZE(2⊄ .1n)!

Hardness vs. Randomness Trade-offs[Yao ’82, Blum & Micali ’84]

• Hard problem exists Good Pseudo-Random Generator (PRG) exists.• Simulate randomized algorithms det.ly with PRG!

Theorem [Impagliazzo & Wigderson 1998]

2O()-time computable decision problem Hs.t. no 20.1-size circuit can compute for every

BPP = P(L is computed in prob. poly-time w/ bounded errors

L is computed in det. poly-time)

Proof Sketch

1. Construct PRG from hard H.2. Simulate rand. algo. w/ p-random bits.

Proof Sketch1. Construct PRG from hard H.

Goal: Construct GH: {0,1}O(log m) → {0,1}m

Prs[ C(GH(s)) = 1 ] Prr[ C(r) = 1 ]Pseudo-random! truly random!

# possible s = 2O(log m) = poly(m)# possible r = 2m

PointProof: good distinguisher D for GH small circuit CD for H

For every poly-size circuit C,

Proof Sketch2. Simulate rand. algo. w/ p-random bits.

Goal: Det.ly simulate rand. algo. by GH

L BPP∈x L∊x L∉Def

Prr[A(x,r) = Yes] > 2/3

|r| = poly(|x|)A( ・ , ・ ): poly-time det. TM

Prr[A(x,r) = No] > 2/3

Proof Sketch2. Simulate rand. algo. w/ p-random bits.

Goal: Det.ly simulate rand. algo. by GH

Trivial SimulationEnumerate all possible -bit strings!

A(x,00…00)=

Yes

A(x,00…01)=

No

… A(x,11…10)=

Yes

A(x,11…11)=

Yes

#Yes > x L∊#No > x L∉

Require O(2m)=O(2poly(n)) time…

Proof Sketch2. Simulate rand. algo. w/ p-random bits.

Goal: Det.ly simulate rand. algo. by GH

Simulation w/ GH

Enumerate all possible -bit seeds of GH!

A(x,GH(0…0))=

No

… A(x,GH(1…1))=

Yes

#Yes > x L∊#No > x L∉

Require 2O(log m) = poly(n) time!

A(x, ・ ) = circuit C

Is Circuit Complexity Essential?• Proving “some problem is really hard” is HARD! (e.g. NP≠P)– It’s the ultimate goal in complexity theory…

• Can avoid “proving hardness” for derandomization?

NO! Derandomization implies proving hardness!!

BPP=P Some problem is hard.

Theorem [Kabanets & Impagliazzo ‘03]

prAM NP Some problem is extremely hard.

Theorem [Gutfreund & Kawachi ‘10, Aaronson, Aydinlioglu, Buhrman, Hitchcock, & van Melkebeek ‘11]

BPP P

NEXP SIZE, orPermanent ASIZE

Theorem [Kabanets & Impagliazzo ‘03]

Resolving “arithmetic-circuit version of NP vs. P“

prAM NP

EXPNP SIZE

Theorem [Gutfreund & Kawachi ‘10, Aaronson, Aydinlioglu, Buhrman, Hitchcock, & van Melkebeek ‘11]

Summary

• Proving circuit complexity Derandomization– through Pseudo-Random Generator– BPP = P, AM = NP, and more…

• Derandomization Proving circuit complexity

Proving Circuit Complexity Derandomization