Open research races. Measured, not self-reported.

Staging · activation pending

64%

below the baseline · 3.59M vs 9.98M

The cheapest controlled qubitized walk step for FeMoco. The active space of Reiher et al. 2017.

Each dot is a validated circuit, by the date it was first measured. The green line is the track's best score so far, the orange line the baseline. Lower is better.

The molecule that turns air into fertiliser, and that no computer can yet solve

FeMoco is the benchmark people reach for when they ask what a quantum computer would be for. This challenge asks how cheaply its simulation can be made to run. Move the pointer over the drawings.

fig. 1 · the cofactor

01 · The molecule

Nature makes fertiliser at room temperature

Every plant needs nitrogen it can use, and the nitrogen in air is locked in one of the strongest bonds in chemistry. Industry breaks it with the Haber–Bosch process, at hundreds of degrees and hundreds of atmospheres, using an estimated one to two percent of the world's energy. Bacteria do the same job in soil, at room temperature, with an enzyme called nitrogenase.

The reaction happens at FeMoco, the iron–molybdenum cofactor at the enzyme's core: seven iron atoms, one molybdenum, nine sulfur and a single carbon in the middle. How it works is still argued over. Its electrons are too strongly entangled for classical computers to resolve the small energy differences that separate one proposed mechanism from another.

fig. 2 · the register

02 · The encoding

Each orbital becomes two qubits

A quantum computer holds the cluster's electrons directly. The model keeps the orbitals where the chemistry happens, the active space. Each orbital can hold one spin-up and one spin-down electron, so each becomes a pair of qubits.

The two tracks are two published active spaces: 54 orbitals (108 qubits) from Reiher et al., and 76 orbitals (152 qubits) from Li et al. Every qubit a circuit uses beyond those is workspace, and workspace is where designs differ.

fig. 3 · one logical qubit

03 · The cost

Why qubits and Toffolis are what count

Physical qubits make errors constantly. A useful machine spreads each logical qubit over a patch of many physical ones and keeps measuring checks between them, which reveal an error without reading the data. Each logical qubit in a circuit therefore costs on the order of a thousand physical qubits.

Most gates are cheap on such a machine. The Toffoli gate is not: each one consumes specially prepared states that take most of the machine's time to make. So the qubit count sets how large the computer must be, and the Toffoli count sets how long it must run.

fig. 4 · the trade-off

04 · The score

One walk step, measured as Toffolis × qubits

The energy is read out by quantum phase estimation, which repeats one operation, the walk step, many thousands of times. The challenge measures that one step: its Toffolis and its peak qubits. The score is their product, the area of the slab's long face, and lower is better.

Qubits can be traded for Toffolis and back, which is why the board is ranked by architecture and keeps the whole front, not one winner. The dashed outline is the baseline, the construction of Low et al. (2025), at 9,600 Toffolis on 1,040 qubits. The best circuit on this track runs at 11,463 on 313, a score of 3.59M, 64% below it.

What the walk step does to its qubits, one gate at a time

The circuits on this board all build the same thing: one controlled step of a qubitized quantum walk for FeMoco's Hamiltonian. Phase estimation repeats that step many times to read out the molecule's ground-state energy. Here is the step drawn as its wires, with the qubits changing as each gate acts on them.

01 · The Hamiltonian

An energy operator made of many small terms

A molecule's Hamiltonian is the rule that gives the energy of any arrangement of its electrons: how they move between orbitals, and how strongly they repel one another. Its lowest possible value, the ground-state energy, is what the chemistry needs.

On a quantum computer the Hamiltonian is written as a weighted sum of simple pieces, each one an operation on the 108 qubits with a number in front of it. FeMoco has a very large number of such terms. Their total size, the sum of the absolute values of the coefficients, is called λ (lambda), and it sets the scale of everything below. Factorized forms of the Hamiltonian, such as double factorization or tensor hypercontraction, compress the terms into tables of numbers that the circuit looks up as it runs.

Fig 5One walk step

Hover a gate · ← →

01 · PREPARE
Loads the index register into a superposition over the Hamiltonian's terms, each weighted by the square root of its coefficient's size. The weights are read from a table, the QROM, one entry at a time.
Qubits
Index register, plus the QROM's output register that holds the looked-up data.
Toffolis
The most. A table lookup costs about one Toffoli per entry, and FeMoco's tables are large.
02 · SELECT
Reads the index and applies the matching term to the 108 system qubits. Every branch of the superposition gets its own term at once.
Qubits
The 108-qubit system register, plus the index and a little control workspace.
Toffolis
A share that grows with the number of terms it must step through, and with the system size.
03 · PREPARE†
Runs PREPARE backwards. The index register and the looked-up data go back to all zeros, so the workspace can be reused.
Qubits
Frees the QROM output register again: peak qubits are reached between PREPARE and here.
Toffolis
Fewer than PREPARE: a lookup can be erased by measuring it and fixing phases, at roughly the square root of its cost.
04 · REFLECT
Flips the sign of every index state except all-zeros. This one reflection turns the block encoding into the walk, whose phases encode the energies.
Qubits
Only the index register, and a qubit or two of workspace.
Toffolis
Very few: about one per index qubit.

Each rail is a wire and the puck at its start is that qubit's state now: hollow for 0, filled for 1, grey in superposition. From the back: the 3-qubit index register with its amplitudes as bars beside it, the lookup's output register (QROM out, live only between PREPARE and PREPARE†), 8 of the 108 system qubits, and the phase-estimation control qubit (PE). Green marks whatever the current gate is changing. SELECT is shown one branch of the index at a time, as its unary iteration visits them. The table is a toy of six terms and 27 chips: the stacks show the order of the costs, not FeMoco's counts, whose tables are far larger.

02 · The block encoding

Putting a Hamiltonian inside a circuit

A quantum circuit can only apply reversible, length-preserving operations, and a Hamiltonian is neither. The trick is a block encoding: add a few extra qubits, the index register, and build a circuit that acts like H/λ on the system whenever the index starts and ends at zero.

PREPARE, SELECT and PREPARE† are that circuit. PREPARE spreads the index over every term in proportion to its weight, SELECT applies whichever term the index names, and PREPARE† gathers the index back. The part of the result where the index has returned to zero is exactly the weighted sum of all the terms, the Hamiltonian, divided by λ.

03 · The walk

One reflection turns it into a walk

Repeating a block encoding does not by itself give anything clean to measure: the index drifts away from zero. Adding a reflection about the all-zero index state fixes that. With it, the four gates make a walk operator W that, for each energy E of the molecule, acts as a rotation by the angle arccos(E/λ). This is qubitization. No approximation is involved; the energies are written into W exactly.

Quantum phase estimation then reads those phases out. It applies W over and over, each application controlled by a qubit in a phase register, and the phase register ends up holding the binary digits of arccos(E/λ). That is why the scored circuit is a controlled walk step: the PE wire at the back of the drawing.

04 · The cost

A cheaper step makes the whole calculation cheaper

To pin the energy down to an accuracy ε, phase estimation needs on the order of λ/ε applications of W. Chemical accuracy for FeMoco means that number is very large, so the step is repeated many times and its cost multiplies straight into the total.

The total Toffoli count is therefore the number of steps times the Toffolis per step, and the machine must hold the step's peak qubits the whole time. Making one step cheaper, in Toffolis or in qubits, makes the entire energy calculation cheaper by the same factor. The two can be traded: a lookup reads several entries at once if it is given more output qubits, cutting Toffolis while adding qubits. The score, Toffolis × qubits, prices exactly that trade.

05 · Inside the boxes

What PREPARE, SELECT and PREPARE† are made of

Each block in the walk step is itself a small circuit. PREPARE uses coherent alias sampling: spread the index evenly, look up a keep threshold and an alternative for each entry, compare the threshold with a random register, and swap in the alternative where the test says so. SELECT steps through the index values with a chain of Toffolis, applying each term's Pauli string as it goes. PREPARE† undoes PREPARE, but erases the lookup by measurement, which costs far less.

The drawing is toy-sized: six entries, a 3-qubit index, 2-bit thresholds. FeMoco's circuits use tensor-hypercontraction or double-factorized versions of the same idea, with far larger tables, which is why the lookup dominates the Toffoli count.

Fig 6 · inside

Everything starts at |0⟩. PREPARE uses coherent alias sampling.

State inspector

What an exact simulator shows. A real device never lets you look.

start: one row, every register 0

index	alt	keep	σ	flag	amplitude	prob.
0	0	0	0	0	+1.000	100.0%

P(index = l) · target outline

Dashed: wₗ/λ from the table. Green: the simulated state now.

Toffolis 0 / 11

uniform 1lookup 5compare 2swap 3

step 1 of 11

Discussions

Start a thread

Discussions couldn't be loaded here. Read them on GitHub.

Pull requests

All PRs

Track: reiher
Spec: reiher-sa-est-v1
Epoch: femoco-sa-rigorous-v2
Screen: reference · 4,096 lanes
Full run: sliced · 524,288 lanes
Ledger at: 6272eded

The task

54 orbitals, 108 spin orbitals

FeMoco is the standard benchmark molecule of fault-tolerant quantum chemistry. Phase estimation repeats one walk step tens of thousands of times, so the cost of that step sets the cost of the computation. The challenge fixes the Hamiltonian, the encoding and the error model, and asks for the best circuit.

Estimated tracks retain Low et al.'s estimated coefficient rule. Rigorous tracks use the exact 0.1 mHa coefficient 1-norm rule on the stored Hamiltonian and additionally require deterministic term-pair and alias-boundary coverage. Neither rule is a proof of all-input quantum equivalence or a new bound on the original chemistry/rotation approximation.

Two levels of search

Architecture first

01 Architecture
How the circuit delivers rotation angles: the primary unit of search. Each architecture keeps its own best circuit.
02 Circuit
One point within an architecture: its levers, widths and schedules.

5 architectures are registered. A submission declares one; a new one is reviewed before it is recorded.

Scoring

Lower is better

score = toffoli x qubits

Toffolis per walk stepExecuted CCX and CCZ plus the charge of each Givens rotation, averaged over the sampled lanes.
Peak logical qubitsHigh-water mark of live qubits, system register included.

Recorded if valid and it is the first circuit of its architecture, or beats that architecture's best score by the margin, or has fewer Toffolis by the margin than every recorded circuit with at most as many qubits. The margin is 0.1%.

Baseline

A ledger row, like any other

9,600 Toffolis × 1,040 qubits = 9,984,000

The construction of Low et al. 2025, the research frontier for FeMoco, built with its published parameters and validated by the same evaluator as every other circuit.

Published point

Context, not a ledger row

Low et al. 2025, spectrum amplification: 10,203 Toffolis × 1,132 qubits
G. H. Low, R. King, D. W. Berry, Q. Han, A. E. DePrince III, A. F. White, R. Babbush, R. D. Somma, N. C. Rubin, Phys. Rev. X 15, 041016 (2025), Table V

Published points use Low et al.'s cost model: 4 Toffolis more per executed Givens rotation than this harness charges, and a printed register-rule qubit count instead of a measured peak. `toffoliHarnessEquivalent` removes the Givens difference so the Toffoli count can be read against ledger rows; qubit counts are indicative only.

Judging

5 of 11 activation gates

The judge is the repository's CI. A submission's builder runs in a sandbox; the evaluator comes from the main branch and samples lanes from a seed the submitter cannot know. A valid circuit that earns a standing is merged and recorded by a bot.

Activation gates

Trusted evaluator with byte-identity pins of the recorded circuitsdonechallenges/femoco/tests/sa_digests.rs: 266 of 267 circuits pinned; the li baseline is reproduced by its manifest
Starting board re-validated by the judge pipeline with ledger-key seedsdonechallenges/femoco/results.tsv (kind = historical): 267 circuits validated with ledger-key seeds
Starting-board manifests rebuild their circuits byte for bytepartialchallenges/femoco/tools/verify_submissions.py: 52 of 267 rebuilt from the manifest alone (the ten best of each track, both baselines and every builder and knob shape), no mismatch
Judge workflow: sandboxed build, trusted evaluation, signed ledger rowsdone.github/workflows/judge.yml, spec/VALIDATION.md
Prebuilt evaluator release bound to the verifier digestdonechallenges/femoco/evaluator.lock.json; release femoco-evaluator-077abe9f1a5c24db
Recorded circuits reproduce their ledger rows on hosted runnersdone.github/workflows/revalidate.yml on the best circuit of each track
Headline rows re-validated on the reference engine at 524,288 lanespendingspec/ROADMAP.md
Symbolic certificate, with its statement of what is proved, for the final candidate of each trackpendingspec/VALIDATION.md (final candidates); one candidate certified so far: challenges/femoco/rigorous/exact-reiher-fewest-toffoli.json
Independent audit of the sliced enginependingchallenges/femoco/spec/FAST-EVALUATOR.md
Validation that bounds the energy error: a reflection by construction or a whole-domain symbolic check, and stratified measurement outcomespendingchallenges/femoco/spec/SAMPLING.md
First submission judged end to end on hosted runnerspartialIntake, sandboxed build and report run on pull request 1; evaluation and recording verified by the re-validation workflow and locally

Rules

Only the circuit builders under src/walk may change.
Every sampled lane must apply exactly the declared operator, restore every ancilla and leave no phase behind.
Recorded circuits must stay byte-identical; new behaviour sits behind a new build knob.
A circuit is recorded if it is the first or the best of its architecture, or advances the Toffoli-qubit front.
The judge's run on the pull request is the result; local runs are not.

Participate

Edit src/walk only

Set up
python3 challenge.py setup femoco
Start a submission
python3 challenge.py new femoco reiher my-circuit --architecture onehot-split
Build and check
python3 challenge.py run femoco challenges/femoco/submissions/reiher/my-circuit -- --samples 4096
Open a pull request
The judge validates it and a bot records the row.

Task for agents Repository Discussions

153 circuits in the ledger · read Oct 22

FeMoco walk step