Download Interactive Proof Systems: Graph Nonisomorphism and Complexity and more Study notes Computational Methods in PDF only on Docsity!
CS221: Computational Complexity Prof. Salil Vadhan
Lecture 28: Interactive Proof Systems, Graph Nonisomorphism
12/02 Scribe: Ruggiero Cavallo
Contents
1 Announcements 1
2 Agenda 1
3 Classical Proof Systems 1
4 Interactive Proof Systems 2
1 Announcements
1 if number of n inputs equal to 1 ≥ n/ 2 0 otherwise
- section today at 6pm in MD-
- this Friday’s class will be in MD-G
2 Agenda
3 Classical Proof Systems
In classical proof systems, we write down mathematical assertions as strings. Then, we have some language L that equals the set of “true” assertions. For example,
Sat ↔ true statements of form “φ is satisfiable.”
A proof system for a language L is a verification algorithm V that has the following properties:
- Completeness: x ∈ L ⇒ ∃ proof V (x, proof) = accept That is, “true assertions have proofs.”
- Soundness: x ∈ L ⇒ ∀ proof?^ V (x, proof?) = reject That is, “false assertions have no proofs.”
- Efficiency: ∀x, proof V (x, proof) runs in time poly(|x|) Efficiency is natural - the notion of a proof is meaningless if it can’t help you verify the claim.
Note that NP = languages with classical proof systems (think of V as checking the relation of the NP language).
4 Interactive Proof Systems
For interactive proof systems, we add two new ingredients:
- Randomization - V can toss coins, err with some small probability.
- Interaction - we replace static written proofs with a dynamic, computationally unbounded “prover.”
Why introduce these two ingredients?
- it’s philosophically interesting. Outside of math, in most areas of human thought this is how people think of proof- conversational, interactive, randomized(?).
- perhaps we can prove a larger class of assertions (i.e., maybe we can capture more languages). This is interesting from a complexity point of view.
- cryptography (this was the original motivation for interactive proofs).
- efficiency in verification. Any problem in NP has a probabilistic proof system where the verification algorithm only reads a constant number of bits of the proof.
- novel properties: “zero knowledge” (proof reveals nothing other than trueness of assertion; this is very useful in cryptography).
- unexpected applications: inapproximability.
Example: interactive proof system for Graph Nonisomorphism.
G = ([n], E), permutation π : [n] → [n] (where [n] = {1,... , n})
π(G) , ([n], {(π(u), π(v)) (u, v) ∈ E})
G and H are isomorphic (written G ∼= H) if ∃π such that π(G) = H
Graph Isomorphism is the language GI = {(G 0 , G 1 ) : G 0 ∼= G 1 }.
- ∈ NP
- not known to be in P
- Soundness - If x /∈ L ⇒ ∀P ∗^ P r[V accepts in (P ∗, V )(x)] ≤ 1 / 3.
- Efficiency - ∀x the total computation time of V in (P, V )(x) is at most poly(|x|).
Note that you can make 2/3 in ( 1 ) and 1/3 in ( 2 ) arbitrarily close to 1, 0, respectively, by the usual method of repeating many times and having the verifier rule by majority. Also note that there is no constraint on P ’s efficiency.
We define IP to be the class of languages with interactive proof systems.
Theorem 4 GNI ∈ IP
How big is IP?
Theorem 5 (Lund, Fortnow, Karloff, Nisan ’92) co-NP ⊆ IP, in fact P#P^ ⊆ IP.
Proof Sketch: Convince poly-time verifier that a formula is UNsatisfiable.
E#SAT = {(φ, k) : φ has exactly k satisfying assignments}
Observation: φ has exactly k satisfying assignments iff ∃k 0 , k 1 such that:
- k 0 + k 1 = k
- φ 0 (x 2 ,... , xn) = φ(0, x 2 ,... , xn) has exactly k 0 satisfying assignments.
- φ 1 (x 2 ,... , xn) = φ(1, x 2 ,... , xn) has exactly k 1 satisfying assignments.
φ and k are given to both the verifier V and the prover P.
P:
V:
- choose b ∈ { 0 , 1 } at random
- Send b to P.
The prover will recursively prove that (φb, kb) ∈ E#SAT. Each time we’re eliminating one variable; at the end the verifier can just check for itself.
- If (φ, k) ∈ E#SAT ⇒ V accepts with probability 1.
- If (φ, k) ∈/ E#SAT ⇒ V accepts with probability < 1. Either 1, 2, or 3 of above will be violated.
But actually, if (φ, k) ∈/ E#SAT, V might accept with probability exponentially close to 1 (i.e., 1 − 2 −n). We’ll fix this next time.
§
