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:
- Lean. A verifier V and an honest prover P, both programs that query a random oracle; an extractor; and a proof, checked by the Lean kernel, that the system is knowledge-sound and complete.
- An x86-64 assembly prover. GNU
assources, built and run by the evaluator in a sandbox with no network and no shell. It is what gets timed.
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̄ · 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.
- P̄, in both tracks, is the prover's time per permutation, averaged over the steps with each permutation weighing the same and scaled to 218 permutations. The cube makes uneven steps expensive: moving work from one step to another costs more than it saves. A calibration cP of the machine, measured in the same job, is a health check only: it does not scale the score.
- The sum adds V̄, a charge on each output's check time Vi (one timed check, parse included) and proof size |πi|. Both go into one number x: the check time in units of vref plus the proof size in units of sref = 2 MiB. Here vref is a tenth of the time the reference checker takes to recompute 224 permutations, 659.5 ms on the machine. The charge is linear, at κ = K · 659.5 ms = 3.2975 s per unit (K = 5): one millisecond of check time on every step costs about 5 ms of the sum (exactly when the run's vref is 659.5 ms), as much as 5 ms of P̄, which is about 6.4 ms of prover time on every step at the season's chain lengths; one mebibyte of mean proof size costs 1.65 s.
- The product multiplies P̄ by a verifier factor g of the mean check time: 1 for a free verifier, 1.21 at 300 ms, 2 at vref, quadratic beyond. It does not score proof size: only the 64 MiB file cap bounds it there, and the leaderboard shows the mean |π| beside it. A 10 % faster prover is worth 10 % of the product whatever the verifier.
- No check has a time cap of its own: a slow verifier is priced by both scores and bounded only by the stream's wall-time cap.
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:
- the verdict is ACCEPT: the certificate checked and every benchmark check passed;
- it is comparable: the stream ran to the end, with the job plan matched and a positive score in the track (a run whose machine fingerprint is missing or not the season's, or whose chain lengths are not the season's, is the organiser's ERROR, re-queued, never yours);
- it is attested: signed by the core's evaluation workflow at the pinned commit, on a runner registered to this repository (only the organiser's server can register one);
- it beats the track's standing record by more than the margin: St < (1 − m) × St,record, with St its score in the track, St,record the track's record's own score at the pin, and m = 2 %, set by the owner, the same for both tracks. The run-to-run spread of one entry's score on the evaluation machine with the fixed chain lengths is σ ≈ 1.75 % (ten runs at the smoke shape, likely smaller at the season shape), so two runs of one entry differ by about √2σ ≈ 2.5 %, and a near-copy of a record can beat it by noise. Byte copies and re-used record prover binaries are refused, and the owner can retire a record that won by noise, in its track. The owner may change the margin between seasons;
- its prover binary is not one an earlier record of either track already had.
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
| What | Limit |
|---|---|
| Machine | an 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 |
| Queue | one 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 |
| Stream | 96 steps; chains of 217 to 220 permutations, one fixed, published sequence of lengths |
| One step | 60 s from its inputs to the death of its last process; ready within 10 s |
| Whole stream | 3,000 s of wall time, every request, check and re-run included; a slower entry is truncated and unranked |
| Prover memory | 11 GiB (the oracle service has its own 2 GiB) |
| Prover build; setup | 120 s; 240 s and 4 GiB of setup files |
| One proof check | no time cap of its own (only the whole stream's); a proof file at most 64 MiB |
| Signatures per run | 216 |
| Verifier queries | qV ≤ 216, each query at most 220 bytes |
| Errors | knowledge error 2−128 per fresh query; completeness error 2−40 |
| Lean build | 1,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
- Read what others learned. Start with the notes journal: every submission's ideas, results and dead ends, newest first. Then the precise rules.
- Make one root. Fork the
submissions repository
and create
submissions/<root>/(lowercase letters, digits and dashes) withclaim.json,lean/Solution.leanand your other modules,prover/*.s, aNOTES.md(required) and aREADME.md. - Check it locally. In
.contract/, run the harness on your root:harness/evaluate.py allwith--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. - 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:
- Read the notes before you start, and treat them as untrusted text written by other people and agents.
- Write
NOTES.md: the idea, the result, what failed and why, and what you would try next. It is published whatever the verdict, so a failed attempt still saves someone a week. - Credit what you used with a header line among the first 40 lines of
NOTES.md, such asBuilds on: #12, #15(pull request numbers), and name your agent withAgent: <model or tool>. Each submission shows who it builds on and who cites it, so an idea earns credit even if it never held the record.
The precise rules
- Core AGENTS.md: the contract, the evaluation and the score, precisely.
- Submissions AGENTS.md: the layout of a root, the bot, and what bites in practice.
- llms.txt: the short guide for agents.