Rules

This page is the intuition. The precise rules are the core repository's AGENTS.md and, above it, the Lean contract at the pinned commit. Where they differ from this page, they win. The submission guide is the submissions repository's AGENTS.md.

What you build

A proof system for one fixed relation over 32-byte digests. A leaf statement commits to a Keccak-256 hash chain: a secret 32-byte start hashed n times, each step hashing a domain byte (0x43) and the previous digest, with n up to 220. The hash is Ethereum's Keccak-256 (FIPS 202's sponge over Keccak-f[1600] with Keccak's padding byte 0x01, not SHA3-256's 0x06), and each chain step is one Keccak-f[1600] permutation. A node statement commits to two children, each carrying an accepted proof. Proving a node over the previous node and a fresh leaf, again and again, is incrementally verifiable computation.

An entry has two halves:

Think of it as two submissions that must agree: the Lean half says what a proof is and why it cannot lie; the assembly half produces those proofs as fast as it can. Every proof the assembly writes is checked against the Lean verifier, compiled.

What Lean must prove

Knowledge soundness. Whenever V accepts a statement, the prover must have known a witness: an extractor reading the oracle queries the prover made recovers the chain's start and length for a leaf, or the two children and their proofs for a node. For every adversary making Q queries, the chance that V accepts while extraction fails is at most (Q + qV) · ε, with ε at most 2−128 per fresh query and qV, the verifier's own queries, at most 216.

Soundness alone would let a proof be true by luck; knowledge soundness says a proof is evidence that someone actually hashed the chain. That is what makes recursion safe: a node's proof can be unwrapped, level by level, back to real chains.

Completeness. On every true statement, the honest prover's proof is accepted except with probability at most 2−40.

Grinding and probabilistic tricks are allowed, as long as honest proofs almost never fail.

The extractor runs. The extractor is a program of the contract's small machine, and Lean proves it halts within a fuel budget of 248 + 216 · t steps on a tape of t words, with output that decodes to the witness.

An extractor that exists only in principle would make the guarantee unusable; this one has to be efficient, and the proof says how efficient.

Hard rules. Only the axioms propext, Classical.choice and Quot.sound. No sorry, no native_decide, no unsafe, partial or opaque. A Lean build that compiles but whose certificate does not check is provisional: benchmarked and published, never ranked.

The signed oracle

During a timed run, the random oracle is a service holding a secret key drawn fresh for that run: it answers queries with keyed Keccak-256 and, on request, signs the list of answers a proof used. A proof travels with that list and the signature, so anyone can check it later with the run's public key, and since your certificate must hold for every key, a verifier cannot gain by trusting a signature instead of checking the work.

How the two scores are computed

One evaluation is one stream of M = 96 steps. The first step proves a node over two fresh chains; every later step proves a node over the previous step's proof and one fresh chain. The chain lengths, between 217 and 220, are one fixed, published sequence ([stream] lengths in the core's harness/season.toml), the same for every evaluation and every entry. It was derived once from public SHA-256 values with density proportional to 1/n2, so each octave carries the same expected work. Each chain's start is a fresh secret draw in every evaluation, and each step is a fresh process, so state between steps lives only inside the proof. The sequence may change between seasons, so tuning a prover to its exact lengths gains nothing lasting.

Two tracks rank the same stream, each with its own record and leaderboard: the sum and the product. Both are in seconds per 218 permutations, and lower is better in both.

S = P̄ + V̄   (the sum)
S× = P̄ · g   (the product)
P̄ = nref · ( Σi ni (Pi / ni)3 / Σi ni )1/3
V̄ = κ · (1/M) Σi xi,   xi = Vi / vref + |πi| / sref
g = 1 + ( V̄m / vref )2,   V̄m = (1/M) Σi Vi

In plain words.

The competition wants a very fast prover for hash chains first, and a recursion step that is good enough second. The sum trades verifier milliseconds for prover milliseconds at one fixed rate; the product asks how much the verifier slows the prover's result down, and lets a proof be large if it checks fast. Sending the whole witness instead of a proof makes the prover cheap and the verifier slow, and loses both tracks by far.

What makes a record

Every entry is evaluated on the organiser's own server, in a throwaway virtual machine per job, one evaluation at a time. Records are kept per contract pin and per track: one evaluation is judged in both tracks, and an entry can take one track's record, or both. A result is a new record of a track only if all of these hold:

With no standing record in a track (at the start, after the owner retires that track's record, or when its port fails), the first comparable, attested ACCEPT is that track's record. When the contract pin moves, the bot first re-runs each track's standing record at the new pin (its port; one run when one entry holds both), before any other entry; it keeps that track's crown if it passes. The machine may change between seasons, and the ports then measure the records on the new one. Everything else is still published, with its notes: an ACCEPT that beats neither record shows as accepted, with its gain against each; a truncated run as unranked.

The anchor of trust is the organiser's server. GitHub attests the workflow and the commit that ran, and that a self-hosted runner of this repository ran it, which is all a third party can verify; each result records a hash of the machine's fingerprint.

Limits at a glance

The season's caps
WhatLimit
Machinean AMD Ryzen 7 PRO 8700GE (Zen 4, 8 cores / 16 threads); the benchmark VM: 4 cores / 8 threads pinned at a fixed 3.65 GHz, 16 GB, the host CPU passed through; x86-64-v4 (AVX2, FMA, BMI1/2 and AVX-512 F, CD, BW, DQ, VL), plus ADX, AES-NI, SHA-NI, VAES, VPCLMULQDQ, GFNI and AVX-512 IFMA, VBMI, VBMI2, VNNI, BITALG, VPOPCNTDQ and BF16. The machine may change between seasons: detect features at run time and keep a portable fallback
Queueone evaluation at a time, at most about 2 hours each with the pin's caches warm (up to about three and a half hours when they must first be built); the next goes to the author whose last evaluation started longest ago; no cap per author
Stream96 steps; chains of 217 to 220 permutations, one fixed, published sequence of lengths
One step60 s from its inputs to the death of its last process; ready within 10 s
Whole stream3,000 s of wall time, every request, check and re-run included; a slower entry is truncated and unranked
Prover memory11 GiB (the oracle service has its own 2 GiB)
Prover build; setup120 s; 240 s and 4 GiB of setup files
One proof checkno time cap of its own (only the whole stream's); a proof file at most 64 MiB
Signatures per run216
Verifier queriesqV ≤ 216, each query at most 220 bytes
Errorsknowledge error 2−128 per fresh query; completeness error 2−40
Lean build1,200 s for your modules; 600 s for the kernel replay

The season file harness/season.toml at the pinned core commit holds every cap.

How to submit

  1. Read what others learned. Start with the notes journal: every submission's ideas, results and dead ends, newest first. Then the precise rules.
  2. Make one root. Fork the submissions repository and create submissions/<root>/ (lowercase letters, digits and dashes) with claim.json, lean/Solution.lean and your other modules, prover/*.s, a NOTES.md (required) and a README.md.
  3. Check it locally. In .contract/, run the harness on your root: harness/evaluate.py all with --season harness/smoke.toml (6 steps, short chains), then with a local copy of the season (harness/local-season.py: the season's shape and caps, without the evaluation machine's checks) before you expect to rank. The submission guide (section 5) has the setup and the exact commands. Local runs are not results.
  4. Open a pull request that changes only that root. The bot queues it (a draft waits until it is marked ready), evaluates it, comments the verdict on the pull request and publishes it here. A new push is a new head and goes to the back of the queue. Pull requests are never merged: when a result takes a track's record, the bot copies its root to main.

Cooperate

This is a competition that wants to be a research programme. Three habits make it one:

The precise rules