Recursive Proof Composition: Compressing Entire Verification Pipelines into One Proof
A zero-knowledge proof can verify one computation efficiently, but large systems generate many proofs across users, batches, blocks, or application layers. Verifying every proof independently can still create high on-chain cost and slow finalization.
Recursive composition allows a new proof to verify previous proofs. Repeating the process creates a proof tree or rolling proof whose final output attests to a much larger body of computation. This technique supports scalable rollups, proof aggregation, private state machines, and compact cross-system verification.
Verifying Proofs Inside Other Proofs
Recursive proof composition is the construction of a proof circuit that verifies another proof as part of its own computation. The resulting proof can then be verified directly or included in another recursive layer, compressing many verification statements into one succinct result.
Recursion Trade-Offs: Cycles, Latency, and Memory
Recursion requires compatible curves or fields, efficient verifier circuits, careful transcript design, and protection against soundness errors that could propagate through the proof chain. Teams must also manage data availability: a compact recursive proof may confirm correctness without making the underlying transaction data available for recovery or audit.
Architecting Proof Aggregation Pipelines
Neti helps protocol teams select recursion-friendly proof systems, optimize verifier circuits, structure aggregation trees, and integrate recursive proofs into on-chain and off-chain state workflows.
FAQ
Does recursion make proof generation free?
No. It reduces verification and data overhead, but the prover still performs the underlying computations and the recursive verification work.
Why are curve cycles used in recursion?
A curve cycle can make it efficient for a circuit defined over one field to verify proofs built on a compatible curve, enabling repeated recursive layers.
Can recursion hide invalid proofs?
Not if implemented correctly. Each recursive layer verifies the included proofs, but bugs in the verifier circuit or protocol composition can undermine the entire chain.
