cert-machine · report · generated from the records
The physics answer key: one hundred simulator runs, two engines, decided in exact arithmetic
A physics engine writes its state as floating-point numbers, and every one of those is an exact fraction. So whether a recorded run kept its energy, to a stated tolerance, can be decided with whole numbers and no rounding in the decision. With Claude (Anthropic’s AI model), I recorded 100 runs of two engines built for simulating robots, MuJoCo 4.0.1 and Newton 1.8.0, on three scenes whose physics is known exactly, and decided each recorded file that way. For MuJoCo, the documentation already describes what the runs show. For Newton, one solver’s default settings include an angular damping that its class description does not mention where it says the method preserves energy. What is added here is the exact decision, the step at which each tolerance first fails, and a page that decides the same bytes again in a browser tab.
A flat body tumbling in empty space, with no force and no torque on it, simulated for 10 seconds at a timestep of 0.002 s. Its spin energy should not change. The line that falls is Newton’s SolverSemiImplicit built with every argument at its default, which includes an angular damping of 0.05, a documented default. The grey lines beside the zero line are every other configuration recorded at this timestep. Each curve is drawn from the exactly decided value at every recorded step.Records: certs/physics-key-newton.json · sha256 218f54cb0b95; certs/physics-key.json · sha256 e1d7c3316356The build refuses this figure if a run file is not the pinned bytes, or the record no longer says that the default run loses between 60% and 63% of its spin energy without ever gaining any, or another configuration ends more than 2.5% from level.
recorded runs
100
60 of MuJoCo 4.0.1, 40 of Newton 1.8.0
verdicts
1,464
393 certified, 1,071 refuted, 0 refused
files on which two deciders agree
112 of 112
JavaScript and Python, no shared code, every field
planted files decided as planted
12 of 12
synthetic runs with a known answer
MuJoCo is Google DeepMind’s engine. Newton is a Linux Foundation project initiated by Disney Research, Google DeepMind and NVIDIA. Nothing on this page is a fault report on either: an integrator of finite order is expected to move away from the true motion, and a damping that is a documented argument with a documented default is a choice, not a bug. Each verdict is about one recorded file of bytes, never about an engine in general. The checks are mine, run with Claude (Anthropic’s AI model), which wrote the programs under my direction.
read this first
What is still open
It is not a discovery about MuJoCo. MuJoCo’s documentation says that integrating a spinning free body explicitly can gain energy, and that its implicit integrators damp a tumble instead. Its own tests check the energy of a tumbling free body, in floating point with a tolerance. Free fall and the same tumble were compared across four other engines in 2014 and 2015 (the Gazebo “boxes” benchmark), and energy and momentum across five engines in 2015 (Erez, Tassa and Todorov). All of those plot or assert floating-point errors. I looked for an earlier case of conservation laws decided on an engine’s recorded output in exact arithmetic and found none; that is a search, not a proof that none exists.
It is not a fault report on Newton. The angular damping is an argument of the solver’s constructor, and its documentation gives the default, 0.05. The words “preserves energy” are in the class description of the integration method; they are not a stated bound, and no sentence promises that the default settings keep a free body’s energy. Passing angular_damping=0.0 turns the damping off. Newton’s own verification tests check free fall, a pendulum’s energy, momentum and torque-free angular momentum, and each of them builds its solver with the damping set to zero. I searched the project’s issues and pull requests for the argument’s name and for “preserves energy” on 17 November 2026 and found nothing on either point; that is a search, not a proof that nobody has raised it.
Two engines, one version of each, one machine. The bytes were written by MuJoCo 4.0.1 and Newton 1.8.0 (with Warp 1.19.0) on one arm64 Mac. Newton ran on its CPU device only; its GPU device may round differently, and so may another platform. The verdicts are about the pinned bytes.
Newton computes in 32-bit floats and keeps no clock. Every 32-bit float is an exact fraction too, so nothing about the decision changes. The time attached to each Newton step is mine: the step number times the timestep. The falling body’s laws compare against that time, so part of what they measure for Newton is the engine’s 32-bit timestep.
One cause is attributed and not shown. With the damping off, Newton’s SolverSemiImplicit gains a little more energy than its SolverFeatherstone, and the gap grows with the number of steps. I attribute it to 32-bit rounding. I have not shown that.
Newton’s pendulum was run under one solver only. SolverSemiImplicit holds a hinge with a damped spring and has no hinge angle in its state, so the frictionless pendulum of this page is not that solver’s system. The pendulum runs are SolverFeatherstone’s.
The tolerances are mine. Six per law, from 1% (or 1 cm) down to exactly zero, fixed before the first run. No sentence of either engine’s documentation promises any of them.
Only conserved quantities, and nothing a robot touches. The pendulum’s timing and the tumbling body’s attitude are not compared with a closed form; only energy and angular momentum are. There is no contact and no friction in any scene, and those are where robots spend their time and where a single right answer stops existing.
Between the recorded steps, nothing is said. A law that holds at every recorded step holds at those instants.
One law was added after the MuJoCo runs were decided. The rules were committed before any simulation step. The law “the spin energy never rises” was added afterwards, when I read that MuJoCo’s documentation states it; I had by then seen the other MuJoCo verdicts and an informal count. It is marked as amendment 1 in corpus/physics-key/RULES.md and is not pre-registered for MuJoCo. The Newton runs came later, under amendment 2, which was committed before any Newton step and already held that law.
The second decider is independent by procedure only. It was written by a separate session of the same AI model, given the rules and nothing of the first decider. Both ran under one person. Exact programs decide here, not a model; you should still know that a model wrote both.
MuJoCo’s fifth integrator is new. The documentation calls “discrete” new and subject to change. In all three scenes it wrote the same bytes as implicitfast.
the idea
A float is a fraction
A floating-point number, 64-bit or 32-bit, is a whole number times a power of two. A simulator’s state is a list of them: the time, the positions, the velocities. Kinetic energy and angular momentum are sums of products of those numbers, so for a recorded step they are fractions too, with no error at all. “The energy at step 4,812 is within 1% of the energy at step 0” is then a comparison of two whole numbers.
That removes one layer of doubt. When a floating-point check says an error is 1.9%, the check itself carries rounding. Here the only rounding is the engine’s own, which is the thing being measured. The pendulum needs a cosine, which is not a fraction; it is trapped between two fractions, as tightly as each comparison needs.
the scenes
Three motions with a known answer
A falling body. Dropped from rest, nothing in its way, for 2 seconds. Its height at every instant is the starting height minus half of g times the time squared, and its speed is g times the time. Two laws: position and speed against those formulas.
A pendulum. One weight on a frictionless hinge, let go from rest, for 10 seconds. One law: its total energy stays what it was.
A tumbling body. A flat body in empty space, spinning about its middle axis with a small nudge, so it flips over and over (the tennis racket effect), for 10 seconds. Four laws: its spin energy stays what it was; its spin energy never rises; its angular momentum keeps its size; its angular momentum stays the same vector.
The MuJoCo runs. Each scene with each of the five integrators MuJoCo 4.0.1 names (Euler, which is the default; implicitfast, which the documentation recommends; implicit; discrete; RK4) at four timesteps: 0.01, 0.005, 0.002 (the default) and 0.001 seconds. 60 files, each named by its sha256.
The Newton runs. Two solvers of Newton 1.8.0, SolverSemiImplicit and SolverFeatherstone, each built twice: with every argument at its default, and with angular_damping=0.0. The falling and the tumbling body under all four, the pendulum under the two SolverFeatherstone ones, at the same four timesteps. 40 files. A step is the one the package’s own tests take.
the falling body
The speed is right; the position lags
Largest distance between the recorded height and the formula over 2 seconds, rounded up, and the tightest tolerance the whole run stays inside. Four of MuJoCo’s five integrators wrote the same bytes, and so did all four Newton configurations.
MuJoCo 4.0.1, integrator
0.01 s
0.005 s
0.002 s (the default)
0.001 s
Euler, implicitfast, implicit, discrete
98.1 mm inside no tolerance tried
49.1 mm inside no tolerance tried
19.7 mm inside no tolerance tried
9.82 mm inside 1 cm
RK4
2.35 × 10⁻¹⁴ m inside 1 pm
3.59 × 10⁻¹³ m inside 1 pm
1.67 × 10⁻¹³ m inside 1 pm
2.09 × 10⁻¹² m inside 1 nm
Newton 1.8.0, solver
0.01 s
0.005 s
0.002 s
0.001 s
all four configurations (the same bytes)
98.1 mm inside no tolerance tried
49.1 mm inside no tolerance tried
19.7 mm inside no tolerance tried
10.1 mm inside no tolerance tried
In MuJoCo, at the default timestep, the body ends 19.7 mm from the formula and first passes 1 cm at step 510. REFUTED at 1 cm; at half the timestep the whole fall stays inside 1 cm.
Its speed in MuJoCo is within a billionth of a metre per second at every step of every run. CERTIFIED The step updates the speed first and then moves the body with the new speed, so the position is always one step’s worth ahead: an error that grows in proportion to time and to the timestep.
With MuJoCo’s RK4 the position stays within 1.67 × 10⁻¹³ m at the default timestep. CERTIFIED at a millionth of a millionth of a metre.
In Newton the position lags the same way: 19.7 mm from the formula at 0.002 s, first past 1 cm at step 511. The speed stays within a millimetre per second at every step of every run CERTIFIED and leaves a micrometre per second by step 87 at every timestep REFUTED: it is at most 342 µm/s off. MuJoCo, which computes in 64-bit floats, holds a billionth on the same law; Newton computes in 32-bit floats.
the pendulum
Energy wobbles, and comes back
Largest change of the total energy over 10 seconds, as a share of the weight times g times the length.
MuJoCo 4.0.1, integrator
0.01 s
0.005 s
0.002 s (the default)
0.001 s
Euler, implicitfast, discrete
1.85% inside no tolerance tried
0.920% inside 1%
0.367% inside 1%
0.184% inside 1%
implicit
1.85% inside no tolerance tried
0.920% inside 1%
0.367% inside 1%
0.184% inside 1%
RK4
1.52 × 10⁻⁸ inside 1 in 10⁶
6.68 × 10⁻¹⁰ inside 1 in 10⁹
1.29 × 10⁻¹¹ inside 1 in 10⁹
7.18 × 10⁻¹³ inside 1 in 10¹²
Newton 1.8.0, solver
0.01 s
0.005 s
0.002 s
0.001 s
SolverFeatherstone, defaults; SolverFeatherstone, damping off
1.85% inside no tolerance tried
0.920% inside 1%
0.367% inside 1%
0.184% inside 1%
With MuJoCo’s default integrator at its default timestep the energy is never more than 0.367% from its starting value, and −0.124% at the end. With RK4 it is never more than 1.29 × 10⁻¹¹. Newton’s SolverFeatherstone at the same timestep: never more than 0.367%. It wrote the same bytes with and without the damping argument.
the tumbling body
Some configurations make energy, some lose it, one loses most of it
Largest change of the spin energy over 10 seconds, with the change at the end. No force and no torque act in this scene.
MuJoCo 4.0.1, integrator
0.01 s
0.005 s
0.002 s (the default)
0.001 s
Euler
9.93% · +9.93% at the end inside no tolerance tried
4.79% · +4.79% at the end inside no tolerance tried
1.88% · +1.88% at the end inside no tolerance tried
0.931% · +0.931% at the end inside 1%
implicitfast, discrete
8.65% · −8.65% at the end inside no tolerance tried
4.47% · −4.47% at the end inside no tolerance tried
1.83% · −1.83% at the end inside no tolerance tried
0.919% · −0.919% at the end inside 1%
implicit
8.65% · −8.65% at the end inside no tolerance tried
4.47% · −4.47% at the end inside no tolerance tried
1.83% · −1.83% at the end inside no tolerance tried
0.919% · −0.919% at the end inside 1%
RK4
1.91 × 10⁻⁹ · −4.55 × 10⁻¹⁰ at the end inside 1 in 10⁶
1.06 × 10⁻¹⁰ · −1.48 × 10⁻¹¹ at the end inside 1 in 10⁹
2.51 × 10⁻¹² · −1.67 × 10⁻¹³ at the end inside 1 in 10⁹
1.62 × 10⁻¹³ · −1.47 × 10⁻¹⁴ at the end inside 1 in 10¹²
Newton 1.8.0, solver
0.01 s
0.005 s
0.002 s
0.001 s
SolverSemiImplicit, defaults
60.6% · −60.6% at the end inside no tolerance tried
61.9% · −61.9% at the end inside no tolerance tried
62.7% · −62.7% at the end inside no tolerance tried
62.9% · −62.9% at the end inside no tolerance tried
SolverSemiImplicit, damping off
9.94% · +9.94% at the end inside no tolerance tried
4.83% · +4.83% at the end inside no tolerance tried
2.00% · +2.00% at the end inside no tolerance tried
1.16% · +1.16% at the end inside no tolerance tried
SolverFeatherstone, defaults; SolverFeatherstone, damping off
9.93% · +9.93% at the end inside no tolerance tried
4.79% · +4.79% at the end inside no tolerance tried
1.88% · +1.88% at the end inside no tolerance tried
0.930% · +0.930% at the end inside 1%
The same scene on a much finer scale, MuJoCo only, at its default timestep of 0.002 s: the three behaviours of its integrators.Record: certs/physics-key.json · sha256 e1d7c3316356The build refuses this figure if a run file is not the pinned bytes, or the record no longer says that the Euler run gains energy at its first step and that the implicit runs never gain any.
MuJoCo, Euler (its default). The spin energy rises at the first step of every run and ends at its largest value: +1.88% at the default timestep. The largest rise within one step is 0.00220% of the starting energy.
MuJoCo, implicitfast, implicit and discrete. The spin energy falls: −1.83% at the default timestep, −8.65% at 0.01 s, −4.47% at 0.005 s, −1.83% at 0.002 s, −0.919% at 0.001 s.
MuJoCo, RK4. Never more than 2.51 × 10⁻¹² from the start at the default timestep.
Newton, SolverSemiImplicit at its defaults. The spin energy falls at every timestep: −60.6% at 0.01 s, −61.9% at 0.005 s, −62.7% at 0.002 s, −62.9% at 0.001 s. “Within 1% of its starting value” first fails within 0.11 s of the start in every run. REFUTED “Never rises” holds at every step of every run, with no tolerance. CERTIFIED
Newton, SolverSemiImplicit with the damping off. The spin energy rises, as under MuJoCo’s Euler: +9.94% at 0.01 s, +4.83% at 0.005 s, +2.00% at 0.002 s, +1.16% at 0.001 s (MuJoCo’s Euler: +9.93%, +4.79%, +1.88%, +0.931%).
Newton, SolverFeatherstone. The same bytes with the default damping and with the damping off, at every timestep. The spin energy rises: +9.93% at 0.01 s, +4.79% at 0.005 s, +1.88% at 0.002 s, +0.930% at 0.001 s.
Angular momentum changes with the energy, with no torque acting. At the timestep 0.002 s its squared size ends +1.88% under MuJoCo’s Euler, −1.83% under implicitfast, and −62.7% under Newton’s SolverSemiImplicit at its defaults.
a published sentence, decided
The documentation’s own property holds exactly
The kinetic energy of a spinning free body is non-increasing in the absence of applied force. Steady spins about principal axes are conserved almost exactly; tumbling motion is mildly damped […]. Systems requiring long-horizon energy conservation of tumbling bodies should use the RK4 integrator.MuJoCo documentation, Computation, Numerical integration, “Gyroscopic derivatives for free bodies”, read 17 November 2026
What it says. Under the implicit and implicitfast integrators, the spin energy of a free body with no force on it never increases.
What was decided. On each of the 8 recorded runs it covers, the spin energy at every step is less than or equal to the step before, as fractions, with no tolerance. CERTIFIED The engine’s own test of the same property allows a small tolerance for rounding; on these runs none is needed.
What it does not say. That energy is kept. It is not: these are the runs that lose it. And it covers the bodies and settings recorded here, not every free body.
For contrast. Under Euler the same statement fails at step 1 of every run. REFUTED
a second published sentence
A sentence and a default
Semi-implicit time integration is a variational integrator that preserves energy, however it not unconditionally stable, and requires a time-step small enough to support the required stiffness and damping forces.Newton 1.8.0, the class description of SolverSemiImplicit and, in the same words, of SolverFeatherstone; quoted as written
What it says. That the integration method keeps energy. It is a description of the method, with no bound and no tolerance.
The default beside it. Both constructors take angular_damping, documented as “Angular damping factor”, default 0.05. In the shared rigid-body step every step of a body ends by multiplying its angular velocity by one minus the damping times the timestep. So a body built with the defaults is damped, by design.
What was decided, at the defaults. On the 4 recorded runs of SolverSemiImplicit with every argument at its default, the tumbling body loses 60.6% to 62.9% of its spin energy in 10 seconds, with no force on it. “The spin energy stays within 1% of its starting value”: REFUTED in each, first within 0.11 s. “The spin energy never rises”: CERTIFIED in each, at every step, with no tolerance. The loss is the size the documented default predicts: a factor of about one minus 0.05 times the timestep on the angular velocity at every step is a loss of about 63% of the energy over 10 seconds.
With the damping off. The same solver gains energy instead, as an explicit step does: +2.00% at 0.002 s, against +1.88% for MuJoCo’s Euler. Neither setting keeps the energy to 1% over 10 seconds at that timestep.
The other solver does not read the argument. SolverFeatherstone has the same sentence and the same documented default. In Newton 1.8.0 its constructor stores the value and, as far as I could find by reading its source, nothing reads it. The bytes agree: with the default and with the damping off it wrote identical files, the same sha256, in all 12 pairs: three scenes at four timesteps.
What this is not. A bug report. A user who wants a free body to keep spinning passes one argument, and Newton’s own tests do. What the page records is that the defaults and the sentence point in different directions, and by how much on these files.
written before running
What I expected, and where I was wrong
The falling body, MuJoCo. I expected the position to fail at 1 cm within 2 seconds at the default timestep while the speed held, and RK4 to hold the position to rounding. That is what the bytes say.
The tumbling body, MuJoCo. I expected the integrators that treat the spinning term implicitly to change the energy less than Euler does. They do not: at the default timestep they lose 1.83% where Euler gains 1.88%. What differs is the direction, which is the property the documentation states. My expectation came from an older version of the documentation.
Newton at its defaults. From the source, before any step: a loss of about 63% at every timestep, and no rise at any step, of which I was less sure at the largest timestep. The bytes: 60.6% to 62.9%, and no rise at any step of any run.
Newton with the damping off. I expected SolverSemiImplicit to reproduce the gains of MuJoCo’s Euler to about the size of 32-bit rounding. At the two larger timesteps it does (+9.94% and +4.83% against +9.93% and +4.79%). At the smallest it gains about a quarter more (+1.16% against +0.931%). There I was wrong.
SolverFeatherstone. I expected identical files with and without the damping argument, because I had found nothing in the source that reads it. They are identical in every pair. I expected its gains to be close to MuJoCo’s Euler, with less confidence: they are (+9.93% at 0.01 s, +4.79% at 0.005 s, +1.88% at 0.002 s, +0.930% at 0.001 s).
Newton’s falling body and pendulum. I expected the position to lag as in MuJoCo, the speed to fail somewhere between a millimetre and a nanometre per second because the arithmetic is 32-bit (I did not know where), and the pendulum’s energy to wobble about as much as under MuJoCo’s Euler. All three are what the bytes say.
how it was checked
Rules first, two deciders, planted files
The rules came first.corpus/physics-key/RULES.md was committed before the generator existed: the scenes, the laws, the six tolerances, the three verdict words, the exact form of every printed number, and what I expected. One law was added afterwards and is marked. The second engine is an amendment to the same file, committed before any Newton step, with what I expected of it.
Reading MuJoCo’s conventions. Before any verdict was read, three floating-point checks of my reading of the engine: a second run with the engine’s own energy and angular-momentum outputs switched on wrote identical bytes (60 of 60 runs); my angular momentum agrees with the engine’s to 7 × 10⁻¹⁵ of its size, and a deliberately wrong reading of the velocity frame disagrees by more than 2 times its size; my energy change agrees with the engine’s to 9 × 10⁻¹⁶.
Reading Newton’s conventions. Newton has no energy or momentum output to compare with, so the checks are different. Every run was recorded twice from freshly built models and the two files are identical (40 of 40). My angular momentum agrees with the one built from the engine’s own rotation function to 2 × 10⁻⁶ of its size, and two deliberately wrong readings (the angular velocity taken in the body frame, the quaternion taken scalar-first) each disagree by more than 0.7 times its size. One step replayed in 64-bit floats from each recorded row lands on the next row to 2 × 10⁻⁶ of the starting spin, and the replay with the damping fits the default solver’s files at least 273 times better than the replay without it. The pendulum’s height and speed from the hinge angle agree with the body the engine reports to 2 × 10⁻⁷.
Decider 1.instruments/physicskey/decide.js: JavaScript, whole numbers only. The same file runs in the browser on the instrument page.
They agree. On all 112 files, every verdict, every first failing step and every printed digit is the same. The record is written only then. CERTIFIED
Planted files. 12 synthetic runs with a known answer: an exact parabola, a constant spin, one step nudged by two parts in a million, a single planted rise, a number that is not a number, a cut file, a file with one bit flipped, three pendulum cases that exercise the cosine, and one file read under both engines’ layouts, right under one and wrong under the other. Each was decided as planted by both.
who did what
Each part is someone’s
The engines and their documentation. MuJoCo: Google DeepMind and its contributors. Newton: the Newton developers, a Linux Foundation project initiated by Disney Research, Google DeepMind and NVIDIA, built on NVIDIA Warp.
Earlier comparisons of engines against conservation laws. The Gazebo “boxes” benchmark (free fall and the tumbling box across four engines); Erez, Tassa and Todorov (2015); MuJoCo’s own test suite; Newton’s own verification tests.
The checks on this page. Carlos Toledo, with Claude (Anthropic), which wrote the generator, both deciders (the second in a separate session, from the rules alone) and this page’s builder under my direction. Recorded and decided on 17 November 2026.
check it yourself
How to re-run it
In a browser.The instrument page fetches any of the 100 files, checks its sha256 and decides it again in your tab with decider 1.
The record.node tools/record-physics-key.js --check runs both deciders on every file again and refuses on any difference from certs/physics-key.json or certs/physics-key-newton.json. About two minutes; Python’s standard library and Node, nothing else.