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)

TwinMind

Get summaries like this for your own meetings

TwinMind takes notes in the background during meetings, lectures, and calls, then writes the summary for you.

Free plan to get started

No bot joins your calls

Phone, desktop & Chrome apps

Your next meeting, summarized like this

TwinMind listens in the background and turns meetings, lectures, and calls into searchable notes you can chat with. Start free.

Available on phone, desktop & Chrome

Your next meeting, summarized like this

TwinMind listens in the background and turns meetings, lectures, and calls into searchable notes you can chat with. Start free.

Available on phone, desktop & Chrome

Your next meeting, summarized like this

TwinMind listens in the background and turns meetings, lectures, and calls into searchable notes you can chat with. Start free.

Available on phone, desktop & Chrome