# Russell Impagliazzo (IAS & UCSD) Valentine Kabanets (IAS & SFU) Antonina Kolokolova (MUN)

## Presentation on theme: "Russell Impagliazzo (IAS & UCSD) Valentine Kabanets (IAS & SFU) Antonina Kolokolova (MUN)"— Presentation transcript:

Russell Impagliazzo (IAS & UCSD) Valentine Kabanets (IAS & SFU) Antonina Kolokolova (MUN)

P  ? NP BPP = ? P IP=PSPACE P  EXP Algebrization ridge Relativization gorge

Let’s compute everything! Hilbert You can’t. Gödel, Turing Let’s prove we can’t in efficient realm, too! Cook, Karp,... The way you are trying, you can’t. BGS, RR,AW...

Proving unprovability 1900: Hilbert’s program Let’s axiomatize all of mathematics! 1930: Godel’s incompleteness theorem There are true mathematical statements that cannot be proven in a (reasonable) theory. 1937: Turing’s uncomputability Uses Cantor’s diagonalization as a major tool. If both L and its complement are semi-decidable (verifiable), then L is decidable. ____ Halt

Diagonalization Idea: list all possible Turing machines For each of them, look at the inputs it accepts (its “language”). Show that there is a TM that is not on the list by constructing one different from any TM in the list on some input. Therefore, there is a language D on which any Turing machine will make an error. 010001..... M1YNNY... M2NNYY... M3NYNN... M4YYYY... DNYYN

Scaling down to complexity 1964-66 Cobham, Edmonds, Rabin Polynomial time = efficient. 1965: Hartmanis/Stearns There are problems solvable in exponential time, but not polynomial time (use diagonalization). Same kind of hierarchy theorems can be proven for space and non-deterministic time and space. Can this be extended to solve P vs. NP?

P vs. NP 1956: Yablonky (in Russia) Thought he solved the “perebor” (brute-force search) problem. Showed that for some class of algorithms it is impossible to eliminate brute-force search. 1956: Godel’s lost letter Do tautologies have proofs of size “not too much larger” than the size of formulas? 1971: Cook,Levin, then Karp Concept of NP-completeness, showing many problems are NP-complete.

The Plot Summary  c. 1971: Quest for “P  NP”  1975: Relativization  1990s: IP=PSPACE, NEXP=MIP, NP=PCP[log n, 1], …  2008: Algebrization P A = NP A P B  NP B P A = NP A P B  NP B ~ ~

“Natural Proof” Monster … Razborov 95, bounded arithmetic framework NP P/poly [RR’97]

Oracles 1939: Turing, already, considered allowing his machines access to a “source of intuition” Such a machine could “ask queries” to some source of knowledge (call it an “oracle”) by writing a query on a tape and immediately getting an answer But the diagonalization argument for undecidability works for such machines! 010001..... M1OM1O YNNY... M2OM2O NNYY M3OM3O NYNN M4OM4O YYYY DODO NYYN

Relativization 1975: Baker/Gill/Solovay There is an oracle A such that some polynomial-time machine with access to it is as powerful as any NP machine with access to that oracle. Take A to be any PSPACE-complete language. There is another oracle B such that NP with access to it is provably stronger than P with access to it. Construct B using diagonalization, or take a random oracle. Diagonalization alone cannot be used to resolve P vs NP. Same is true for many other complexity questions. P A = NP A P B  NP B

Logically speaking … What does it mean to have contradictory relativizations ? Intuitively, “P vs. NP” should be independent of the “Relativizing Complexity Theory”. Oracle worlds ¼ models of a theory P A = NP A P B  NP B [BGS’75]

Oracle worlds and models

AIV92 approach Take a theory of arithmetic (unbounded) and add function symbols. Give limited amount of information about properties of these functions. What can be proven about these functions with the full power of arithmetic, but knowing only a few facts about them?

Relativizing Complexity Theory (RCT) [Arora, Impagliazzo, Vazirani ’92] Axiomatization of PolyTime Computation s.t. { P A | any oracle A } = { stand. models of RCT }. Interpretation: Complexity statements provable in RCT are relativizing statements. Consequence: Non-relativizing statements (such as P  NP ) are independent of RCT.

Cobham’s characterization of P [Cob64]: P is the minimal class of functions that Contain basic functions +, |x|,x*y, bit(x,i),projection, 2 |x|*|x| Closed under function composition If f and g are in P, then so is f o g. And under limited recursion on notation f(x,0)=g(x), f(x,k)=h(x,f(x,k/2)), |f(x,k)| { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com/14/4279028/slides/slide_16.jpg", "name": "Cobham’s characterization of P [Cob64]: P is the minimal class of functions that Contain basic functions +, |x|,x*y, bit(x,i),projection, 2 |x|*|x| Closed under function composition If f and g are in P, then so is f o g.", "description": "And under limited recursion on notation f(x,0)=g(x), f(x,k)=h(x,f(x,k/2)), |f(x,k)|

RCT : more details 2-sorted FO extension of Number Theory. f,g,h,… functions from N to N; x,y,z,… numbers. Cobham’s axioms for P’ (without minimality) basic functions: e.g., +, -, *, # … 2 P’ closures: e.g., f, g 2 P’ ) f o g 2 P’ Add: Induction (unrestricted), Length axiom (outputs of f 2 P’ polybounded), Universality ( P’ has a universal function)

RCT : Defining other classes Define all complexity classes in terms of P’. f 2 NP’ iff 9 c 2 N 9 g 2 P’ 8 x 2 N f(x) = 1, 9 y |y| < |x| c & g(x,y) = 1 f 2 EXP’ iff 9 c 2 N 9 g 2 P’ 8 x 2 N f(x) = 1, g( x, 2 |x| c ) = 1 PSPACE’ = Reachability Problems on digraphs with Adjacency(x,y) 2 P’

Bounded arithmetic vs. AIV92 RCT Reasoning power of a system is not restricted Function symbols have some properties of polytime functions Question: what can be proved about functions from limited known properties? Bounded arithmetic Reasoning power of a system (induction) is restricted If polynomial-time functions are introduced, they are exactly the polytime functions Question: what can be proved about polytime functions with restricted power of reasoning?

RCT : Computation is a “black box” [AIV’92]: Using RCT’s definition of PolyTime, can only prove relativizing complexity statements.

Opening up the “black box” What other properties does PolyTime have ?

Local Checkability of Computation tape symbols tableu of computation 2x3 window Turing machine computation is correct iff all 2x3 “local windows” are legal. (Used by Cook & Levin to show 3-SAT is NP-complete)

LCT: Local Checkability Theorem [AIV’92]: Extend RCT with an axiom stating that computation is locally checkable. LCT Axiom: L  NP   P-uniform 3-cnf family {  n } s.t. x 1 …x n  L iff  y 1 …y m,  n+m (x 1,…,x n, y 1,…,y m ), for m = poly(n). LCT holds in “real world” (by Cook-Levin).

LCT Theory = RCT + LCT axiom [AIV’92]: LCT proves PSPACE=IP, NP=PCP[log n, 1], … If oracle O satisfies LCT, then O 2 NP/poly  coNP/poly. LCT is “too strong”: Provability in LCT is almost the same as provability in “real world”. Versions of LCT with more uniformity are even more restrictive.

RCT vs. LCT RCT is strictly weaker than LCT. e.g., IP=PSPACE is provable in LCT, but not in RCT. “Black-box”/ relativizing techniques “Non-black-box”/ essentially all techniques Theory capturing “arithmetization” ???

Arithmetization Technique used to prove non-relativizing results such as IP=PSPACE Treat Boolean formulas as polynomials over a larger field. Over Boolean values, the two agree. (x Æ y) turns into x*y, (x Ç y) into 1-(1-x)*(1-y). Now, the values of the polynomial can be computed for any integer, giving extra information.

IP=PSPACE [LFKN, Shamir, 1990] PSPACE: True Quantified Boolean Formulae problem Interactive Proofs: L 2 IP[k] if there is a probabilistic polytime verifier V such that x 2 L then 9 prover P so that Pr(V accepts) ¸ 2/3 : (x 2 L) then 8 provers P, Pr(V accepts) · 1/3 Á 2 TQBF? Arithmetize Á as p() V P p(x 1 ) p(a 1, x 2 ) if p(0)+p(1) is ok, send random a 1...

Two Approaches to capturing arithmetization: [For’94 ] & [AW’08]

Fortnow’s self-algebrizing oracles Def: Language A is self-algebrizing if its multilinear polynomial extension A is in P A. ( P A -computable family of multilinear poly’s {p n } over Z s.t., for all Boolean x 1, …, x n, A(x 1, …, x n ) = p n (x 1, …, x n ). ) [Fortnow’94]: For every language L, there is a self-algebrizing language A such that L 2 P A, and A 2 PSPACE L. ~

Self-algebrizing oracles [Fortnow’94]: For every self-algebrizing language A, IP A = PSPACE A. Say that a complexity statement Fortnow- algebrizes if it holds relative to every self- algebrizing oracle. But what complexity statements fail to Fortnow-algebrize ???

Aaronson & Wigderson’s Approach Def [algebrizing inclusion]: For complexity classes C and D, the inclusion C µ D AW-algebrizes if for any A, C A  D A, where A is a low-degree polynomial extension of A. Def [algebrizing separation]: For C and D, C  D AW-algebrizes if for any A, C A  D A. ~ ~ ~

AW-Algebrization [AW’08]: Many known results algebrize (e.g., PSPACE=IP, OWF  NP  ZKIP, MAEXP not in P/poly,...) [AW’08]: Many open questions fail to algebrize (e.g., P vs NP, NP vs BPP,...). Closure under logical deduction ? Statements other than inclusions / separations ? Is all hope really lost ?

Al Jabra P A = NP A P B  NP B ~ ~ [AW’08] Logic P A = NP A P B  NP B [BGS’75] Black Box

AW-Algebrization vs. This Work [AW’08] pointed out an important new barrier to progress in complexity theory. [Impagliazzo,Kabanets,K’09]: Axiomatizing this barrier leads to fine- tuning. Fine-tuned placement of the barrier is less pessimistic about the possibility of progress with current techniques.

Arithmetic Checkability Axiom For every language in NP, there exists a low- degree polynomial verifier. L  NP   polynomial family f={f n }, f n : Z n  Z, deg(f n ) = poly(n) & f  P, so that  Boolean x 1 …x n, x 1 …x n  L iff  Boolean y 1,…,y m s.t. f n+m (x 1,…, x n, y 1,…, y m )  0.

Arithmetic Checkability: Example “ G has an independent set of size t ” input variables: x i,j = indicator for edge (i,j) witness variables: y i = indicator for i being in Independent Set f(x,y) =  i,j (x i,j + y i + y j -3) *  k { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com/14/4279028/slides/slide_36.jpg", "name": "Arithmetic Checkability: Example G has an independent set of size t input variables: x i,j = indicator for edge (i,j) witness variables: y i = indicator for i being in Independent Set f(x,y) =  i,j (x i,j + y i + y j -3) *  k

ACT = RCT + Arithmetic Checkability LCT implies Arithmetic Checkability Axiom. ACT does not imply LCT. (Arithmetic Checkability holds relative to any self- algebrizing, arbitrarily powerful oracle; but LCT doesn’t.)

ACT proves the following: PSPACE = IP, OWF  NP  ZKIP, MAEXP not in P/poly, … (similar to [AW’08])

Independence from ACT NP vs P, EXP vs io-P/poly, BPP vs P, … (construct models using communication complexity lower bounds, similar to [AW’08])

NEXP = MIP … is not provable in ACT either !

NEXP vs MIP Theorem: There is an oracle A satisfying Arithmetic Checkability, but EXP A  MIP A. Proof. Construct L such that EXP L  MIP PSPACE L (using that MIP and PSPACE make only poly-size oracle queries). Let A be the self-algebrizing (Fortnow-) encoding of L, and so A satisfies Arithmetic Checkability. We get EXP L  EXP A, and MIP A  MIP PSPACE L. Hence, EXP A  MIP A. QED

Local vs Arithmetic Checkability as in [AW’08]: For every A satisfying Arithmetic Checkability, NEXP A[poly] = MIP A ( with only poly-length queries allowed ). But, we can construct an Arithmetically Checkable oracle A so that NEXP A[poly] =P A = MIP A ( A = { (N, x, 1 L ) | NTM N A accepts x on some path with oracle queries of length  L } ) So ACT cannot prove MIP  P …

Local vs Arithmetic Checkability [Meir’09]: Combinatorial proof of NEXP = MIP (without using “arithmetization”). Meir’s proof relies on strongly-uniform local checkability of NEXP computation.

ACT and PCP Theorems We also show that ACT does not prove the PCP Theorem that NP=PCP[log n, 1]. Cf. [Dinur’07]: Combinatorial proof of PCP Thm. Also, ( ACT + PCP Theorem ) do not prove NEXP=MIP.

RCT vs ACT vs LCT << PSPACE = IPNP = PCP

Interpretation (strong) Local Checkability is enough to prove any provable complexity statement. Algebraic Checkability provides a useful way to exploit Local Checkability (and show, e.g., PSPACE = IP) However, NP = PCP and NEXP = MIP require more than just Algebraic Checkability. Moreover, [Dinur’07] and [Meir’09] show that Algebraic Checkability is not necessary for these results.

Oracle worlds and models ACT

Conclusion AIV’92 framework provides a way to formalize (axiomatize) barriers by stating which properties of (polynomial-time) computation existing techniques are using. For example, ACT is a useful characterization of provability by using arithmetization-based techniques. Arithmetization alone cannot resolve most open complexity questions. Can Local Checkability be used more?

Open Questions New ways to use Local Checkability ? Combinatorial proof of PSPACE = IP ? Other barriers formalized in the same framework?

P  EXP P  ? NP BPP = ? P IP=PSPACE Algebrization ridge Relativization gorge Thank you!

RCT: Models vs. Oracles { P A | any oracle A } = { stand. models of RCT }. If complexity statement S [Positive, proof theoretic]: is provable in RCT ) True in all (standard) models ) True in all relativizations of P [Negative, model theoretic]: has contrary relativizations ) RCT-models with S true and S false ) independent from RCT

LCT: Local Checkability Theorem [AIV’92]: Extend RCT with an axiom stating that computation is locally checkable. PF-CHK [ poly, log] : class of languages L with polytime verifiers V x,proof (1 n, r), making O(log n) queries to x and proof, so that x 2 L iff 9 poly(n)-bounded proof, such that 8 0 { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com/14/4279028/slides/slide_52.jpg", "name": "LCT: Local Checkability Theorem [AIV’92]: Extend RCT with an axiom stating that computation is locally checkable.", "description": "PF-CHK [ poly, log] : class of languages L with polytime verifiers V x,proof (1 n, r), making O(log n) queries to x and proof, so that x 2 L iff 9 poly(n)-bounded proof, such that 8 0

Conclusion AIV’92 framework provides a way to formalize (axiomatize) barriers by stating which properties of (polynomial-time) computation existing techniques are using In particular, ACT is a useful characterization of provability by using arithmetization-based techniques. Arithmetization alone cannot resolve most open complexity questions. But, this does not mean standard techniques can’t work, or that Arithmetization can’t be part of the solution!

RCT vs ACT vs LCT << PSPACE = IPNP = PCP

Interpretation (strong) Local Checkability is enough to prove any provable complexity statement. Algebraic Checkability provides a useful way to exploit Local Checkability (and show, e.g., PSPACE = IP) However, NP = PCP and NEXP = MIP require more than just Algebraic Checkability. Moreover, [Dinur’07] and [Meir’09] show that Algebraic Checkability is not necessary for these results.

Conclusion ACT is a useful characterization of provability by using arithmetization-based techniques. Arithmetization alone cannot resolve most open complexity questions. But, this does not mean standard techniques can’t work, or that Arithmetization can’t be part of the solution !

Open Questions New ways to use Local Checkability ? Combinatorial proof of PSPACE = IP ?

P  ? NP BPP = ? P IP=PSPACE P  EXP Algebrization ridge Relativization gorge

s A function f is called δ -hard for size s, if any circuit of size s fails to compute f on at least δ fraction of the inputs. 2n2n {0,1} n

Download ppt "Russell Impagliazzo (IAS & UCSD) Valentine Kabanets (IAS & SFU) Antonina Kolokolova (MUN)"

Similar presentations