State, Physics, Causality, and Memory Evaluation

Picture a small ball rolling across a table. For two seconds it is plainly visible. Then it passes behind a box, and for eight frames you see nothing at all. Then it emerges on the other side. Now ask a world model what happened in between.

This is a deceptively simple question. It sounds like a single question, but it is really a bundle of at least four distinct questions, and world models can answer some of them correctly while failing the others. That separation is the entire subject of this chapter.

There are at least four different things a model could do here, and they are easy to confuse. Among them, only the last is a causal question: the first three are observational or representational.

• It could generate eight frames that look like a ball continuing across the box. The pixels are plausible; the ball is in roughly the right place.
• It could maintain a hidden state that keeps the ball's position and velocity coherent, so that the ball emerges at exactly the right place at the right time.
• It could keep the ball's identity intact, so that the thing that emerges is the same object rather than a new one that happens to be nearby.
• It could do all of the above while also knowing that if you had pushed the ball differently just before it disappeared, it would have emerged somewhere else.

These are different requirements, not a strict hierarchy. Accurate positions do not guarantee persistent identity, and identity tracking does not guarantee accurate motion. An intervention asks a further question about changes to the world that observational prediction alone does not identify without assumptions. Each requirement needs its own evaluation protocol.

A model can pass the visual test while failing hidden-state, identity, or intervention tests. Even strong results across these offline diagnostics do not establish closed-loop usefulness: a planner may fail when it acts on the predictions. Chapter 64 evaluates decisions, Chapter 65 develops experimental design, and Chapter 67 examines failure modes and model exploitation.

This chapter is about how to tell these cases apart. It is in Part XI: Evaluation and Understanding. The previous chapter, "Perceptual and Generative Evaluation" (Chapter 62), handled the question of whether generated observations look right and whether their distribution matches the data. Here we develop state, constraint, and intervention diagnostics within the world-model evaluation ladder established in Chapter 61, without treating those diagnostics as nested requirements.

The chapter is organized around four evaluation families:

• State probing and representation quality. When you freeze a representation and fit a small readout, what can it recover, and what does that recovery prove?
• Object permanence and temporal consistency. Does the model maintain a coherent hidden trajectory through occlusion, and for how long?
• Physical rule and constraint tests. Does the model respect the conservation laws and boundary conditions of the regime it claims to model?
• Interventions, counterfactuals, and causal fidelity. Under a change to one mechanism, does the model predict the right change, or merely fit the observational distribution?

The four families examine separate properties. Probing measures accessibility to a readout; occlusion tests measure behavior over hidden windows; constraint tests check a named rule; interventions test a specified change under an identification design. None universally subsumes the others. Running them separately makes their different failure modes visible.

State what information the model received, what information the baseline received, and what the metric denominator counts. Compare methods on a named population, and distinguish differences in modelling from differences in information access. A privileged-state baseline can be useful, but its advantage over an observation-only method cannot be attributed entirely to better modelling.

The first three families use a point mass moving in the unit square with reflecting walls, an occluder band, and noisy position observations. The causal section then switches to a separate one-step structural model so that its confounding mechanism is explicit. The point-mass state lives in $\mathbb{R}^4$ as

$$s_t = (x_t, y_t, v^x_t, v^y_t)$$

where:

• $x_t, y_t$: position components in metres.
• $v^x_t, v^y_t$: velocity components in metres per second.

We observe only the position components through $o_t$, and the dynamics are the deterministic map

$$s_{t+1} = f(s_t, a_t)$$

defined in the simulator below, where $a_t$ is the acceleration action.

The reflecting-wall simulator returns one next state given state and action; its random initial conditions, action sampling, and observation noise are separate draws. A structural model with a specified disturbance likewise returns one outcome once all its inputs are fixed. The later causal example introduces a shared disturbance $u$ in such a one-step model. Reusing that disturbance across counterfactual branches is an explicit coupling assumption, not a property inferred from passive observations.

The point-mass simulator fits in a few dozen lines of NumPy and lets us inspect probe, occlusion, and constraint diagnostics against known truth. Neither it nor the later causal model is a benchmark for trained foundation models. Treat them as controlled fixtures: their simplicity makes each diagnostic's target and assumptions visible, without establishing its performance on a larger system.

A probe is a small model fitted on top of a frozen representation. You take the encoder, stop its gradients, run it over a dataset, and then ask: can a simple readout predict quantity $q$ from the representation $z_t$? Saying that the representation "contains" $q$ can conflate recoverability by a chosen readout, unrestricted information content, and downstream use. We need to ask how the information is arranged and which procedure can read it out.

The three questions are:

1. Linear accessibility. How well does a fitted linear readout recover $q_t$ from $z_t$ on held-out data? Success demonstrates accessibility to that fitted readout on the tested distribution. Failure can reflect regularization, sample size, fitting, or distribution shift; it does not prove that no linear readout could succeed. A linear probe still learns a task-specific mapping.
2. Information decodability. Can some function in a richer probe family recover $q_t$? A flexible probe can learn substantial task structure from its frozen inputs, so high performance depends jointly on the encoded information, the readout's capacity, and its fitting procedure. Capacity cannot supply target information absent from those inputs.
3. Downstream functional use. Does the rest of the system use $q_t$ to make decisions? This is the only one of the three that connects to behaviour, and it cannot be established by a probe at all. A probe is a diagnostic instrument attached to the side of the model; it does not tell you what the model does with the information when it acts.

Comparing readouts can reveal which fitted family works better on the test distribution. Better nonlinear scores do not establish impossibility of linear recovery, and failures under both families do not prove absent information. Good decoding also does not establish causal necessity: the downstream system may ignore the recovered variable. Testing functional use requires additional experiments, such as controlled representation interventions and closed-loop comparisons.

Check these three procedural details before interpreting a probe score. Splits and preprocessing determine what information is held out; controls clarify how the selected probe behaves on an alternative task. Mistakes can bias an evaluation or limit the conclusions it supports.

The probe itself is a fitted map $g_\theta$ from the frozen representation $z_t$ to a target $q_t$. It is a simple readout, not a full model. In the linear case, $g_\theta(z_t) = W z_t + b$; in the nonlinear case, the probe first maps $z_t$ through a fixed feature function and then applies a ridge readout. The data are the held-out trajectories, and all probe scores are computed against targets that were not used to fit either the encoder or the probe, and trajectories are held out as complete sequences rather than individual frames so that frames from one rollout never appear in two splits. The key design choice is that the encoder is frozen: the probe cannot reshape the representation to make its job easier, so any information the probe recovers must already be present in $z_t$.

Split at the trajectory level, not the frame level. Consecutive frames of one trajectory are strongly correlated: neighbouring timesteps share nearly the same position. Random frame splits can put near-duplicates of test frames in the training set and inflate the probe's held-out score through memorisation. Splitting whole trajectories removes this within-trajectory leak. In our toy we hold out complete rollouts. Choose a split unit that respects the dependencies in the data; shared scenes or subjects may require a larger grouping than one trajectory.

Fit preprocessing on training data only. Standardisation statistics, whitening matrices, and PCA bases must be estimated on the training split and then applied unchanged to validation and test. Fitting them on the full dataset uses held-out information. Its effect on a score depends on the data and fitting procedure; neither inflation nor a flat train/test gap is guaranteed.

Use a control task with matched probe capacity. Hewitt and Liang (2019) developed type-level randomized control tasks for linguistic probes. Our shuffled regression targets are a simpler toy control, not a reproduction of their protocol. Report real-target and control results together, with the randomization and split specified. A control gives context about the chosen fitting procedure; it does not bound all structured-task learning or certify information content.

To keep this concrete, let us build a frozen representation by hand and be explicit about what it is. We will use a phase encoding of position only. In the formula and NumPy code, $x_t$ and $y_t$ denote the numerical values of observed coordinates in metres: the dimensionless phase is $2\pi$ times the coordinate divided by a one-metre period.

$$z_t = \big[\,\cos(2\pi x_t),\; \sin(2\pi x_t),\; \cos(2\pi y_t),\; \sin(2\pi y_t)\,\big] \in \mathbb{R}^4 .$$

where:

• $x_t$: the observed horizontal position at time $t$, in metres.
• $y_t$: the observed vertical position at time $t$, in metres.
• $\cos(2\pi x_t), \sin(2\pi x_t)$: the phase encoding of the horizontal coordinate as a point on the unit circle; together they determine its numerical value modulo one. Exact inversion over a full period is nonlinear; this does not preclude a useful approximate linear readout over a restricted distribution.
• $\cos(2\pi y_t), \sin(2\pi y_t)$: the phase encoding of the vertical coordinate as a point on the unit circle, with the same periodic-recovery property.

This is a handcrafted encoder, not a learned one. Exact recovery of a noiseless position within a specified one-period interval uses nonlinear phase inversion; positions differing by an integer share the same encoding, and noisy observations near the interval boundary complicate recovery. The encoder does not directly take velocity, but that does not make velocity statistically independent of its output. Our sampled trajectories can correlate position and velocity. The experiment tests these readouts on a named distribution, not an absolute present-versus-absent information theorem.

Our world is a point mass in the unit square with perfectly reflecting walls. Let us fix the conventions before writing any metric. Fixing conventions up front is not a formality; it is what makes the numbers in the tables below interpretable and comparable across sections.

• State: $s_t = (x_t, y_t, v^x_t, v^y_t)$, metres and metres per second.
• Action: $a_t$, metres per second squared, applied as an acceleration.
• Time step: $\Delta t = 0.1$ s, so one trajectory of 30 steps is 3 seconds.
• Observation: $o_t = (x_t, y_t) + \epsilon_t$ with independent coordinate noise $\epsilon_t \sim \mathcal{N}(0, (0.004\ \text{m})^2 I_2)$.
• Occluder: the band $x \in [0.5 - w, 0.5 + w]$ for $y \in [0.05, 0.95]$, with $w$ the occluder half-width.
• Data-generating policy: $a_t \sim \mathrm{Uniform}(-0.3, 0.3)^2$ m/s², independent across components and timesteps.
• Split unit: one complete trajectory. We use 60 for training, 20 for validation, 20 for test.

The hidden fraction tells us how much of the data sits behind the occluder. At 0.278 it is not small, and occlusion is not rare in this dataset. The reason occlusion matters out of proportion to its frequency is that a rare failure to maintain a coherent hidden state can dominate the downstream consequences, even if the model is otherwise accurate on 90% of the data.

We now build the probe dataset. Because the encoder is defined on observed positions, we keep only timesteps where the ball is visible, and we standardise the representation using training statistics only. Standardising with statistics computed on the full dataset is the leakage trap described above, so we are careful to compute the mean and standard deviation from the training split and apply the same transformation to validation and test.

Interpret the probe scores with three limits in mind: readout capacity, failed recovery, and downstream use.

A flexible probe may be doing substantial task learning from the information available in its frozen inputs, not creating target information missing from them. A nonlinear readout's gain can depend on both the encoded features and the readout's capacity and fitting procedure; the score does not apportion these contributions. Our control records this procedure's held-out performance after target shuffling. It bounds neither all learning on random targets nor learning on structured targets. Report the probe architecture, feature dimension, and regularisation strength so that the procedure can be reproduced.

Low linear performance does not show that information is absent. Failure of both chosen families still cannot rule out successful recovery by another readout or training procedure. A control task provides context, not an information-theoretic absence test. What you have shown is how these specific probe procedures performed on this split.

Good decoding does not establish causal necessity. If a fixed readout recovered velocity exactly almost surely throughout the target population, then $v_t=g(z_t)$ on that population. Zero error on a finite test set does not establish that condition. Neither result shows that the transition model or policy uses the recovered velocity. Controlled representation interventions can test that use, but an intervention inside a model is not automatically an intervention in the world. Chapter 66 returns to this distinction in interpretability and world-model debugging.

There is a further trap in our toy: the encoder is handcrafted, so this experiment characterises a diagnostic procedure, not a trained world model. Its inputs are known by construction, but statistical relationships between position and velocity still depend on the trajectory distribution. A real encoder requires its own splits, controls and interpretation.

Our probe evaluates individual timesteps. Object permanence concerns an object's continued existence when it is unobserved. Tracking its hidden position through a gap is a richer operational diagnostic: a model may preserve existence or identity while remaining uncertain about location or predicting motion inaccurately. Hidden-trajectory evaluation therefore needs its own target in addition to a persistence criterion.

This is where compounding error and memory meet. The previous chapter, "Perceptual and Generative Evaluation," asked whether a generated frame looks right. Here we ask whether the hidden trajectory is right. For an occluded-object control task, position accuracy can matter to the chosen action even when the generated frames look plausible. These are complementary tests: accurate hidden positions do not guarantee good visual generation, and plausible frames do not certify accurate positions.

We should be precise about what "correct" means during an occlusion. Three distinct properties are usually bundled together:

• Hidden trajectory accuracy. The model's estimate of the ball's position while hidden is close to the true position.
• Reappearance accuracy. At the first visible timestep after the gap, the model's belief matches the observation.
• Identity persistence. The object that reappears is the same object, rather than a newly spawned one that happens to be nearby.

Multiple indistinguishable objects can exchange identities while preserving the visible set of positions. An identity-aware test needs persistent labels or another identity criterion. Our single-object toy does not test competing identity assignments; that does not make identity and trajectory accuracy equivalent. A tracked object can keep its label while its predicted position is wrong.

Observational ambiguity also matters. A noisy visible history may be consistent with several hidden continuations. A point loss can still compare predictors by expected risk over realized trajectories, but does not characterize the forecast distribution. Where the task needs uncertainty, report and evaluate a conditional distribution rather than treating one plausible continuation as the uniquely predictable outcome.

The six paths below are the first six held-out trajectories in index order, and the amber markers identify frames hidden by the band. This figure shows ground-truth paths and visibility geometry, not a predictor's errors or reappearance accuracy.

The comparison names each predictor's information budget and metric denominator. In this driven task, horizon-dependent error mixes initial-state estimation with omitted future forces and possible contacts. It is not a pure measure of learned memory: these predictors are handcrafted, and the constant-velocity baseline has no learned recurrent state.

Horizon is one axis; occluder geometry is another. We sweep the band half-width on fixed undriven trajectories. The metric is position error at the final hidden step of the first usable gap, not at the first visible reappearance. Wider bands change both gap lengths and which trajectories qualify, so this sweep does not isolate elapsed time from sample selection.

Recurrent and transformer-based world models carry their hidden state across time in a learned memory. A natural diagnostic is to reset or truncate that memory at the moment the object disappears and see whether performance degrades. If it does, the memory matters for the task. This is an appealing experiment because it is easy to run, but the inference it supports is narrower than it first appears.

A mid-episode reset may be out of distribution if training never used such resets. Context truncation may likewise be unfamiliar, depending on the training protocol. Performance changes measure sensitivity to the stated manipulation, not an isolated memory circuit. Describe the training context and reset schedule before interpreting either ablation.

Four useful temporal properties need different measurements:

• Sequence coherence is a local property: successive predicted states are mutually consistent.
• Long-range dependence is about how far back in time the model's prediction depends on.
• Object identity requires a persistent identity criterion; multi-object gaps make assignment ambiguity particularly visible.
• Uncertainty should be reported, not suppressed: when several hidden continuations are consistent with the visible data, a good model produces a spread of plausible futures rather than one confident guess.

Finally, note the discipline about oracle baselines and information budgets. It is easy to build a comparison in which one method quietly reads the simulator's latent state while another reads only observations, and then report the resulting gap as a modelling improvement. Every baseline in this section is labelled with what it reads. If you introduce an oracle, introduce it loudly. The reason this discipline is worth repeating is that the temptation to compare against an oracle without disclosing it is strong: the oracle often performs better, and the difference can be presented as evidence of modelling quality rather than of information asymmetry.

The previous section asked whether the hidden state is coherent. This one asks whether the dynamics obey a specified physical law under a named regime. A model can produce a smooth, coherent, plausible trajectory that travels at an unphysical speed through a dissipative medium, or that passes through a wall, or that gains energy at every bounce. Constraint tests are how you catch that. They are the natural complement to the trajectory-accuracy tests above: accuracy asks whether the model is close to the truth on average, and constraint tests ask whether the model respects the mechanisms that produce the truth.

Specify the regime before testing a rule. In this force-free, elastic toy, kinetic energy is conserved. Applied forces can do work; damping and lossy contacts can dissipate energy, so a driven dissipative system needs both contributions in its energy balance. A conservation test without a regime can penalize correct dynamics. Here a lossy contact reduces normal kinetic energy only when the incident normal velocity is nonzero.

We will evaluate three regimes, all with the same dynamics code but different parameters:

The damping factor multiplies both velocity components by $0.9$ each step, so total kinetic energy is multiplied by $0.81$. At a wall, restitution multiplies only the normal velocity by $-e$; its energy component is multiplied by $e^2=0.49$, while tangential energy is unchanged. Total energy therefore does not generally fall by a factor of $0.49$. These regimes test different mechanisms, but a residual alone cannot identify which mechanism is wrong.

For a rollout of length $H = 30$ starting from the true initial state $s_0$, define the predicted energy ratio $\hat\rho = \hat{E}_H / \hat{E}_0$ and the true ratio $\rho = E_H / E_0$, where $E$ is the kinetic energy

$$E_t = \tfrac{1}{2} m \|\mathbf{v}_t\|_2^2$$

where $m = 1$ kg is the mass and $\mathbf{v}_t$ is the velocity at step $t$. The energy ratio residual is

$$\mathrm{ERR} = \big| \hat\rho - \rho \big|$$

with the predicted and true ratios defined as

$$\hat\rho = \frac{\hat{E}_H}{\hat{E}_0}, \qquad \rho = \frac{E_H}{E_0}$$

where:

• $H$: the rollout horizon, $30$ steps, so $H\Delta t = 3.0$ s.
• $\hat{E}_t$: the kinetic energy of the model's predicted state at step $t$.
• $E_t$: the kinetic energy of the simulator's true state at step $t$.
• $\hat\rho$: the model's predicted energy ratio over the rollout.
• $\rho$: the true energy ratio produced by the simulator's own dynamics.

These ratios require positive initial energy. The fixtures satisfy that condition; the implementation floors denominators at $10^{-12}$ joules as a numerical safeguard, which changes the ratio convention near zero. In the elastic case $\rho=1$; with damping and no clipping $\rho=0.81^H$; with lossy contact the ratio depends on each impact. The violation rate uses the declared absolute ratio-error tolerance $0.05$, not a universal physical threshold.

We evaluate four predictors in each regime to compare regime dependence and model-class limitations. Simulator truth is reused as an identity reference; evaluating numerical integration drift would require an independent higher-accuracy reference or a time-step convergence study, which this example does not provide.

• True integrator. Simulator truth reused as the reference prediction. Its zero residual follows by identity, not from an independent numerical-accuracy check.
• Linear model fitted on force-free data. A one-step linear map $\hat{s}_{t+1} = A s_t + b$ estimated by ridge regression on force-free trajectories.
• Linear model fitted on damped data. The same estimator, fitted on damped trajectories.
• No-change control. The deliberately wrong negative control: $\hat{s}_{t+1} = s_t$. It preserves initial velocity and kinetic energy but freezes position, illustrating that passing an energy check is not sufficient for correct dynamics.

A non-zero constraint residual can come from at least five places, and attributing it correctly is most of the interpretive work:

• Learned dynamics error. The model misrepresents the mechanism.
• Numerical integration drift. Under-resolved integration can introduce error. Diagnosing it needs an independent numerical reference; our identity comparison does not measure it.
• Observation error. If the rollout is initialised from noisy observations rather than the true state, the initial energy estimate itself is noisy.
• Coordinate and unit errors. Inconsistent velocity conversion across initial and final states can distort ratios. A common multiplicative conversion of all velocities cancels in $E_H/E_0$; ratio agreement cannot detect every unit error.
• A mismatched regime. The model may be perfectly correct for a different regime than the one under test.

The experiment includes regime mismatch and model-class misspecification. A systematic signed residual can arise from either, from calibration bias, or from other errors; its sign does not uniquely diagnose the cause. Compare matched-regime data, held-out mechanisms and an appropriate numerical reference before assigning responsibility.

The next figure compares the free-trained and damped-trained linear fits on the same 20 elastic held-out rollouts, plotting each unit's signed energy-ratio residual instead of its average. The fits also use different realized initial-state draws in their training trajectories, so this comparison does not isolate a change in training regime alone.

Constraint projection can improve a chosen residual while worsening trajectory prediction. Renormalizing a nonzero predicted velocity to its initial magnitude enforces energy conservation in the elastic regime, but is wrong for a dissipative regime's energy target. Clamping position to the box does not enforce energy conservation. A projection must target the actual constraint and satisfy its feasibility conditions; it does not universally drive every residual to zero. Report projected and unprojected errors together.

Finally, note that constraint testing is not a substitute for the state probes of the previous section. A model can respect every conservation law while tracking the wrong object, and it can track the right object while violating energy conservation. These are independent axes of evaluation. The full picture requires both.

The occluded-ball question from the previous sections was observational: given what was seen, what happens next? The questions in this section are different. They are about what would happen under a change. The difference between "given what was seen, what happens next" and "what would have happened if we had done something different" is precisely the difference between prediction and causal inference, and no amount of observational data can answer the second kind of question without additional assumptions.

Three targets must be kept apart, because they are estimated differently, identify different quantities, and are routinely confused:

Observational fit does not identify any causal quantity without further assumptions. A model can fit the observational distribution to machine precision and still be wrong about the effect of an intervention, and the mechanism by which this happens is confounding.

The earlier simulator sampled actions independently of its state and transition, without a shared action/outcome disturbance. We now switch to a separate one-step structural causal model in which an unobserved disturbance $u_t$ influences both the action and the velocity change:

$$\begin{aligned} u_t &\sim \mathcal{N}(0, 1) \\ a_t &= -\kappa\,(x_t - 0.5) + u_t \\ v_{t+1} &= v_t + \big(a_t + c\,u_t\big)\,\Delta t \end{aligned}$$

where:

• $u_t$: the unobserved exogenous acceleration disturbance, with numerical values in m/s² drawn from a standard normal.
• $a_t$: the acceleration action in m/s² chosen by the state-feedback policy with gain $\kappa=2$ s$^{-2}$; the position reference $0.5$ is in metres.
• $x_t$: the position at step $t$.
• $v_{t+1}$: the next velocity, driven by the action plus the disturbance coupling $c$.
• $\Delta t = 0.1$ s: the step size.

The action is chosen by a state-feedback policy, but the policy's exploration noise is the same $u_t$ that enters the dynamics with coupling $c$. An engineer observing only $(x_t, a_t, v_t, v_{t+1})$ never sees $u_t$, so the observational data are confounded by construction. This toy illustrates one possible shared-signal mechanism: the observational correlation between action and outcome mixes the direct effect of the action with the effect of the shared signal. It does not establish how often that mechanism occurs in deployed systems.

Now ask: what is the causal effect of the action on the one-step velocity change? Holding $u_t$ fixed and differentiating, the structural derivative is

$$\frac{\partial\, \Delta v_t}{\partial a_t} = \Delta t = 0.1\ \text{m/s per m/s}^2$$

where $\Delta v_t = v_{t+1} - v_t$ is the one-step velocity change, $a_t$ is the action, and $\Delta t = 0.1$ s is the step size. The derivative is $\Delta t$ because the structural equation is linear in the action with slope $\Delta t$. This is the quantity we want to recover, and it is a structural quantity: it describes how the next velocity would change if we intervened on the action while holding everything else fixed.

That is the ground truth we want to recover. Now see what an observational regression gives. Rearranging the policy equation gives $u_t = a_t + \kappa (x_t - 0.5)$. Substituting this into the dynamics,

$$\frac{\Delta v_t}{\Delta t} = a_t + c\,u_t = (1 + c)\,a_t + c\kappa\,(x_t - 0.5)$$

where $u_t = a_t + \kappa (x_t - 0.5)$ has been substituted. The coefficient on $a_t$ is $1 + c$ rather than $1$, so the observational relationship overstates the structural action effect. The empirical analogue is a regression of the observed velocity change on the observed action and position.

In the noiseless structural relationship, the observational coefficient is $(1+c)\Delta t=0.2$, twice the intervention slope $0.1$. The measured regression below includes observation noise and fits nearly, not exactly, perfectly. A predictive coefficient need not be an intervention effect.

The held-out observational fit is $R^2\approx0.9993$, while its fitted action coefficient is about $0.19994$ instead of the structural slope $0.1$. Fit alone does not reveal the confounding in this example. The nearly perfect noisy fit should not be described as machine precision.

Now we run a paired simulator intervention on the held-out units. For each unit:

1. Clone the unit's initial state $x_0$ and its exogenous disturbance $u$.
2. Run it once with its natural action $a$.
3. Run it again with the same state and the same $u$, but with the action shifted by a fixed $\delta$.
4. Subtract the two outcomes.

Because $u$ is shared, the difference isolates the direct effect of the action. Substituting the structural equation $\Delta v(a) = (a + c\,u)\,\Delta t$ into the two branches,

$$\begin{aligned} \Delta v_t(a + \delta) - \Delta v_t(a) &= \big((a + \delta) + c\,u\big)\,\Delta t - \big(a + c\,u\big)\,\Delta t && \text{(structural equation at each action)} \\ &= \big(a + \delta + c\,u - a - c\,u\big)\,\Delta t && \text{(expand)} \\ &= \delta\,\Delta t && \text{(the shared } c\,u \text{ cancels)} . \end{aligned}$$

For the noiseless structural outcomes, dividing by nonzero $\delta$ recovers $\Delta t=0.1$ exactly. The code then adds independent measurement noise to both branches and averages across units, so its estimate has sampling error. Shared structural $u$ is the simulator's explicit counterfactual coupling; passive video does not supply that coupling by itself.