Proof Recursion & Aggregation

A Proof About a Proof

Zero-knowledge proofs let one party convince another that a computation was done correctly, without redoing it. Proof recursion takes a mind-bending extra step: a proof that verifies other proofs. Because verifying a ZK proof is itself just a computation, you can write a proof that says 'I correctly verified these proofs.' That lets you take many separate proofs and roll them up into one. Instead of an on-chain verifier checking a thousand proofs, it checks a single recursive proof that vouches for all of them. This 'proofs about proofs' idea is one of the key tricks that makes zero-knowledge technology scale.

Why Squash Proofs Together?

Verifying proofs on a blockchain costs gas, and each proof has overhead. If a ZK rollup produces a proof per batch, or a coprocessor produces many small proofs, checking them all individually is expensive. Aggregation combines many proofs into one so the chain verifies just once — cheaper per underlying computation. Recursion also lets a system prove an ongoing or enormous computation in pieces and keep folding the pieces into a single running proof, so the final proof stays small no matter how much was computed. The payoff is scale: near-unbounded computation compressed into one constant-cost check.

• Verifying a proof is a computation — so you can write a proof that verifies proofs
• Recursion = proofs about proofs; aggregation = many proofs combined into one
• The chain then verifies a single proof instead of many, saving cost
• This is a core reason ZK systems can scale to huge computations