A briefing, dated
This lesson is a snapshot of a field that changes month by month, written in November 2026. Every number below has a date and a source, and some of them will be out of date by the time you read this; the habits of mind — ask what was measured, on what hardware, at what security level, and who measured it — will not.
Three shifts define the period since 2023. First, cost collapsed: proving a whole Ethereum block went from an overnight job to a few seconds on a rack of consumer GPUs, so the question moved from "can it be done?" to "can it be done safely and by anyone?". Second, security became the bottleneck: a series of soundness bugs in production systems, and the refutation of conjectures that many systems had used to set their parameters, pushed the community from advertised to provable security and towards formal verification. Third, verifiable computation left the blockchain: zero-knowledge age checks for identity wallets, verifiable machine-learning inference and verifiable databases are now built by organisations that have nothing to do with tokens. The sections below take these in turn, then open problems, then a reading path.
Proving costs and the race to real-time proving
In July 2025 the Ethereum Foundation proposed a concrete target (zkVMs and coprocessors): prove at least 99% of mainnet blocks within 10 seconds, on on-premises hardware costing at most about USD 100,000 and drawing at most 10 kW, with open-source code, at least 128 bits of security, proofs no larger than 300 KiB, and no trusted setup (EF, July 2025). The power limit was chosen so that individuals, not only data centres, could run provers.
Progress against the latency and power targets was fast. By the Foundation's December 2025 summary, proving latency had fallen from about 16 minutes to 16 seconds within a year, costs had fallen about 45-fold, and zkVMs proved 99% of blocks in under 10 seconds on the target hardware. The public dashboard Ethproofs, launched in January 2025, reported in its end-of-2025 review that four teams had reached sub-10-second 99th-percentile latency within the cost and power limits, that most teams' single-GPU proving time had dropped from 16 minutes to under a minute, and that more than 90% of the proving clusters were built from consumer RTX 5090 GPUs. Its 2026 roadmap tightened the latency goal to 8 seconds, standardised on GPU counts as the unit of hardware, and moved from dollar cost to energy per proof.
How did the costs fall so fast? Not through one breakthrough but through the compounding of the ideas in this level: small fields (BabyBear, KoalaBear, Mersenne-31) with extension-field challenges, faster polynomial commitments, lookup- and sumcheck-based arithmetisations, precompiles for Keccak and signature checks, continuations with massive GPU parallelism, and recursion trees tuned to finish within a slot. Remaining costs have shifted: as proving kernels sped up, witness generation (running the program to produce the trace) and data movement became significant fractions of the time, and both are now active engineering targets.
From advertised to provable security
Every hash-based proof system has a soundness analysis with two kinds of term: errors from the random challenges (governed by the field size) and errors from the spot-check queries (governed by the code's rate and the number of queries). The tightest proven bounds for Reed–Solomon proximity hold up to the Johnson radius ; stronger "up to capacity" conjectures would allow fewer queries and smaller fields, and many deployed systems set their parameters by them.
In November 2025 two independent preprints refuted several of these conjectures: Crites and Stewart disproved the correlated-agreement conjecture up to capacity, the mutual correlated agreement conjecture used by WHIR, and a list-decodability conjecture used by DEEP-FRI, and Ben-Sasson, Carmon, Haböck, Kopparty and Saraf proved lower bounds showing that proximity gaps beyond the Johnson radius require better list-decoding bounds than are known. Neither paper attacked a deployed system; they removed the ground under parameter choices. The Ethereum Foundation responded by asking zkVM teams for provable security, measured by a common open-source estimator called soundcalc: integration by February 2026, 100 provable bits and proofs of at most 600 KiB by May 2026, and 128 provable bits with proofs of at most 300 KiB, plus a written security argument for each system's recursion architecture, by early December 2026 (February 2026 update). As of this writing that final milestone is weeks away; check the teams' and Ethproofs' reports for the outcome.
The toy estimator below shows why the change matters. It is deliberately crude — real calculators track many more terms — but it captures the trade-off: under the proven regime each query is worth half as much, and the field must be larger, so the same parameters lose about a third of their bits, and buying them back costs larger proofs or more prover work.
from math import log2
def fri_bits(field_bits, log_domain, rate, queries, grinding, regime):
"""A deliberately simplified estimate of a FRI-based STARK's soundness, in bits.
'conjectured': up-to-capacity proximity gaps (each query worth log2(1/rate) bits, and a
challenge error of about domain/|F|);
'proven': the Johnson-radius regime (each query worth half that, error about domain^2/|F|).
Real calculators (such as the Ethereum Foundation's soundcalc) track many more terms."""
per_query = log2(1 / rate) * (1.0 if regime == "conjectured" else 0.5)
challenge = field_bits - log_domain * (1 if regime == "conjectured" else 2)
return min(challenge, queries * per_query + grinding)
configs = [
("BabyBear^4, rate 1/2, 100 queries", 124, 24, 1 / 2, 100, 16),
("BabyBear^5, rate 1/2, 168 queries", 155, 24, 1 / 2, 168, 16),
("BabyBear^5, rate 1/4, 84 queries", 155, 24, 1 / 4, 84, 16),
]
print(f"{'configuration (domain 2^24, 16 bits of grinding)':48} conjectured proven")
for name, fb, ld, rate, q, gr in configs:
print(f"{name:48} {fri_bits(fb, ld, rate, q, gr, 'conjectured'):8.0f} {fri_bits(fb, ld, rate, q, gr, 'proven'):8.0f}")Fiat–Shamir, in theory and in practice. It has long been known that some contrived protocols are sound interactively but unsound under every concrete hash function. In 2025 Khovratovich, Rothblum and Soukhanov made this practical: they built a circuit for which a GKR-based proof system, compiled with Fiat–Shamir, accepts a false statement whatever hash is used, by exploiting the fact that the hash function itself can be computed inside the circuit being proved (ePrint 2025/118, CRYPTO 2025). Deployed systems are not directly affected, but the result reopened the question of what Fiat–Shamir guarantees for the succinct proofs that now secure real value, and follow-up work proposes mitigations.
Soundness bugs in production systems
The bugs that have actually threatened deployed systems fall into a few classes, and the same classes keep recurring.
| Disclosed | System | What went wrong | Class |
|---|---|---|---|
| 2019 | Zcash (original Sprout circuit) | key generation in the underlying paper produced extra elements that allowed counterfeiting; quietly fixed in 2018, no evidence of exploitation | setup / paper |
| 2019 | circomlib (used by Tornado Cash) | a hash output assigned but not constrained | under-constrained circuit |
| 2022 | Implementations of Girault, Bulletproofs, PlonK ("Frozen Heart") | statement or public inputs missing from the Fiat–Shamir hash | transcript binding |
| 2025 | RISC Zero zkVM 2.0.0–2.0.2 | a missing constraint in the RISC-V circuit let a prover "prove" 7 mod 5 = 0; on-chain verifiers were paused with an emergency stop and the circuit fixed | under-constrained circuit |
| 2025 | Solana ZK ElGamal proof program | components missing from a Fiat–Shamir transcript; patched, program disabled for audit, no known exploitation | transcript binding |
| 2026 | Six zkVMs and proof systems (Jolt, Nexus, Cairo-M, Ceno, Expander, Binius64) | prover-supplied claims not absorbed into the transcript before the challenges that check them; all fixed before disclosure | transcript binding |
| 2026 | SP1 version 6 | a binding gap in the recursion circuit's row counts (advisory); fixed | recursion / binding |
Two lessons stand out. First, almost none of these broke a cryptographic assumption; they were missing constraints and missing transcript inputs, the bugs of Arithmetisation and SNARKs and Zero knowledge, appearing again at scale. Second, ordinary testing does not find them, because tests use honest provers. The responses are adversarial: bug bounties (several of the above were bounty reports), fuzzers that run the same program on many zkVMs or mutate traces to look for disagreements, such as ARGUZZ (USENIX Security 2026) and zkSecurity's zkvmBlast (2026), and formal verification.
Formal verification of circuits and zkVMs
A proof system's soundness theorem is a mathematical statement; a circuit's correctness ("these constraints are satisfied exactly by the traces of RV32IM executions") is another. Both can be machine-checked. The Ethereum Foundation's Verified zkEVM project, with a budget the Foundation has described as USD 20 million over three years, funds work in three tracks; its site lists 42 grants as of 2026. Much of it is in Lean 4 (see formalising mathematics in Lean): ArkLib formalises interactive oracle proofs and their compilation into arguments, a companion library gives computable polynomials, and projects extract Rust implementations of primitives into Lean to prove them equal to their specifications, increasingly with AI theorem provers doing part of the work. Other efforts verify circuits directly: tools that prove a circuit's outputs are uniquely determined by its inputs (Veridise's Picus), and embedded languages in which circuits are written together with their specifications.
Two gaps remain prominent. Verification has so far concentrated on soundness; completeness bugs — valid executions that cannot be proved, which on an L1 would stall the chain — have been found by fuzzing in several zkVMs. And the end-to-end chain, from Rust source through compiler, zkVM circuit, proof system, recursion and on-chain verifier, is verified nowhere in full; each link is a separate project.
Post-quantum signatures and proofs
NIST's first post-quantum standards appeared in August 2024 (FIPS 203 for key establishment, FIPS 204 and 205 for lattice-based and hash-based signatures, as in Signatures and keys); HQC was selected as a backup key-establishment scheme in March 2025, and the Falcon-based FN-DSA (FIPS 206) was still in draft in 2026 (NIST PQC). For blockchains the hard part is signatures: every node stores and checks every one, and post-quantum signatures are roughly 10 to over 100 times larger than Ed25519's 64 bytes. Hash-based signatures rest on the most conservative assumption of all. The oldest is Lamport's one-time scheme (1979), which fits in a few lines and shows both their appeal and their cost:
import hashlib
import random
H = lambda b: hashlib.sha256(b).digest()
rng = random.Random(2026) # seeded for the demo; real keys need a secure RNG
# Lamport one-time signatures (1979): security rests only on the hash function.
sk = [[rng.randbytes(32), rng.randbytes(32)] for _ in range(256)] # two secrets per digest bit
pk = [[H(a), H(b)] for a, b in sk]
def bits(msg):
d = int.from_bytes(H(msg), "big")
return [(d >> (255 - i)) & 1 for i in range(256)]
def sign(msg):
return [sk[i][b] for i, b in enumerate(bits(msg))] # reveal one secret per bit
def verify(msg, sig):
return all(H(s) == pk[i][b] for i, (s, b) in enumerate(zip(sig, bits(msg))))
s = sign(b"pay Amina 5")
print("valid:", verify(b"pay Amina 5", s), " same signature on another message:", verify(b"pay Kenji 7", s))
print("public key", 2 * 256 * 32, "bytes, signature", 256 * 32, "bytes (Ed25519: 32 and 64)")
# One-time means ONE time. Each extra signature reveals the other secret at about half of the
# remaining positions; a forger then needs a message whose digest matches only the positions
# where a single secret is known, which takes about 2^(that number) hash evaluations.
revealed = set()
for k, msg in enumerate([b"pay Amina 5", b"pay Kenji 7", b"pay Lars 2", b"pay Noor 9", b"pay Thandi 4"], 1):
revealed |= {(i, b) for i, b in enumerate(bits(msg))}
pinned = sum(1 for i in range(256) if ((i, 0) in revealed) != ((i, 1) in revealed))
print(f"after {k} signature{'s' if k > 1 else ' '}: forging takes about 2^{pinned} hash evaluations")Practical schemes build many-time signatures from one-time ones with Merkle trees: XMSS (stateful: the signer must never reuse a leaf) and SLH-DSA (stateless, larger). Ethereum's post-quantum plan, as described on pq.ethereum.org (updated June 2026), replaces validators' BLS signatures with a hash-based XMSS variant and — because hash-based signatures cannot be added together the way BLS signatures can — aggregates thousands of them with a SNARK produced by a minimal, hash-based zkVM. Verifiable computation thus becomes part of the consensus layer itself. The team's own estimate is that the protocol upgrades could be completed around 2029, with users' accounts migrating over years through account abstraction.
For proofs, hash-based systems (FRI, and its successors STIR and WHIR) are the plausibly post-quantum workhorses, with the caveats of STARKs and folding. Lattice-based proof systems and folding schemes (LaBRADOR, Greyhound, LatticeFold, Neo and others) aim at smaller proofs or efficient recursion with post-quantum assumptions; as of 2026 they are an active research area with early implementations. A system is only as post-quantum as its weakest component, and many deployed pipelines still end in a pairing-based Groth16 wrapper for cheap verification on Ethereum.
Hardware: NTT and MSM
Two kernels dominate classical proving. The multi-scalar multiplication (MSM), over millions of elliptic-curve points, dominates pairing-based provers and KZG commitments; the best algorithms (Pippenger's bucket method) make it roughly linear with a modest logarithmic saving. The number-theoretic transform (NTT), the fast Fourier transform over a finite field, converts between a polynomial's coefficients and its values on a subgroup of roots of unity, and dominates FRI-based provers: low-degree extension, quotient computation and folding all go through it (see Fourier analysis). The NTT is built from one repeated step, the butterfly, which is exactly the even/odd split of FRI run in reverse: from and it produces and with one multiplication.
The program implements a radix-2 NTT over BabyBear and multiplies polynomials both ways, counting field multiplications.
import random
import time
p = 15 * 2**27 + 1 # BabyBear: 2013265921, with 2^27 dividing p - 1
g = 31 # a generator of the multiplicative group of F_p
mults = 0 # instrumentation: count field multiplications
def ntt(a, invert=False):
"""Iterative radix-2 number-theoretic transform (an FFT over F_p). len(a) is a power of 2."""
global mults
a, n = list(a), len(a)
j = 0
for i in range(1, n): # bit-reversal permutation
bit = n >> 1
while j & bit:
j ^= bit
bit >>= 1
j |= bit
if i < j:
a[i], a[j] = a[j], a[i]
length = 2
while length <= n:
w_len = pow(g, (p - 1) // length, p) # a primitive length-th root of unity
if invert:
w_len = pow(w_len, -1, p)
for start in range(0, n, length):
w = 1
for k in range(length // 2): # one butterfly (plus the twiddle update)
u, v = a[start + k], a[start + k + length // 2] * w % p
a[start + k], a[start + k + length // 2] = (u + v) % p, (u - v) % p
w = w * w_len % p
mults += 2
length *= 2
if invert:
n_inv = pow(n, -1, p)
a = [x * n_inv % p for x in a]
mults += n
return a
def multiply_ntt(f, h):
global mults
size = 1
while size < len(f) + len(h) - 1:
size *= 2
F, Hh = ntt(f + [0] * (size - len(f))), ntt(h + [0] * (size - len(h)))
mults += size
return ntt([x * y % p for x, y in zip(F, Hh)], invert=True)[:len(f) + len(h) - 1]
def multiply_naive(f, h):
global mults
out = [0] * (len(f) + len(h) - 1)
for i, x in enumerate(f):
for j, y in enumerate(h):
out[i + j] = (out[i + j] + x * y) % p
mults += len(f) * len(h)
return out
rng = random.Random(0)
print(" n naive mults NTT mults ratio naive s NTT s same result")
for n in [64, 256, 1024, 2048]:
f = [rng.randrange(p) for _ in range(n)]
h = [rng.randrange(p) for _ in range(n)]
mults = 0; t0 = time.perf_counter(); A = multiply_naive(f, h); t1 = time.perf_counter(); m1 = mults
mults = 0; t2 = time.perf_counter(); B = multiply_ntt(f, h); t3 = time.perf_counter(); m2 = mults
print(f"{n:5} {m1:13,} {m2:11,} {m1 / m2:7.1f} {t1 - t0:9.3f} {t3 - t2:8.3f} {A == B}")The schoolbook method costs multiplications; the NTT route costs three transforms of size , each about multiplications as counted here, plus more. The ratio grows like : about 27 at , and by the same count roughly 8,000 at and over 100,000 at , the sizes real provers use. Your timings will differ from run to run and machine to machine, but the trend in the time columns follows the counts.
Both kernels are regular, parallel and memory-bound, so GPUs dominate in 2026: open-source GPU libraries such as Ingonyama's ICICLE provide them, and the ZPrize competitions of 2022 and 2023 drove MSM and NTT speed-ups on GPUs and FPGAs. FPGA and ASIC accelerators exist in research (several academic ASIC designs report large speed-ups over GPUs for NTT and MSM) and as commercial efforts, but in public benchmarks of 2025–2026 the fastest provers were built from commodity GPUs. Specialised hardware faces a moving target: proof systems change every year, and an ASIC fixed to one field or curve can be obsoleted by a new arithmetisation.
Standardisation
Standards lag research here, deliberately. ZKProof, a community initiative since 2018, maintains a Community Reference document and runs workshops on terminology, security definitions and implementation guidance. At the IRTF's Crypto Forum Research Group, drafts specify the BBS signature scheme for selective disclosure, interactive Σ-protocols and the Fiat–Shamir transformation, the latter two directly targeting the transcript-binding bugs above. NIST's Multi-Party Threshold Cryptography project published its first call for threshold schemes (NIST IR 8214C) in January 2026; besides threshold signatures and encryption, its scope includes zero-knowledge proofs as a building block, which puts ZK on NIST's path to reference specifications for the first time. Identity is driving standards from another direction: W3C's Verifiable Credentials data model, ISO's mobile driving licence formats, and the European digital identity wallet framework have all had to decide how selective disclosure and zero-knowledge proofs fit in.
Beyond blockchains
- Outsourced computation, the original motivation of interactive proofs: a client checks that a cloud provider ran its job correctly. Proving overhead long made this uneconomic except for high-value results; falling costs are bringing it within reach for audit trails, scientific computation and regulated reporting.
- Identity. Age verification and selective disclosure from government-issued credentials, such as Google's open-source Longfellow ZK used with European age-assurance pilots (Zero knowledge), are the largest deployments outside blockchains so far.
- Verifiable machine learning. Proofs that a specific model produced an output, or that a model's weights match a committed version (zkVMs and coprocessors), with costs still orders of magnitude above inference.
- Verifiable data. Proofs that a query over a committed database returned the right answer, and proofs of solvency in which an exchange proves that its liabilities to customers are covered without revealing individual balances.
- Provenance and elections. Research prototypes prove that a published photograph is an allowed edit of a camera-signed original, and end-to-end verifiable voting systems such as Helios use zero-knowledge proofs of ballot validity — where, as the 2012 analysis of weak Fiat–Shamir showed, the details matter.
Open problems
- Provable soundness at practical cost. Close the gap between proven and conjectured proximity bounds for Reed–Solomon and related codes, or design protocols that do not need the conjectures.
- Fiat–Shamir. Understand which succinct proofs remain sound under concrete hash functions, and design transcripts (and hash functions) that resist attacks of the 2025 kind.
- Small, fast, post-quantum proofs. Hash-based proofs are large; lattice-based ones are young. A post-quantum proof as small and cheap to verify as Groth16 does not exist.
- Prover memory and streaming. Proving a long computation without holding its whole trace in memory, ideally on a single consumer device.
- End-to-end verification. A machine-checked chain from high-level program to on-chain verifier, including compilers, recursion and completeness.
- Private proving. Users want proofs about private data but lack the hardware to prove; delegating the proof leaks the witness. Combining ZK with multi-party computation or homomorphic encryption ("collaborative" or "private delegated" proving) is promising and expensive.
- Decentralised proving. Prover networks must guarantee liveness — someone will produce the proof in time — without concentrating proving in a few operators.
- Lower bounds. How much overhead must a prover pay relative to native computation? Theory gives few answers.
How to get started in the field
A path that works for many people:
- Read Justin Thaler's Proofs, Arguments, and Zero-Knowledge, free online; the lessons of this level follow its arc. Keep the Zero Knowledge Proofs MOOC (Berkeley RDI, with lecturers from several universities) alongside for lectures and exercises.
- Watch the ZK Whiteboard Sessions from ZK Hack: short, technical explanations of SNARKs, PLONK, lookups and FRI by people who build them.
- Break things. ZK Hack runs puzzle competitions in which you exploit a planted bug in a proof system; 0xPARC's zk-bug-tracker is a catalogue of real ones. Breaking teaches soundness faster than building.
- Build something small with a real library: a circuit in Circom or Noir, a STARK with Plonky3, a guest program in a RISC-V zkVM. Then write a negative test that tries to prove something false.
- Follow the research on the IACR Cryptology ePrint Archive, where nearly every paper in this level first appeared, and the ZKProof workshops; follow production through Ethproofs and the teams' security advisories.
The field rewards people who combine mathematics, systems engineering and an adversarial mindset; it is also small enough that careful newcomers who find a real bug or write a clear explanation are noticed.
Exercises
1. The frontier of verifiable computation
Warm-upHumanTwo teams each announce that they "prove Ethereum blocks in real time". Which facts do you need before you can compare the two claims? Select all that apply.
2. The frontier of verifiable computation
CoreHumanCount field multiplications as the lesson's program does: an NTT of size costs multiplications (two per butterfly, butterflies per stage, stages); multiplying two polynomials with coefficients uses three transforms of size , plus pointwise products and multiplications for the final scaling. How many multiplications does this cost for ?
3. The frontier of verifiable computation
CoreHumanA Lamport one-time signature scheme uses SHA-384: messages are hashed to 384-bit digests, and each secret value is 48 bytes long. How many bytes long is a signature?
4. The frontier of verifiable computation
CoreHumanIn late 2025, preprints refuted several "up to capacity" proximity-gap conjectures for Reed–Solomon codes. What was the most direct consequence for FRI- and WHIR-based systems that had set their parameters using those conjectures?
5. The frontier of verifiable computation
CoreHumanWhich of these production soundness bugs were caused by missing constraints or missing transcript inputs, rather than by breaking a cryptographic assumption? Select all that apply.
6. The frontier of verifiable computation
CoreComputationalGrinding adds security bits to a proof cheaply: before the query positions are derived, the prover must find a nonce that makes a hash of the transcript start with zero bits, which costs about hash evaluations, so a cheating prover who wants to retry with fresh queries pays times more per attempt.
Write grind(transcript, bits) that returns the smallest nonce such that SHA-256(transcript + n.to_bytes(8, "big")) starts with at least bits zero bits.
7. The frontier of verifiable computation
StretchComputationalWrite the recursive radix-2 NTT. ntt(a, w, p) receives the coefficients a of a polynomial (lowest degree first; len(a) a power of two, ), an element w of multiplicative order modulo the prime p, and returns the values modulo p.
Split , evaluate and recursively at the powers of , and combine with butterflies. The tests compare with the definition and time a transform of points.
Further reading and resources
- Proofs, Arguments, and Zero-Knowledge · Justin ThalerThe best single book for entering the field.
- Shipping an L1 zkEVM #1: realtime proving · Ethereum Foundation · 2025
- Shipping an L1 zkEVM #2: the security foundations · Ethereum Foundation · 2025
- zkEVM security sprint: February update · Ethereum Foundation cryptography research · 2026
- Ethproofs 2025 review and 2026 roadmap for real-time proving · 2025
- On Reed–Solomon proximity gaps conjectures · Elizabeth Crites and Alistair Stewart · 2025
- On proximity gaps for Reed–Solomon codes · Eli Ben-Sasson, Dan Carmon, Ulrich Haböck, Swastik Kopparty and Shubhangi Saraf · 2025
- How to prove false statements: practical attacks on Fiat–Shamir · Dmitry Khovratovich, Ron D. Rothblum and Lev Soukhanov · 2025
- Unfaithful claims: breaking 6 zkVMs · OtterSec · 2026
- Verified zkEVM project · Ethereum Foundation
- ArkLibA Lean 4 library of formally verified interactive oracle proofs and arguments.
- Post-quantum Ethereum · Ethereum Foundation
- NIST Post-Quantum Cryptography project
- NIST IR 8214C: First call for multi-party threshold schemes · 2026
- ZKProof Community Reference
- ZK Whiteboard Sessions · ZK Hack
- Zero Knowledge Proofs MOOC · Berkeley RDI
- Cryptology ePrint Archive · IACR