Make the digest
a proof.

What stands today.

Descent of Nations is a deterministic, batch-parallel Rust reimplementation of Rise of Nations, built to be bit-exact wherever that can be proven and fast enough to train agents on. Fidelity is not a vibe here; it is measured against the shipped machine code itself. A differential oracle maps the retail executable and calls its actual functions with controlled inputs, next to ours:

The reverse engineering keeps overturning folklore. Damage is a 31-stage integer chain with armor in the middle. General movement is integer. Border influence is a cell-radius model, not a spline. And the shipped AI receives difficulty-scaled economic bonuses · twenty years of "the AI is so good at economy," and it was on welfare. Ours is required not to be; non-cheating is a product gate.

Alongside the sim: an open, modifiable RL environment · Gymnasium, VectorEnv and PettingZoo adapters over the full 82-opcode action space with parameter-level masks. Not a toy subset: the environment must not foreclose a state-of-the-art player. And the .rcx replay format, which had no public documentation or parser anywhere, now has both.

The observation.

Rise of Nations is a lockstep RTS. Peers exchange orders only · never state · and every machine simulates the same world locally. Which means the shipped game already had to solve a verification problem: how do you know the other machine computed the same world you did?

Its answer, in 2003: every turn, hash the simulation state across fifteen channels · economy, combat, movement, and the rest · and compare digests between peers. Desync is detected by checksum disagreement. Replays are just the order log plus those digests.

That is a verification protocol. A replicated state machine, a compact input log, a per-step state commitment. The game was built wanting to be verified · it simply lived two decades before the machinery that could keep it honest against anything stronger than an honest peer.

The thesis.

A proof that each tick's transition was computed correctly · folded incrementally across a match, the way the match itself is played · would be, to our knowledge, the most complex incrementally verifiable computation ever attempted: tens of thousands of heterogeneous state transitions per tick over a large mutable world, not a linear pass over a ledger.

Three facts make it a thesis rather than a fantasy. The statement already exists · the fifteen-channel digest defines exactly what to prove, and it was defined by the game, not by us. The simulation is integer · the RE campaign keeps finding integer chains and grid models where folklore expected floats, which is to say: we reverse-engineered our way to an arithmetization-friendly 2003. And the spec is measured, not asserted · eighteen million oracle trials mean a circuit's reference semantics would be pinned to shipped machine-code behavior, not to a document.

It also composes with the environment work. An open RL environment plus verifiable execution is something reinforcement learning conspicuously lacks: benchmarks that cannot lie. "This agent achieved this result in this environment" becomes a checkable artifact · provable evaluations, cheat-proof leaderboards, tournaments verified without replaying a frame · the same design that already makes a board-game cheat unsatisfiable, scaled up from an 11×11 board to a war.

The road, honestly.

Nothing below is a claim of achievement. It is the order of battle, each stage a checkable artifact, no dates attached:

Verifiable computation has spent its first decade proving the 1950s · balances, books, batches. A war, with its economy and fog and ten thousand simultaneous small decisions, is 2003. The digest is already there. We intend to prove it.

Status, plainly: the fidelity oracle, replay validation, and RL environment numbers above are current and real. The proof stages are a stated intention · none has begun. This page is the flag, planted in public, so progress against it can be checked rather than believed.