The problem.
Interactive proof systems are easy to nod along to in a paper and hard to get right in code. Every sentence a paper skips, such as how variables are indexed, how layers connect and how challenges are derived, becomes a bug when you implement it. I wanted to understand these protocols well enough to build them, not just use them through someone else's library.
The approach.
Start from the smallest piece and build up. Sumcheck is the core: it reduces a claim about a sum over a hypercube to a single evaluation. GKR layers those reductions across a circuit. KZG commits to polynomials so a verifier can check evaluations succinctly. Fiat–Shamir turns the interaction into a non-interactive proof by deriving the verifier's challenges from a transcript.
The process.
Implemented polynomial representations and evaluation arithmetic in Rust from first principles.
Engineered the Sumcheck prover and verifier, then layered GKR on top with verification routines checking circuit layer outputs against evaluations and random challenges.
Found and corrected a critical bit-indexing bug in the KZG trusted setup: it used least-significant-bit indexing where the protocol layout needs most-significant-bit format. Tests pass after the change.
Added a Criterion benchmark harness so performance work is measured, not guessed. Published numbers will follow once the methodology is documented.
The screens.
The outcome.
“Implementation is the real test of understanding. The bugs were never in the maths I had memorised; they were in the details the paper leaves implicit. It is also an honest picture of where I am: this is a work in progress, not a production library, and I would rather show that than overstate it.”