SPS: the becoming cell

A single-purpose learner of one transformation on the sphere: Sphere → Plane → Sphere.

Status: frozen research artifact (v17, release 1.0.0)

SPS is a frozen research framework and boundary study of geometric predictive cells — not a universal learner or intelligence architecture. Active development is archived as of v17. Do not add another container, loss, or synthetic world unless a genuinely new hypothesis appears. The complete story, with provenance for every result, is in docs/REPORT.md. The reopening rule: SPS is reopened only when (a) a real problem naturally has spherical or rotational state, (b) a new theory directly addresses distributed credit assignment, (c) an external researcher reproduces or extends a result, or (d) a practical benchmark exposes a failure SPS is specifically suited to solve. The only stable public interfaces are the thin APIs in sps/api.py; the research internals remain explicitly experimental.

• The report — docs/REPORT.md: the complete boundary study (v1–v17), every result with provenance.
• Try the components — three standalone recipes in examples/: python examples/01_adaptive_dynamics.py · 02_distributional_prediction.py · 03_bounded_communication.py
• Regenerate the result tables — python -m scripts.run_benchmarks --quick
• Reproduce everything — pip install . then python -m pytest (149 deterministic tests)

The present state P lives on the sphere S². A proposed change u is generated in the tangent plane at P and pushed up to a future sphere state F. When reality produces an observed next state, it is pulled back into the same tangent plane, and the difference between proposed and observed change is the only learning signal.

P  ->  u  ->  F        (proposal: sphere -> plane -> sphere)
P  ->  u_obs           (observation: observed next -> plane)
loss = |u - u_obs|^2   (learning: adjust the operator only)

• One learnable thing. A cell owns exactly one becoming operator. There are no rewards, labels, encoders, stored sequences, retrieval, or attention.
• Geometry stays explicit. Projection onto the sphere, exponential/log maps, and parallel transport are exact closed forms; only the operator coefficients learn.
• Memory is not a model. Any trace is a fixed-size part of the current dynamical condition (an inertia term), never an archive and never a hidden-world belief.

X_t   = (P_t, V_t)                          current dynamical condition
φ_t   = [ Y_{≤L}(P_t) ; V_t ]               spherical harmonics of present + inertia
B_t   = skew(W φ_t + b)                     becoming operator (skew-symmetric)
F_t   = Exp_{P_t}( B_t P_t )                proposed future sphere state

Only the becoming coefficients W, b learn.

project_to_sphere, project_to_tangent, exponential_map, log_map_sphere, parallel_transport (keeps tangency to ~1e−7), and harmonic_features (real Cartesian spherical harmonics on S²; degree 1 = 3 features, 2 = 5, 3 = 7; higher degrees raise NotImplementedError).

SPS memory can exploit temporal regularity (it is an inertia trace), but the present memory update does not reliably perform hidden-state inference. Adding a parallel-transport trace is a different capacity from harmonic degree: trace = temporal information, degree = spatial complexity; they are not substitutes.

• Separation diagnostics: time-adjacent-state separation is meaningless (world trajectories are always close); use time-strided states or cross-batch comparisons. Random harmonic worlds can possess attracting equilibria, so collapse is not automatically a model failure.
• Parallel transport matters: the trace and u_obs live in the tangent plane at P_{t−1} and must be carried to P_t before mixing; ambient-coordinate mixing injects artificial rotation (up to 0.83 out-of-plane component).
• Excess capacity degrades recovery under free joint training (optimizer trades correlated features across degrees), but progressive stage-gating fixes it: a degree is retained only if held-out tangent-plane MSE improves by a threshold. A literal frozen-residual fit was tried and rejected — freezing lower blocks systematically underfits the larger model.
• Gate on tangent-plane MSE, not angular error: geodesic error is degenerate on near-collapse worlds and too noisy for retention decisions.
• Communication creates ability (two-cell partial observation): on an S² × S² world where each part's future depends on the other's present, one bounded fixed-size message (the other part's present position, 3 reals) cuts prediction error 4× vs isolated cells, while shuffled (wrong-partner) messages collapse back to isolated and an oracle seeing both parts stays essentially exact. The cells genuinely rely on the message: feeding trained coupled cells shuffled messages makes them worse than isolated. Two cells and one bounded channel — no attention, no growing memory, no network.
• Cells can discover a communication protocol: with a small learned message m = E([Y(P); V]) trained by the other cell's loss, error falls monotonically with channel width (d_m=1 0.198 → d_m=2 0.092 → d_m=3 0.007). Two learned numbers already beat the 3-number hand-designed position message (the learned pair exploits the curvature and inertia the raw position omits), and three learned numbers approach the oracle. Shuffling the learned protocol collapses it to isolated — the discovered protocol, not the extra parameters, is what carries the ability.
• The discovered protocol transfers — it is a shared language, not a wiring trick: four identical cells (one shared encoder + one shared operator, no cell IDs) trained on two matchings of the symmetric S² × S² world achieve the same held-out error on the trained pairing, an unseen pairing, and permuted cell identities (0.048 each, ~10× under isolated 0.45) — a code that works for any partner and any arrangement is a shared language. Two controls nail the contrast: shuffling delivery on the trained model collapses it (0.95), and two private two-cell pairs each work on their own pairing (0.045/0.052) yet fail when their cells are re-paired (1.15) — mismatched private codes are useless, so the shared configuration is what enables reuse.
• The SPS structure is an efficiency prior, not a new capability: on the same world, data, matching protocol, message channel (E: own-condition → msg_dim), tangent-plane target, optimizer, and steps, the equivariant skew operator (66 params) reaches 0.046 while a matched-budget generic MLP reaches only 0.170 and a GRU (267 params, 4× budget) 0.071. A generic MLP can tie — but only at 3.5× parameters and 2× steps (0.043). Recurrence never closes the gap; the discrete 2-bit DIAL-style channel is a 4.9× bottleneck (0.225), so the discovered protocol is genuinely analog; a second round of message passing is redundant (the coupling is instantaneous, first-order). SPS reaches its floor within 100 training steps while MLP/GRU need 4–8× more data, and it scales cleanly to six partners (0.047) where matched-budget generic models lag (0.19/0.07). What the comparison establishes: the geometric (rotation-equivariant, harmonic + transported-inertia, skew-tangent) operator is dramatically more parameter- and sample-efficient than established transition models on this task, and the discovered protocol is a continuous code. It does not establish superiority on harder/other tasks, long-horizon coordination, or semantic language.
• The boundary is sharp, and it is drawn honestly (out-of-family worlds): when the world is no longer generated from the harmonic family the cell conditions on, the communication mechanism survives but the operator prior does not generalize. Across six worlds (in-family harmonic control; smooth non-harmonic coupling; piecewise switching; time-varying strength; noisy observations; delayed coupling), a bounded channel beats no channel and SPS ties the 2-round message-passing model on every flavor; at matched parameter budget SPS beats a generic MLP on 5/6. But the skew operator's representational efficiency is in-family-only: on smooth non-harmonic coupling it is a hard restriction (0.39, essentially the isolated floor, vs a generic MLP at 0.10 — a representational plateau, since 3× training does not move it), and a 3.5×-budget MLP catches up on every out-of-family world. The narrow-but-defensible claim: SPS is an exceptionally efficient specialized solver for smooth coupled spherical harmonic-becoming dynamics, whose bounded continuous shared channel is broadly flavor-robust.
• A gated residual escapes the operator's representational wall without losing the prior (v9): wrapping the skew operator as u = skew-structure + g·MLP_res with a per-sample gate initialized off, refit stage-gated (fit the operator alone, then warm-start the full model, retaining the residual only if held-out tangent MSE improves) turns the in-family-only weakness into a strength: on smooth non-harmonic coupling the 185-param hybrid reaches the generic-MLP error (0.083 ≈ 0.084) that the pure operator misses (0.37); on harmonic it never regresses and typically improves (0.014 vs 0.023) with the gate mostly off (≈0.03); on a mixed world it beats both the pure operator and the generic MLP (0.096 vs 0.199/0.146), and the gated residual concentrates in the nonlinear cap (gate-weighted |u_res| inside the cap ~5× outside, robust across seeds). The measured caveat: the residual is not strictly zero in-family — because the bounded message channel limits SPS everywhere, the residual also compensates that bottleneck (gate stays low but nonzero), so localization is a tendency, not a hard on/off.
• The gate detects where SPS is insufficient, not where the cap is (v9 transfer boundary): a hybrid trained once on the north-cap mixed world keeps a positive zero-shot gain on a 45°-oblique cap, two smaller caps, a moving cap, and a 2.5×-stronger coefficient, and its activation tracks the structured operator's own one-step error on the control (mismatch-corr ≈0.9) — so it is not merely memorizing the trained coordinates. The honest limit: a full 90° rotation is seed-dependent (at some seeds the residual adds a spurious correction, negative gain), so the gate is a partial mismatch detector, not rotation-equivariant.
• A cell can predict a distribution of futures (v10): on the fork world the same visible state leads to two legitimate futures (u = u_harmonic ± v0, a latent coin picks the sign), so a deterministic cell learns the average and its predicted future never occurs (its prediction stays ~E|v0| off every branch). Wrapping the structured operator in a two-component Gaussian mixture (BenchMixture: μᵢ = skew-structure + dᵢ(z), p(u) = πN(μ₁,σ₁²) + (1−π)N(μ₂,σ₂²)) trained by NLL (after an MSE phase that anchors μ_base at the harmonic prior) puts both modes on the two true branches (modes-to-branches 0.05 vs the deterministic 0.36), brings held-out NLL far below the best single Gaussian (−4.6 vs 2.8, i.e. σ well under |v0| at both modes), uses both modes at π ≈ 0.5 with no collapse, and still keeps its mean prediction on the harmonic prior — the structured prior is preserved while the cell becomes a probabilistic future model. The v10.1 calibration phase then checks the distributional reading itself: a third training stage (freeze the modes and the message encoder, fit only the weight network by +-branch cross-entropy) makes E[π₊] track the coin bias p_plus — 0.250/0.504/0.737 for p = 0.25/0.5/0.75 — while the branch centers stay put (mu_branch < 0.09 ≈ a small fraction of |v0|), the separation sweep fixes the crossover below which a single Gaussian suffices (normalized separation ≈ 4 at v0_scale 0.05 vs ≈ 27 at 1.0; modes only leave the branches when the branches are not resolvable), and the noise sweep shows the branch-aligned σ tracking the injected noise (σ ≈ sqrt(noise² + capture²)). Readout aligns components to the physical branches per step, so the 1↔2 label swap is never assumed.
• A message can choose which future (v11): on the fork_comm world the carrier's present encodes a fresh bit b_t (shifted-bit construction: the transition that produced the carrier's present used b_t, so the bit is in the carrier's state and provably absent from the receiver's own present, trace, and history), and the receiver's branch coin matches the bit with p=0.9 — its future is predictable only through the carrier's message. Conditioning only the mixture weight on the message (condition_weights_on_message: π = sigmoid(g(P, V, m)) while the modes stay local μᵢ = f(P, V)) makes the message resolve which future while the modes still define what the futures are. Because the NLL barely pressures the message once the modes are sharp, the readout is trained on the oracle code (b_t, 0) and the encoder is distilled onto it: the learned E[π_bit] reaches 0.79 (seed mean) vs the oracle 0.88 ≈ the p=0.9 ceiling, no-message 0.49, shuffled 0.53, an opposite-bit donor flips π to 0.30, and the carrier stays 0.5 — the discovered message is the oracle protocol, and the world's leak-freedom is verified (a linear probe on the receiver's own features reads the bit at chance).
• The consequence-only frontier (v11.1): the outcome-responsibility rule — freeze the modes, take r_{t,k} = N(u_obs; μ_{t,k}, σ²)/Σ_j N(...) and train the encoder + weight network with L = −Σ_k r_{t,k} log π_{t,k} — uses no hidden bit, no oracle code, and no context label, only the predicted modes, the observed consequence, and the message before prediction. The honest result is negative: the target carries branch information but its alignment with the bit is mode-placement dependent (sharp-but-misplaced NLL modes make the tiny-σ likelihood track the residual), and the rule does not close the gap to the distilled protocol (π_bit 0.62–0.65 vs 0.79) because the responsibility's bit-mismatch noise is message-independent and the readout overfits the local-feature shortcuts — the encoder's credit is too noisy to improve the generalizing bit extraction. The information ceiling of a 90%-reliable carrier is 1 − H₂(0.1) ≈ 0.531 bits of entropy reduction; the learned message extracts ~0.13–0.21 bits (about a quarter). The finding locates the frontier precisely: the architecture can use the information, but a consequence-only rule that reliably discovers it remains open.
• Persistence teaches the sender, not the receiver (v11.2): holding the hidden bit fixed for blocks of H steps (b_t = b, P(s_t = b) = 0.9, everything else identical — no oracle, no distillation, joint likelihood only) tests whether the failure was the information being too fleeting. The sender's channel self-organizes: message-to-bit information grows 0.75 (H=1) → 0.99 (H=16) — consequence-only likelihood teaches the encoder the persistent cause from repeated evidence. The receiver's readout does not: π_bit stays ~0.6, msg ≈ none ≈ shuffled at H≥8. The documented confound: persistent bits leak into the receiver's own trace (its past consequences were generated under the same b; a linear probe reads b_t at 0.52 → 0.87 as H grows), removing the message's necessity. At bit flips the message is the only fresh source (the trace lags one step) and yields a small boundary benefit at short blocks (H=2: 0.58 vs 0.48), which fades as the shared readout fails to read the bit. Verdict: distributed communication semantics do not self-organize from consequence alone even with persistent causes — the receiver side is the standing failure.
• Consequence-only credit cannot even maintain a placed protocol (v12): the maintenance-vs-discovery question. Start from v11's working protocol (readout trained on the oracle, encoder distilled, receiver π_bit 0.76 seed-mean, msg≈none gap 0.28) and remove the oracle, continuing with either plain NLL (v12a), the responsibility rule (v12b), or the responsibility rule from the un-distilled oracle readout (v12c) — all on the H=1 leak-free fork_comm world. Every arm decays: π_bit falls to 0.64/0.64/0.62 (v12a/b/c) toward the v11.1 floor, and the message-vs-none gap narrows from 0.28 to ~0.16 — the protocol is not self-sustaining, it requires persistent oracle pressure during training. The sender's channel stays informative under maintenance (msg→bit ~0.8), so the decay is receiver-side, the same standing failure. This closes the v11.x consequence-only line as a research program: the receiver readout neither discovers (v11.1, v11.2) nor maintains (v12) a bit-carrying protocol from consequence alone. Literature context (verified 2026-08-06, see docs/REPORT.md §13): every emergent-communication protocol in the literature is driven by an explicit task signal (RL reward — DIAL arXiv:1605.06676, Mordatch & Abbeel arXiv:1703.04908), or by a second observer's latent-alignment / joint-attention mechanism (MHNG arXiv:2205.12392, SSNG arXiv:2410.21803, MARL-CPC arXiv:2505.21985); an arXiv survey found no single system self-organizing communication from pure next-observation likelihood under gradient-based credit assignment ("not found in surveyed sources" — not a proof of absence).
• The relative consequence-only objective fails too (v13): the last candidate inside the philosophy — contrastive pairing. Replace the responsibility cross-entropy with a relative loss L = clamp(margin + NLL_true − NLL_shuf, min=0): the readout must make the observed future fit better under the true received message than under a shuffled (in-distribution) one, so the mode-placement/absolute- mismatch noise that killed v11.1 cancels out (the only difference between the two conditions is the message itself). Training stays consequence-only (NLL to place the modes, then the contrastive stage with modes and variances frozen). The honest result is a total negative: the contrastive loss does not learn (it stays ~0.66–0.72, the margin is never satisfied), the sender still encodes the bit (msg→bit ~0.70) but the receiver readout stays at π_bit ~0.54 — worse than the v11.1 responsibility rule (0.62–0.65), not better. With v11.1 (absolute), v11.2 (temporal persistence), v12 (maintenance) and v13 (relative) all failing, the consequence-only line is definitively closed: the architecture can carry the protocol (distilled 0.79) but no consequence-only credit signal — absolute, relative, persistent, or maintenance — discovers or sustains it. The only known way to discover it remains a clean target: the oracle code (v11) or a second observer's latent alignment (the reward-free literature's MHNG/SSNG), both of which the philosophy excludes.
• Consequence-only fails even with a direct geometric role (v14): the strongest possible form of the negative — the message translates the shared center of both modes (μ_k(P,V,m) = μ_k^local(P,V) + T(m), T(m) a tangent-plane translation, π_k = π_k(P,V) local), on a continuous- latent world (translate_comm: c_t ~ U(−1,1) in the carrier only, the receiver's future center is u_h + c_t v0 with ±ε w0 local futures). Two fixed local modes cannot cover the moving center without the message, so the lazy-mixture escape is removed and the message has a direct, unavoidable effect on predicted geometry. The honest result is a total negative: the world is leak-free (receiver's own state reads c_t at R² ~0.01) and learnable (a supervised MLP reads c_t from the carrier's present at R² ~0.74), and the architecture can carry the protocol (oracle-trained center error 0.10 vs learned 0.22), but NLL-only still does not discover it — the learned message carries almost no c_t (c_reg R² ~0.01), learned ≈ mean-message ≈ shuffled (~0.22 each), and a causal message swap moves the modes (~0.6) with separation and weights exactly invariant. The v11–v13 negative is therefore not an artifact of the probability readout — within the tested SPS architectures and worlds, single-observer consequence likelihood did not teach the sender what to transmit, even when the message had a direct and necessary geometric role. This does not claim that no possible likelihood-based architecture could ever learn communication; it falsifies this line of SPS variants.
• Reward-free communication self-organizes under two-observer necessity (v15): the philosophy change and new hypothesis. Two partial observers of a shared latent, each predicting the OTHER's half on the decoupled agree_comm world (u_A = self_A + cB_t v0 + sA_t eps w0, A predicts B's half cB, B predicts A's half cA; A's local state is leak-free of cB). Objective L = L_center^A + L_center^B + λ L_agreement(z_A, z_B) where L_center is a direct MSE on the shared center through the message translation T(m) (non-lazy — covering modes cannot satisfy it) and the agreement is InfoNCE + cross-predictive head on latents z = Z([present; message]). The honest result is a qualified YES: the learned message is causal — center error learned 0.323 < none 0.368 < shuffled 0.402 (seed mean), the message carries the sender's half (c_reg R² ~0.16, far above the v14 ~0.01), and a donor swap (replace only the partner message) moves the predicted center toward the donor's shared state while shuffled loses the benefit. Two honest caveats: (1) the agreement term aligns the latents (InfoNCE > 0.99) but does NOT improve center error beyond the future regression alone (no-agree ≈ learned) — the discovery is carried by the direct future-necessity, the agreement is a secondary alignment signal; (2) the 2-dim oracle code cannot express the 3-dim position-dependent cB v0 target, so oracle ≈ none — a channel limitation, not an architecture failure. Verdict: reciprocal partial- observation necessity — each cell's future prediction depends on the other's half — is what supplies the credit a single observer's consequence could not; the two-observer structure reopens reward-free communication after the single-observer line closed.
• Agreement can organize representations, but useful communication still requires the future regression (v15.1): the agreement load-bearing test. Four conditions on agree_comm: future-only, future+agreement (v15), agreement-only, and agreement-only on DISCONNECTED pairs. The agreement-only result is the locked middle interpretation: (1) agreement alone DOES align the two observers' representations for real — paired latent similarity 0.98/0.97 vs shuffled ~0.0, healthy variance and effective rank ~1.9 (not a constant collapse, not a per-sample fingerprint that agrees both ways); (2) but the aligned messages are semantically empty for the future center — a fresh tangent-aware linear receiver readout of the messages predicts the center at R² ≈ 0.00/0.03 (no better than no-message), vs R² 0.13/0.14 for the full v15 objective, and the sender's half stays at v14 noise in the message (c_reg ~0.04 vs ~0.13-0.16); (3) the disconnected control collapses exactly as expected (latent variance 0, paired agreement == shuffled agreement == 1.0) — proving condition 3's alignment is genuine pairing, not generic distributional similarity; and (4) plain future-only training already produces more useful messages than agreement-only (readout +0.09/+0.12). Verdict: the agreement term can organize compatible representations, but useful communication semantics still require the direct reciprocal predictive necessity of the future regression.
• The spherical memory container is boundedness, not intelligence (v16): the research-note hypothesis "a spherical state-transition system as a persistent world model/memory layer" has a testable core — does storing the persistent memory on the sphere (normalized to S² at every update) change learning dynamics vs an identical unconstrained Euclidean vector memory? The ablation (same BenchSkew cell, same capacity, same world, same seeds; only observe() differs) answers NO: on the stationary Markov control the two containers are equivalent (geo err 0.0084 vs 0.0095), and on a persistent- latent world (c_{t+1} = 0.95 c_t + noise hidden drift on top of the position field) the Euclidean memory is strictly better (0.0837 vs 0.0926) because it stores the latent's MAGNITUDE (linear-probe R² 0.34 vs 0.04) which the unit-sphere container discards. The geometry is the container, not the intelligence — and the container restricts: it trades magnitude memory for norm stability. A transformer-adjacent persistent-memory layer built on sphere normalization inherits this tradeoff unless it keeps an explicit magnitude channel.
• The memory magnitude limb is the gain; the polar decomposition is not (v17): the polar repair — the Euclidean memory read as direction-on-S² + radius — tested against five containers of equal effective budget (euclid, sphere, polar, euclid4 dead-dimension control, euclid-nm = raw vector + explicit norm feature WITHOUT any sphere geometry) on four worlds (dir / mag / both / noise; 3 seeds). The explicit magnitude limb is the ENTIRE gain: euclid-nm beats plain euclid on the magnitude world and the both-world on every seed. The polar decomposition adds nothing over the limb: euclid-nm ties polar on mag and beats it on both (all seeds) — forcing the direction onto S² is at best neutral. The pure-sphere container is the worst on all four worlds, including the direction-structural and noise worlds, and the dead-dimension control never beats euclid (the gains are not the extra parameter). Verdict: polar as a distinct mechanism is dropped; the justified component is the magnitude limb on the Euclidean memory. The design principle sharpens: the memory's problem was missing magnitude, not missing sphere geometry.

python3 -m pytest -q      # 149 tests (~145 min; ofamily + v9/v10/v13/v14/v15_1 are the long poles)
ruff check .              # lint (E, F, UP, B; line-length 100)
python3 -m scripts.run_benchmarks --quick   # regenerate the canonical result tables (~6 min)
python3 -m scripts.render_illustration      # animated illustration of interacting agents (writes assets/sps_demo.gif)
python examples/01_adaptive_dynamics.py   # component recipe 1 (~5 min)
python examples/02_distributional_prediction.py
python examples/03_bounded_communication.py
python3 -m research.progressive_complexity        # complexity selection demo
python3 -m research.couple_partial_observation             # two-cell coupling demo (~4 min)
python3 -m research.comm_learned_channel               # learned-communication demo (~4 min)
python3 -m research.shared_language             # shared-language demo (~8 min)
python3 -m research.novelty_benchmark            # novelty benchmark vs generic models (~15 min)
python3 -m research.ofamily_boundary            # out-of-family boundary test (~50 min)
python3 -m research.v09_adaptive_residual                 # adaptive structured+residual becoming (~20 min)
python3 -m research.v09_transfer_boundary        # gate-transfer boundary check (~20 min)
python3 -m research.v10_distributional_futures                # distributional futures (mixture over futures) (~10 min)
python3 -m research.v10_calibration    # v10.1 calibration sweeps (pi follows p, separation, noise) (~30 min)
python3 -m research.v11_conditional_protocol                # the message chooses which future (conditional distributional) (~30 min)
python3 -m research.v11_2_persistent_cause              # persistent hidden cause: does communication self-organize? (~25 min)
python3 -m research.v12_protocol_maintenance                # maintenance vs discovery: can consequence-only hold a placed protocol? (~35 min)
python3 -m research.v13_contrastive_consequence                # contrastive pairing: the relative consequence-only objective fails too (~35 min)
python3 -m research.v14_geometric_translation                # geometric conditioning: the message translates the center - consequence-only still fails (~35 min)
python3 -m research.v15_reciprocal_necessity                # two-observer agreement: reward-free communication self-organizes under reciprocal necessity (~50 min)
python3 -m research.v15_1_agreement_ablation              # agreement ablation: agreement aligns, future necessity communicates (~25 min)
python3 -m research.v16_memory_container                # memory container: sphere-bound vs Euclidean persistent memory (~8 min)
python3 -m research.v17_magnitude_limb                # polar memory vs magnitude limb: the limb is the gain, polar is not (~45 min)
python3 -m research.harmonic_excess_capacity  # excess-capacity diagnostics (~2-3 min)

The demos share world parameters between train and eval splits (a past bug produced nonsense errors by not doing so). Tests need adequate budgets — small configs (~32×16 / 1200 steps) leave 2–3e−3 residuals; use ~B=48×T=24 and 3000–4000 steps. Tests are order-independent: conftest.py reseeds torch/python RNG before every test, and world generators draw from explicit torch.Generator(seed) instances, so P(suite failure from ordering) = 0.