Mind the Seriality Gap

Every clip in this section, and every error number, comes from one simulator: experiments/statebench/statebench/sim/solver.py, the seriality-gap paper’s own. This is what it does.

The world

A square box, 10 by 10 units. Inside it, 1, 2, 3 or 5 balls, all of radius 0.7 and equal mass. No gravity, no friction, no spin: between contacts a ball moves in a straight line at constant speed. Contacts are perfectly elastic. Speeds in the data have a median of 8 units per second (5% to 95%: 2.3 to 14.7), so in one frame at 15 frames per second a typical ball moves 0.55 units, about 0.8 of its radius. What the data records, once per frame and per ball, is four numbers: the centre position (x, y) and the velocity (vx, vy) at that instant. A 49-frame, 5-ball clip is therefore 49 × 5 × 4 = 980 numbers, and that is exactly what the state models take in and put out.

How time advances

The simulator has no time step. It is event-driven: it jumps from one contact to the next and moves every ball in a straight line in between. For one frame interval (1/15 s) it does the following.

1. From the current positions and velocities, compute when each possible contact would happen: for every pair of balls, the time at which their centres are 2 × 0.7 = 1.4 units apart (the root of a quadratic in time); for every ball and each of the four walls, the time at which its centre is 0.7 from the wall (a linear equation).
2. Take the earliest of these times. If it is after the end of the frame interval, move every ball in a straight line to the end of the interval, record the frame, and stop.
3. Otherwise move every ball in a straight line to that time, change the velocities of the balls involved by the rule for that contact (next paragraph), and go back to step 1 from the new state.

Because the contact times are solved for exactly and the motion between them is exact, the recorded frames carry no integration error. Any number of contacts can happen inside one frame interval, each at its own time; the frame only shows where the balls ended up.

How the simulator scores a generated clip

The same simulator produces the error numbers. The global error Δx(GT) is the mean distance, over balls and over frames 5 to 48, between a generated ball centre and the true one. The local error Δx(k) asks whether the generated clip obeys the physics from one moment to the next: take the generated frame t−k, estimate each ball’s velocity from its position change since frame t−k−1 (the paper’s estimator; the model’s own velocity numbers are not used, so the score depends on positions only), run the simulator k frames forward from that state, and measure the distance to the generated frame t. The mean over balls and over t = 5 … 48 is Δx(k); the paper uses k = 1 and k = 5. A clip that follows the physics exactly scores 0 on Δx(1) and about 0.02 on Δx(5) (the small floor comes from estimating velocities from positions when a contact falls inside the interval). The true clips score exactly that.

One property of this score matters later: every distance in a clip scales with the balls’ speed, so a generated clip whose balls move 30% slower than the data scores about 30% lower on Δx(5) without following the physics any better. A fair reading of Δx(5) needs the sample’s mean speed next to it.

Balls of radius 0.7 collide elastically in a 10 × 10 box at 15 frames per second. The model sees only numbers: 49 frames × 5 balls × (x, y, vx, vy) = 980 values per clip. No pixels, no VAE, no tracker. It is a small transformer with one token per (frame, ball), 8 layers, width 256, 6.85M parameters, trained with flow matching.

The datasets

Each dataset is built by the paper’s own generator: 400 frames simulated per seed, the first 200 discarded as burn-in, at most one accepted window kept per seed. Initial conditions, solver, window filters, collision-density limits, and the held-out collision-count quotas are the original code, unchanged.

The burn-in keeps the state distribution equal to the original data’s. First-frame ball speeds, 5 balls at 49 frames:

Without the burn-in every clip would start from a freshly sampled initial condition, where 100% of ball speeds lie in [8, 10] against 18% in equilibrated data. Held-out sets keep the original repository’s balancing across ball-ball collision counts; one ball has no ball-ball collisions and no balancing.

Global error Δx(GT) is the mean distance between generated and true ball centres over frames 5 to 48. Local error Δx(k) runs the exact simulator k frames forward from the generated frame t−k and compares it with the generated frame t, with velocities read off the generated positions by the paper’s finite-difference estimator.

The bidirectional model reaches 0.885 on the five-step local error. The block-4 model — the paper’s autoregressive scheme applied to states, 4 frames generated per block, earlier frames held fixed — reaches 0.223, four times more physically accurate, and also has the lower global error.

Left: the local error falls until about 20 steps and is flat from 20 to 200, the paper’s Observation 4. No number of denoising steps brings the bidirectional model near the block-4 model.

Right: the bidirectional model’s global error is lowest at 1 step and rises with more steps. One step returns roughly the conditional mean of all futures consistent with the given frames — close to the truth on average, but not a physically consistent trajectory. The global error therefore does not measure physical accuracy; the local error does.

The bidirectional model is accurate at the first generated frame and drifts to the level of unrelated positions in the box by about frame 30.

The 1-step curve lies below the 50-step curve, which looks backwards but is expected. One denoising step returns a blend of trajectories rather than any one of them; being the mean, it minimises squared distance to the truth while being physically wrong. Fifty steps return one physically consistent sample, and because the dynamics are chaotic a single valid future ends up as far from the true one as any other valid future.

The paper’s control removes the serial structure. Both models become far more accurate, and — the substantive point — the two architectures become nearly equal: 0.0300 bidirectional against 0.0229 block-4 at 49 frames, a ratio of 1.31. Global error agrees: 0.0434 against 0.0399.

That matches the paper’s Observation 2, which reports 0.246 and 0.220 for its two video models at one ball and 49 frames, a ratio of 1.12. The gap that exists at 5 balls does not exist at 1 ball.

5 balls: the bidirectional model degrades with clip length, 0.684 at 25 frames to 0.885 at 49, tracking the paper’s video curve (0.670 to 0.883). The block-4 model is flat at 0.223 to 0.239, as the paper’s autoregressive video model is flat at about 0.61. Observations 1 and 3 reproduce, at 1/30 of the parameters.

1 ball: both models are flat, and so is the gap between them. The bidirectional model goes from 0.0371 at 25 frames to 0.0300 at 49 — slightly down, not up. Clip length by itself is not what hurts one-pass generation; dependent collisions are.

Local five-step error, bidirectional models, mean over 3 seeds with the standard deviation across seeds:

Block-4 models, with the bidirectional-to-block-4 ratio in parentheses. The gap grows with clip length at 5 balls and is flat at 1 ball:

Conditional score error

Total score RMSE from the score-error audit run on these checkpoints: 25,000-step weights, 1,024 held-out clips, 32 uniform noise levels, 8 noise draws, float32 with TF32 disabled. “Generated frames” is clip length minus the 5 conditioning frames.

The same audit, as mean squared score error per predicted number:

Per-number score error is flat or slightly declining with length at every ball count, one ball included. The total grows only because there are more numbers to predict. From 20 to 44 generated frames the output grows by a factor of 2.2, so a flat per-number error predicts √2.2 = 1.48× growth in the total; measured growth is 1.46× at 1 ball, 1.50× at 3 balls, and 1.37× at 5 balls.

This matters for the audit’s question. A total score error that grows as the square root of the output size, with no increase per number, is what a model whose per-number score error is fixed and positive produces on a larger output. It is not evidence of a length-dependent breakdown in score accuracy.

Sampling accuracy

Denoising-step budgets of 1, 2, 4, 8, 16, 32, 64, and 128, shared initial-noise seed, all 1,024 held-out clips. Best mean local error over all tested budgets:

A successful global prediction has mean position error at most 0.1 world units; a successful local prediction has five-frame physics error at most 0.05. The 1-ball models meet both thresholds at a fixed budget that does not grow with length: 2 steps for the global criterion at every length, and 32 steps for the stricter local criterion at 28, 36, and 44 generated frames. The 20-frame case needs 128 steps for the local criterion, the one place a shorter clip is harder — its best mean local error, 0.0338, is also the worst of the four. No multi-ball cell reaches 90% on either criterion at any tested budget, and adding steps does not fix it.

Both metrics fall monotonically as blocks get finer — the paper’s Observation 3, with a much wider spread than in pixel space, where its models span 0.88 down to 0.61. Block-causal models are cheaper at inference than the bidirectional one only when blocks are large: block 1 costs 44 times as many model calls at the same number of denoising steps.

Block 1 also shows the step saturation: 0.401 at 1 denoising step, 0.133 at 5, 0.116 at 20, 0.115 at 50.

Depth gains keep coming to 32 layers but flatten (0.885 to 0.765 to 0.717), while width saturates almost immediately (0.885 to 0.849 for a 4× parameter increase). Depth buys more than width per parameter, the paper’s Observation 5.

No bidirectional model of any size tested approaches the block-4 model’s 0.223, let alone block 1’s 0.110. More layers do not substitute for generating in order.

Shift 5 makes both models worse and leaves the ordering and the size of the gap unchanged (3.98× against 3.69×). The schedule choice is not what produces the results above.

7 minutes for 1-ball bidirectional, 22 minutes for 5-ball bidirectional, 10 and 50 minutes for the corresponding block-4 models. Block-causal training is slower because the paper’s scheme doubles the sequence and needs an explicit attention mask, which prevents the fused attention kernel; at one ball the sequence is short enough that this costs almost nothing.

Side note: predicting how long a balanced held-out set takes to build

The original repository balances each held-out set across ball-ball collision counts. Under one clip per simulation, the rarest bin must be found by rejection sampling rather than harvested from a single collision-heavy simulation, and the cost varies enormously by cell.

The collision-count distribution has a geometric tail, so a short sample predicts the rare bins. 24,000 fresh simulations for the 2-ball 49-frame cell, 82 seconds on 8 cores:

Consecutive ratios are near-constant at 0.140. Fitting on the well-populated bins and extrapolating:

Checked against the live build: the model predicts about 119 clips in the 9-collision bin after 8.0M simulations; the build had about 100. Roughly 20% accurate, from 82 seconds of sampling.

A single-rate Poisson process would have a factorial tail, falling off much faster than this. A constant ratio is what a Poisson mixture gives: mixing over a Gamma-distributed rate yields a negative binomial, whose tail is geometric. Physically that fits, since how often two balls meet depends on their configuration, so the collision rate varies between simulations. This is an inference from the shape, not verified against the simulator.

Practical rule: before building a balanced cell, run about 25,000 simulations, fit the ratio on the bins with good counts, and extrapolate. A 6,000-simulation smoke test whose rarest bin has a single observation gives an unusable estimate.

The rollout targets work in state space

In pixel space the same targets gave changes within ±2%, which the rollout-guidance section above documents. Here rollout-5 guidance lowers Δx(5) by 28% at 49 frames and 34% at 25 frames, and improves 84–87% of individual holdout clips when paired on the same initial noise. The pixel-space failure was a tracking problem, not a property of the guidance idea: with exact states there is nothing to detect.

The rollout targets do not flatten the length curve

The 25→49 growth of Δx(5) is 1.28× unguided, 1.26× with rollout-1 and 1.41× with rollout-5. The growth of the global error is unchanged or slightly steeper, 2.21× against 2.33–2.56×. Guidance shifts the whole curve down by a roughly constant factor. The block-4 model is flat at 0.96× and still 2.9× more accurate than the best guided bidirectional model at 49 frames.

A rollout-5 target improves Δx(1) as much as a rollout-1 target does

0.119 against 0.116 at 49 frames, and it improves Δx(5) and Δx(GT) more. The five-frame target carries more information about where the ball should be than the one-frame target, whose source frame is itself only one frame away from the target.

The oracle

The oracle receives the true future states. It is a positive control: it shows how far one gradient step per denoising step can move the sample. At 50 steps it takes the global error from 2.93 to 0.04 and the five-step local error from 0.888 to 0.188, below the block-4 model's 0.223. It also gains from more steps, which vanilla sampling does not:

At 100 steps the oracle's 25→49 growth is 1.08×. This matches the pixel-space clean-latent oracle, which also kept improving with steps while vanilla sampling did not. The guided steps are an iterative fit to a supplied answer; they do not compute the answer.

Below 0.3 the rollout guides do little; at 3 they start to hurt Δx(1); at 10 every guide is worse than no guidance on the local errors, the oracle included. The optimum is 1 for all three targets, and the same value is selected at every clip length and step count from 50 steps upward.

Ablations

One change at a time from the main grid, 49 frames and 50 steps, with strength re-selected on the calibration clips.

• Re-estimating the source velocities from positions, as the metric does, gives the best rollout results — a further 4–5% on Δx(5). The model's own velocities are slightly less consistent with its positions than finite differences are.
• Dropping the velocity channels from the loss hurts every guide: the velocity targets carry information the position targets do not.
• Guiding only late loses most of the gain. The early, high-noise steps matter even though the clean estimate there is a blurred mean trajectory.
• For the rollout targets the gradient through the model helps; for the oracle it hurts, and the plain Tweedie-estimate gradient gives the best oracle numbers of the whole experiment, Δx(5) 0.122 at 50 steps. With a fixed exact target there is no need to ask the model which direction is consistent with its own prediction.

Watching the trails shows what the metrics measure. The vanilla panel produces balls that turn in mid-flight, pass through each other and leave the wall at the wrong angle. Rollout-5 guidance removes many of these, so its trails look like a plausible billiard trajectory, but by the end of the clip the balls are nowhere near their true positions: a physically consistent future that starts from slightly different collisions diverges from the true one within about 20 frames. The oracle panel follows the truth panel almost exactly. Block 4 produces a consistent trajectory that is also a different one.

At frame 5 every method sits on the truth. By frame 20 the vanilla and both guided runs have visibly separated, and by frame 36 the lines are as long as the box. Only the oracle keeps every disc inside its dashed circle, which is why it has no visible lines. Guidance shortens these lines a little but does not stop them growing.

More plausibility measures

The paper's two metrics compare two points in time. These ask what the simulator says about a generated trajectory as a whole, on the same trajectories as Figure 22 at 50 steps and strength 1. They fall into three groups: what the model's own velocity channel says, what the simulator says about the generated positions, and how far the sample is from the truth.

“Event” everywhere means what the paper's simulator reports when run for one frame interval from the generated frame t−1 with the generated positions and velocities. Because the true clips are exact simulator snapshots, the ground truth scores zero on every violation measure, which checks the definitions.

Rollout guidance fixes positions and breaks velocities

On the position-based measures the guided models sit between vanilla and block 4: half as many overlapping frames, the ball–ball collision-law residual down from 0.71 to 0.43 with a rollout-1 target, and the collision-count distribution repaired — vanilla generates 25 collisions per clip against 15 in the data, and rollout-5 gives 15.4. On every velocity-based measure the guided models are worse than vanilla: energy drift 3×, phantom velocity changes 2×, speed-distribution distance 6×.

The rollout target's velocity at frame t is the simulator's velocity after running from the estimate's frame t−k. Early in sampling the estimate is a conditional mean whose velocities are averaged over many futures and therefore too small, and the target inherits and then enforces those small velocities. Neither local error catches this: the paper's re-estimates velocities from positions, and the generated-velocity variant only checks that a few frames are consistent with each other, which a trajectory that is too slow but self-consistent passes — both variants improve under rollout guidance. A conserved quantity tracked across the whole clip is what exposes it.

The oracle and block 4 are physically clean by every measure; vanilla is not

Vanilla's ball–ball collision-law residual is 0.71, meaning the velocity after a detected contact differs from the elastic-collision outcome by 71% of the incoming speed, against 0.13 for the oracle and 0.23 for block 4. Vanilla balls overlap in 14% of generated frames and leave the box in 3%; the oracle and block 4 do so in under 1%.

Are the generated clips distributed like true clips?

The measures above pick one physical quantity each. The complementary question is whether the generated clips, taken as whole objects, are distributed like true clips. Each clip's 44 generated frames are flattened into one vector — 440 position coordinates, 440 velocity coordinates, or both — in the model's standardized units, and compared with the truth three ways.

• Gaussian Fréchet distance, the FID construction, between the 896 generated clips and 20,000 independent true clips of the same length. Fitting a Gaussian to 896 samples in 880 dimensions is noisy, so the ground-truth column — the 896 holdout true clips scored the same way — is the noise floor.
• Sliced Wasserstein-2 distance to the same 20,000 clips: the exact 1-D W2 along 1,000 random directions, root-mean-squared. No Gaussian assumption.
• Classifier two-sample test: 5-fold cross-validated accuracy of a classifier trained to tell the 896 generated clips from the 896 true clips they continue, where 50% means indistinguishable. A generated clip and its true continuation always share a fold; otherwise the twin in the training fold teaches the opposite label and accuracy falls below chance.

Vanilla, the oracle and block 4 are indistinguishable from the truth on every whole-trajectory measure

Their Fréchet and sliced-W2 distances sit on the noise floor at every number of principal components, and the CNN and logistic regression score 50% against them. Gradient boosting reaches 54.5% on vanilla, the only trace of a signal. This is the same vanilla model that overlaps balls in 14% of its frames and collides 25 times per clip instead of 15. Those violations live in a few coordinates per frame — the distance between one pair of balls, the velocity jump at one contact — and change the marginal distribution of the 880 coordinates so little that a two-sample test on 896 clips does not see them.

Only the rollout-guided models separate, and only through their velocities

The CNN tells rollout-1 and rollout-5 clips from true ones with 93% and 97% accuracy; sliced W2 on velocities is 3× the floor and on positions 1.15×. Logistic regression stays near 54%, so the difference is not a shift in the mean trajectory but in its shape.

In physics-feature space there are three islands: the truth alone, since every violation measure is exactly zero for it; the two rollout-guided models, with their low final energy; and a third island where vanilla forms its own blob next to a shared oracle-and-block-4 blob. In raw-coordinate space every method is the same featureless cloud. That matches the table: the raw coordinates do not carry the physics violations that the simulator-based measures detect.

The whole-trajectory distances therefore add one thing — a clean confirmation that the rollout-guided velocity drift is a distribution-level defect — and miss everything else. Comparing generated trajectories as a distribution needs a feature space in which the violations are large, and for this task those features are the physical measures, not the coordinates.

Physics-law guidance

The guidance above pushes the model toward a target it computes for itself by simulating forward. That lowers the error, but the error still grows as clips get longer. This part drops the target and guides with physics instead.

A law is an equation relating neighbouring frames that the true motion satisfies exactly: energy is conserved, a ball touching nothing travels in a straight line, a ball leaving a wall reflects, two balls never overlap, and no ball passes through another. The model is pushed toward satisfying these. Nothing simulates the motion forward, so this guidance never needs to know what happens next — only what any correct answer must look like.

Three law sets were tried, and they are named below by what they contain rather than by the order they were tried in.

The law methods do more sampling work than what they are compared against

Everything earlier in this section runs the denoising pass once, applies its correction once per step, and produces one clip. The law methods add three things: renoise-and-denoise rounds, each mixing the finished clip back to a chosen noise level and running the steps below it again; a second model run per step, so the correction is applied twice; and repeated independent samples, where several clips are generated and one is kept. Each of the three lowers the error on its own, whatever the guidance is, so law results cannot be read against the earlier ones directly. This is what each method runs:

The last column multiplies the other three together, so it counts how many times the model runs to produce one clip. The law methods cost far more than the methods they were originally compared against, which is why the comparison further down gives every method the same three settings.

Three things made this work. Law gradients touch only a few numbers per frame, so each one needs its own size limit rather than a shared one — before that, every law made the result worse. Letting the gradient flow through a differentiable simulator beats comparing against a fixed simulated target, because it can also move the frame the simulation starts from. And renoise-and-denoise rounds help.

Renoise-and-denoise rounds help every method, though, not just this one, and they help the unguided model most of all, so they are not evidence that the laws are doing the work. Two further problems: this method still simulates forward, which is what the laws were meant to avoid, and its samples collide far less often than real ones.

Second law set: geometry laws alone, no simulator

This set drops the simulator entirely and keeps only the geometry laws: no overlaps, no crossings, stay inside the box. Every law the first attempt had rejected was retried with renoise-and-denoise rounds, five new laws were written, and the update rule was varied.

Measured against methods run without renoise-and-denoise or repeated independent samples, this set looked like a clear win. It is not: give the rollout target the same renoise-and-denoise rounds and the same repeated independent samples and most of the apparent win disappears. The two figures below give every method the same settings, and differ only in whether each method keeps the best of its samples.

This set has three parts, and only the first is guidance:

1. Geometry guidance. No overlaps, no crossings, inside the box; bounded per-element step, strength 3, plus the relative-velocity reflection law at weight 0.3, faded as it is satisfied, applied only when σ ≤ 0.35 and added without renormalising the geometry step. The reflection helper is worth 0.02; nothing else helps as a guide.
2. Renoise-and-denoise, 24 rounds from σ 0.45 with two corrections per step: 0.654 → 0.458.
3. Law-critic selection. Eight samples per clip from different noise; the one with the smallest sum of z-scored log losses of three laws — position-only free flight, speed constancy outside contacts, total momentum outside wall contacts, all fixed in advance on a separate run — is kept: 0.457 → 0.388. The critic captures about half of what a perfect pick would, 0.311.

Some laws help as a guide; others only help as a filter

Laws written on velocities get satisfied in the wrong way. The model has a velocity channel that the error metric never reads, so it can satisfy a velocity law by editing those numbers, and it can satisfy a collision law by producing fewer collisions. Both make the law's own residual look better while the motion gets worse.

Laws written on positions have the opposite problem: they need a recognisable contact to act on, and a badly wrong sample does not contain one, so they go quiet exactly where they are needed. A straightness law that cannot be gamed at all still hurts, most likely because straightening an early, blurry estimate pushes the model toward futures in which nothing ever collides.

The same laws are useful in a different role. Instead of guiding, they score finished clips, and the best-scoring one is kept. Nothing is being optimised against them, so there is nothing to game, and they rank clips well.

The rounds are what makes the law set competitive, and what flattens its curve

Take the rounds away and the full law set loses to block 4 by a wide margin at every clip length. It also stops being flat: with the rounds its error is the same on the longest clips as on the shortest, and without them it grows like everything else. The flat curve is therefore a property of the laws and the rounds together, not of the laws alone. This is the sharpest statement the section can make about the law set, and it is weaker than the one the earlier comparison suggested.

Block 4 is the only method the rounds damage

Every other method is more accurate with them, the unguided model most of all. Block 4 gets worse at every clip length, and on the longest clips it also stops keeping the data’s speed. A round re-noises the whole clip and regenerates it block by block, which breaks the agreement between neighbouring blocks that makes generating in order work. That is why block 4 is drawn solid without the rounds: that is its best setting, and it is the number the guided methods have to beat.

The rounds do not rescue the rollout targets

Both rollout targets are already slowing the balls down without the rounds, at every clip length, so none of their numbers count in either setting. Adding the rounds lowers their error but does not fix the speed, and on the longer clips it is still failing. The oracle, which is given the true future, keeps the data’s speed throughout and is unaffected either way.

Keeping the best of eight helps every method, and helps them by similar amounts, so the ordering barely changes. Whatever the critic is picking up on is not specific to the law-guided model. The full law set and block 4 given the same renoise-and-denoise rounds finish level on the longest clips either way, and block 4 run plainly stays clearly ahead of both.

One thing does change. Block 4 given the renoise-and-denoise rounds fails the speed check at the longest clip length when its eight independent samples are averaged, and passes it when the critic chooses one. The selection is partly repairing what the renoise-and-denoise rounds do to that model — more evidence that the renoise-and-denoise rounds are the wrong setting for it, and that its plain run is the number worth comparing against.

What the full law set actually does

At every denoising step the model produces its current guess at the finished clip. Ten laws are evaluated on that guess, each one an equation the true motion satisfies exactly, and the guess is nudged toward satisfying them. Nothing simulates the motion forward at any point.

Write \(p_t^b\) and \(v_t^b\) for the position and velocity of ball \(b\) at frame \(t\) in the current guess, \(\Delta t\) for the frame interval, \(r\) for the ball radius, and \(\rho_t^{ij} = p_t^i - p_t^j\) for the vector between a pair of balls. Every law is written on one interval, from frame \(t-1\) to frame \(t\), and averaged over balls or pairs and over the generated frames.

Which balls each law applies to

A law about free flight must not be applied to a ball that just collided, and a law about collisions must not be applied to a ball that did not. Neither is known, so both are estimated from the guess itself. For a pair, three distances are computed: the closest approach if both balls fly freely forward from \(t-1\), the closest approach flying backward from \(t\), and the closest approach of the straight segment joining the two frames. Taking the smallest, \(d^{ij}\), a soft indicator of contact is

and the chance that ball \(b\) touched nothing in the interval is \(\phi^b = \prod_{j \neq b}\left(1 - s^{bj}\right)\). The free-flight laws are weighted by \(\phi^b\), the collision laws by \(s^{ij}\). The margin \(m\) is set wider for the free-flight laws than for the collision laws, so that a collision the indicator underestimates does not leave a free-flight law fighting it.

The ten laws

Geometry, which holds at every frame regardless of what happened:

Free flight, for a ball the indicator says touched nothing. Let \(q = p_{t-1}^b + v_{t-1}^b \Delta t\), mirrored once about a wall if it lands outside, and \(\tilde v = -v_{t-1}^b\) if it was mirrored and \(v_{t-1}^b\) otherwise:

Collisions, for a pair the indicator says touched. Write \(V = v^i + v^j\) for the pair’s total velocity and \(E = \lVert v^i\rVert^2 + \lVert v^j\rVert^2\) for its energy:

The last two need the contact normal. Flying both balls freely forward from \(t-1\), let \(s_c \in (0,1)\) be the fraction of the interval at which their separation first reaches \(2r\), \(\rho_c\) the relative position there, and \(n = \rho_c / \lVert \rho_c \rVert\). For equal masses an elastic collision reflects the relative velocity about \(n\), giving \(\hat u = u_{t-1} - 2(u_{t-1}\!\cdot n)\,n\) where \(u = v^i - v^j\):

Dividing by the current speed, which is what made this set work

As written, every residual above shrinks if the balls simply move less. A guidance that slows everything down therefore lowers the loss without predicting anything better, and that is what an earlier law set did. So each residual is divided by how fast the balls are currently moving — \(\lVert v_{t-1}^b \rVert + \varepsilon\) for a single ball, the sum of both speeds for a pair — squared to match the residual. Scaling every velocity in the clip by a constant now leaves the loss unchanged, so slowing down buys nothing.

How the laws become a correction

The laws are not summed into one loss and differentiated once. Each law’s gradient with respect to the current guess is taken separately, and each gets its own step, because the gradients differ in scale by orders of magnitude: a law that is already satisfied almost everywhere touches a handful of numbers per frame, and adding it to a dense one would bury it. For a law taking a bounded step, the gradient is divided by its own largest element and scaled by that law’s weight, so no law can move any single number by more than its share. For the rest, the step is the exact minimiser along the gradient, which for a squared residual is

capped so one law cannot dominate a step. The per-law corrections are then added. This happens twice per denoising step.

Two things sit on top and are not guidance: the finished clip is partly re-noised and denoised again twenty-four times, and several clips are generated with three of the laws used to score them and the best kept. Both help any method, which is what the comparison above controls for.

Most of the apparent win came from the extra sampling work

The geometry law set looked far better than the rollout target, but the rollout target had been run without renoise-and-denoise or repeated independent samples. Give it both and almost all of that difference disappears. Those two settings help any guidance, and they help the unguided model most of all. The full law set does open a genuine gap over the rollout target, and that gap comes from the laws, because both methods now get the same sampling.

The full law set beats both rollout targets at every clip length

Given the renoise-and-denoise rounds it does so whether each method averages its eight independent samples or keeps the best of them, and the margin widens as clips get longer. The rollout targets also slow the balls down, so their numbers stop counting from the middle clip lengths on, and without the rounds they fail that check at every length. The law set keeps the data’s speed everywhere except the longest clips without the rounds.

Law guidance stops the error growing with clip length, but only with the renoise-and-denoise rounds

Given the rounds, the law set’s error is the same on the longest clips as on the shortest, and every other guided method gets worse as clips lengthen. Take the rounds away and the law set grows with length like the rest. So the flat curve needs both the laws and the rounds; neither produces it alone. Selection is not involved either way: the curve is flat with a single sample and with the best of eight.

Given the same sampling, law guidance matches generating in order

On the longest clips the best law set and block 4 given the same renoise-and-denoise rounds reach the same five-step error, within the spread across training seeds, and the law set is ahead on the one-step error. Without the selection, block 4’s number at that length is disqualified by the speed check as well. The two cross: block 4 leads on short clips and loses that lead on long ones, because the renoise-and-denoise rounds make block 4 worse as clips lengthen while the law set holds steady.

That tie depends on holding block 4 to settings that damage it. A renoise-and-denoise round mixes a finished clip back into noise and regenerates it block by block, which breaks the agreement between neighbouring blocks that makes block 4 work. Run without renoise-and-denoise it is ahead on both errors, and the law-guided model cannot match it there because it needs the renoise-and-denoise rounds to reach its own best result. So: equalise the sampling and the two tie; let each method use the settings that suit it and generating in order still wins.

The first law set’s improving curve came from slower balls

The first law set, the one with the differentiable simulator, appeared to get better on longer clips. Its balls also move progressively slower than real ones as clips lengthen. The error measures how far a ball has drifted from where it should be, and a slower ball drifts less, so the error falls without the prediction improving. That curve is not evidence of anything and is no longer plotted.

The laws are satisfied where they apply; the error is where they do not apply

Every law comes with a condition for when it may be used. Free flight applies to a ball only if no other ball and no wall is within one frame of travel (0.6 units) of its path, because otherwise a contact may fall inside the interval and a straight line would be the wrong prediction. The collision laws apply to a pair only if the two balls touch and nothing else is within reach of either, because the outcome of a contact next to a wall or a third ball depends on which contact comes first. Where the condition fails, the law says nothing.

Figure 48 shows what that leaves. For the exact position-only laws, 12% of the (frame, ball) windows have a law applying in all five of their intervals. Those windows are nearly right already (0.06 against 0.02 for the true clips) and hold 2% of the total error. The other 98% of the error is in windows with at least one interval the laws leave alone (panel a). Panel b says what is in those intervals: a collision with something else within reach (34% of the error), two or more collisions in the five frames (24%), a wall bounce with another ball within reach (16%), and near passes where nothing touches but a ball or wall was within one frame of travel, so no law was sure enough to apply (23%).

Panel c is the direct test. Ten more iterations of the position laws on the finished clip lower the laws’ own loss 18-fold and the five-step error by 0.008. The laws are being satisfied; the score barely notices, because the score lives in the intervals the laws do not touch.

The velocity-channel laws have looser conditions and cover 38% of the windows, but the intervals they leave hold 81% of the error, and even in the windows they cover the guided clip is 1.7× worse than block 4 (0.17 against 0.10): those laws constrain the generated velocities, and the score reads only positions, so a clip can satisfy them by adjusting its velocity numbers alone. Block 4 has the same 10% coverage and the same split (3% of its error in covered windows), and is better in both kinds of window, 0.07 and 0.24 against 0.10 and 0.57.

What is left uncovered has one thing in common: two events close together, and the outcome depends on their order. A law for that case must compute which of two contacts happens first from the state at the start of the interval, apply it, and then check the second. That is the simulator’s own step. The law sets above stop at 0.32 because every law in them assumes one event per interval, and the error that remains is in the intervals that break that assumption.

The first law set gets part of its accuracy by avoiding collisions rather than by getting them right. Its clips contain roughly a third as many ball-to-ball collisions as real ones, and the balls lose half their energy. A collision that never happens cannot be resolved wrongly, so dodging them lowers the error without improving the physics.

The geometry law set does not cheat that way. It keeps as much energy as the unguided model, matches the real distribution of ball speeds, halves the unguided model’s unexplained velocity changes, never overlaps two balls, and halves its collision-law error. It still collides less often than real clips, which is its one remaining defect — milder than the first law set’s, and absent from the rollout target, which gets the collision rate right.

Neither law set improves the global error. Both produce a physically consistent future rather than the true one. Block 4 is still the only method that is accurate, keeps its energy and collides as often as real clips, all at the same time.