AI summary by TwinMind
Lecture 2: Doubly Efficient Interactive Proofs, Part 1
MIT OpenCourseWare
1h 53m 22s
Course Logistics and Schedule Updates
- Holiday next week - no class
- Week of 29th: Rachel will give lecture while instructor is in Germany
- October 6th: Special lecture by Oded Regev on new quantum factoring algorithm improvements to Shor's algorithm
- Will be combined colloquium/theory reading group format
- First hour: general theory audience talk
- Next 2 hours: detailed algorithm discussion
Recap of Sum Protocol
- Sum protocol: way to prove sum of multivariate polynomial over small set H (e.g., Boolean cube) equals some value
- Takes exponential time H^m to compute sum naively
- Can verify efficiently using interactive proof with oracle access to function
- Sum protocol is "bread and butter" of proof systems - used in almost every proof system
- Previous applications shown: Sharp Set interactive proof via arithmetization technique
Doubly Efficient Interactive Proofs Introduction
- Classical interactive proofs only cared about efficient verification, not prover runtime
- Doubly efficient: care about both verifier AND prover efficiency
- Prover more powerful than verifier but not all-powerful
- Example: counting triangles in graph via low degree extension technique
Low Degree Extension Theorem
- Theorem: For any function f: H^m → {0,1}, there exists unique polynomial f̃: F^m → F such that:
- f̃ agrees with f on H^m
- Degree in each variable is |H|-1
- F is any finite field containing H
- When H = {0,1}: called multilinear extension (degree 1 in each variable)
- Proof of Extension: f̃(z) = Σ_{h∈H^m} f(h) · ∏ᵢ κₕᵢ(zᵢ) where κₕᵢ are Lagrange interpolation polynomials
- Proof of Uniqueness: By reduction to univariate case using Lagrange interpolation theorem uniqueness
Power and Applications of Low Degree Extension
- Allows going from arbitrary sequence of bits to polynomial with structure
- Low degree polynomials have structure that enables sum check protocols
- Key insight: if cheating, must cheat everywhere (error correcting code property)
- Essential for catching cheating provers in proof systems
Counting Triangles Example
- Graph G with n vertices, want to prove number of triangles = β
- Verifier can only run O(n²) time, can't afford n³ triangle counting
- Define f: {0,1}^{2log n} → {0,1} as adjacency matrix function
- Number of triangles = (1/6) · Σᵢ,ⱼ,ₖ f(i,j)·f(j,k)·f(i,k)
- Use low degree extension f̃, apply sum check protocol
- Verifier runtime: O(n²), Prover runtime: polynomial
- Alternative simpler protocol: send A², A³ matrices and verify using randomized matrix equality
GKR Protocol for Low Depth Circuits
- Goal: Doubly efficient interactive proof for bounded depth circuits
- Circuit C: size s (very large), depth d (small)
- Verifier runtime: O(d · polylog s)
- Prover runtime: poly(s)
- Assumptions:
- Circuit is layered (gates in layer i only connect to layer i+1)
- Log-space uniform circuit representation
- Each layer has exactly s gates (pad with dummy gates)
- Fan-in 2 (addition/multiplication gates only)
GKR Protocol Structure
- D sub-protocols, each reducing claim about layer i to layer i+1
- Step 1: Arithmetization - convert OR/AND to addition/multiplication gates
- Step 2: Prover computes values of all gates in circuit
- Step 3: For each layer i, represent gate values as function Vᵢ: H^m → {0,1} where H^m has size s
Parameter Choices for Extension
- Choice 1: H = {0,1}, m = log s (binary representation)
- Choice 2: H has size log s, m = log s / log log s
- Second choice preferred for later PCP applications
- Field F size must be ≥ m·d for soundness
- For PCP applications, want F = poly(|H|)
GKR Protocol Layer Reduction
- Goal: Reduce claim about Vᵢ(z) to claims about layer i+1
- Express Vᵢ(p) in terms of layer i+1 using circuit structure:
- Vᵢ(p) = Σ_{w₁,w₂} [addᵢ(p,w₁,w₂)·(Vᵢ₊₁(w₁) + Vᵢ₊₁(w₂)) + multᵢ(p,w₁,w₂)·Vᵢ₊₁(w₁)·Vᵢ₊₁(w₂)]·κₚ(z)
- addᵢ, multᵢ: functions indicating gate connections (addition vs multiplication)
- Apply sum check protocol to this expression
- After sum check: verifier needs to compute expression at random point (z₀,z₁,z₂)
Verification Challenges
- Verifier can compute κ function (Lagrange interpolation extension)
- Major issue: Verifier cannot compute ãdd, m̃ult extensions efficiently
- Temporary assumption: Verifier has oracle access to compute ãdd, m̃ult
- Verifier asks prover for Vᵢ₊₁(z₁), Vᵢ₊₁(z₂) values
- If original claim false, prover must provide at least one false value to avoid immediate rejection
- Result: Reduced 1 claim about layer i to 2 claims about layer i+1
Current Protocol Status
- Successfully showed layer-by-layer reduction using sum check + low degree extension
- Key remaining challenge: How verifier computes ãdd, m̃ult without trusted oracle
- Protocol doubles number of claims per layer (exponential blowup issue to be addressed)
