1 Introduction↩︎

1.1 The Code World Model paradigm↩︎

A central observation in recent work on LLMs for game playing is that a small language model plus a well-specified world model plus classical search can outperform a much larger model used as a direct policy. The Code World Model (CWM) paradigm makes this concrete: an LLM is prompted with a game’s rules and some sampled trajectories and asked to synthesize a fully executable implementation of the game’s transition dynamics. A classical planner — typically Monte Carlo Tree Search (MCTS) [1] — then searches over the synthesized world model, interacts with a referee (the true game), and is evaluated in an arena.

We reproduce this baseline on tic-tac-toe and Connect Four (Section 3.1): LLM-synthesized CWMs refined to transition accuracy 1.0 and paired with UCT-MCTS (Monte Carlo tree search with the UCT—upper confidence bounds applied to trees—selection rule [2]) dominate the same LLM used as a direct policy by wide margins (e.g., 29–1 in Connect Four), reproducing the direction of the result in [3] on known games. Synthesis is trivially cheap: total API cost across all runs in this paper is approximately $2, with roughly $0.001–0.005 per arena game for the LLM-as-policy baseline and synthesis a one-off cost.

1.2 The implicit trust step↩︎

Accepting a synthesized world model involves a gatekeeping step: the CWM is refined in a sandbox until it achieves transition accuracy 1.0 on a set of randomly sampled trajectories. This gate is computationally cheap and is the only barrier between synthesis and deployment in the planner.

Our central question is: does passing this gate certify that the CWM is adequate for planning?

The concern is structural — it arises from the setup itself, not from any particular model or random draw (Figure 1). A planner does not play randomly — it concentrates search on states it deems strategically significant. If the random-trajectory gate and the planner’s search distribution diverge systematically, there could exist a CWM that passes the gate yet is wrong precisely on the states that matter for competent play. We call this the verified-vs-correct gap.

1.3 A first look: when the gate is identifying↩︎

Our first experiments, across three game families and two knowledge regimes (rules given / rules withheld), find that the feared gap does not appear on small, fully-specified games (Section 3.2). Whenever a CWM passes the random-trajectory gate, it is also correct on the MCTS-visited distribution; whenever it is wrong on the search distribution, it also fails the gate. For these games the random sample is identifying — no compact wrong hypothesis fits all training trajectories yet diverges elsewhere. This is an honest null result, and we report it as such, because understanding when the gate is identifying is necessary to understand when it is not.

1.4 When the gate fails: rare rules and the danger law↩︎

The null result on small games points to the condition under which the gate can be fooled: a rule that random play almost never triggers but competent play reliably seeks out. We engineered a minimal instrument satisfying this condition (Section 3.3): a variant of the game army5x5a augmented with a material-at-cap tiebreak rule whose material-terminal rarity under random play is 2.5% (the rate at which the rule decides the game) yet which decides roughly 50% of competent games.

A CWM that omits this rule passes the gate at transition accuracy 1.0 and is \(\geq 98\%\) state-accurate on the search distribution, yet is systematically outplayed (win rate 0.404 [0.384, 0.424] vs fair baseline 0.495 [0.475, 0.515], Wilson 95% intervals, n=4800; it loses 1.6 games for every one it wins). State accuracy is blind to the omission (dilution: the handful of wrong states is averaged into a large pool of correct ones, so the aggregate barely moves); play is not.

We then quantify when this can happen via a law that relates harm to gate size and rule rarity (Section 4), and show that the gap cannot be repaired by providing more example transitions (Section 5).

1.5 Extension to imperfect information↩︎

The same mechanism appears on the inference half of an imperfect-information CWM. Such a model must also implement an infer_states function — given a sequence of observations, reconstruct the set of possible hidden states — and this function is gated separately. We prove (Section 6) that the inference gate is identifying when the game is shallow enough, explain why poker games fall below this threshold, and construct a minimal game (Beacon) in which a verified-but-wrong infer_states passes the inference gate yet loses every game.

1.6 Contributions↩︎

This paper makes six contributions. The first three establish the perfect-information story — the gap, the quantitative law that governs it, and why it cannot be repaired by example — and the last three carry the same mechanism onto imperfect-information CWMs and unify the two halves of the contract:

1. The verified-vs-correct gap (Section 3.3): A gate-passing, \(\geq 98\%\)-state-accurate CWM that is systematically outplayed (win rate 0.404 [0.384, 0.424] vs fair baseline 0.495 [0.475, 0.515], Wilson 95% intervals that do not overlap, n=4800; 1.6 losses per win). The gap arises from a rare-but-pivotal rule omitted from the specification and invisible to random-trajectory sampling. We also document the honest null — small fully-specified games show no gap — which clarifies the boundary conditions.

2. A quantitative danger law (Section 4): \(\mathrm{danger} = \mathrm{play\_cost} \times (1 - \mathrm{rarity})^N\). The \((1 - \mathrm{rarity})^N\) gate-miss factor is proven exact under i.i.d.Bernoulli sampling (Proposition 1); \(\mathrm{play\_cost}\) is empirical — but not opaquely so: we prove the upper bound \(\mathrm{play\_cost} \leq \mu_{\mathrm{query}}(E)\), the planner’s query-hit mass of the error region (Proposition 2), certify a lower bound by witness (\(\geq 0.065\) at seed-clustered 95%), and prove the exact value \(\tfrac12\) on Beacon (Proposition 4), leaving only the exact constant at scale empirical. The law predicts a threshold below which verification is safe and above which harm saturates at the full play cost.

3. Translation, not inference (Section 5): LLM CWM synthesis behaves as rule translation under the tested regimes. Across the two model sizes tested (mini, large) and every data regime we ran (naive DAgger, proper DAgger, targeted on-manifold examples), the omitted rule was not recovered from example transitions. Artificial off-manifold repair data actively corrupts synthesis.

4. The coverage bound (Section 6.2, Theorem 1) and Beacon (Section 6.4): We prove that a size-\(N\) random inference gate is identifying when \(N \gtrsim b^{d_{\max}} \cdot p_{\text{chance}}^{-1} \cdot \log|\mathcal{I}|\) — where \(b\) is the per-info-set branching factor, \(d_{\max}\) the maximum player-action depth, \(p_{\text{chance}}\) the smallest deal probability, and \(|\mathcal{I}|\) the number of reachable info-sets (all defined in Section 6.2) — which explains the absence of an inference gap in Kuhn and Leduc. We complement it with an enumeration-free certificate (Theorem 2): any gate-passing inference function has undetected-error hit mass \(\leq \ln(1/\delta)/N\) under the gate’s sampling distribution — a bound whose constants involve no enumeration of info-sets, hence apply to games of arbitrary size, at the price of certifying bounded error mass rather than full coverage. We then construct Beacon, the minimal game that escapes the coverage bound (and realizes the reach-ratio blow-up that makes the error-mass certificate’s transfer to play vacuous), obtaining 0/8156 gate mismatches alongside 0.000 play win rate.

5. The belief model is invisible to a transition gate (Section 6.6): We prove (Proposition 5) that the information partition encoded by observation/infer_states appears in no transition tuple, so a transition-accuracy gate cannot detect a wrong belief model. We demonstrate it on masked tic-tac-toe: withholding the masking rule yields a transition-gate-perfect (1.000) but belief-wrong (observation_rate 0.020, inference_rate 0.180) synthesis, with a synthesized single-seed corroboration on Beacon (transition gate 1.000, inference_rate 0.000). With Beacon, this gives both faces of belief-model verification — a wrong belief can lose at play and is invisible to a transition gate.

6. Unification (Sections 6, 7): The verified-vs-correct gap and the inference gap are one mechanism on two halves of the CWM contract. A size-\(N\) random gate fails exactly on events of random-reach probability \(\lesssim 1/N\) that competent play nonetheless reaches; the harm is \((\text{consequence}) \times P(\text{gate miss})\), with \(P(\text{gate miss}) \approx e^{-Nr}\) for transition rules and \(\approx e^{-N \cdot p_{\text{chance}} \cdot b^{-d_{\max}}}\) per inference info-set.

2 Setup and Methods↩︎

2.1 The CWM contract↩︎

A Code World Model is a Python module implementing the following interface (the contract):

• initial_state()\(\to\)state — returns the starting game state.

• legal_actions(state)\(\to\)list[action] — returns the list of legal actions.

• apply_action(state, action)\(\to\)state — returns the next state.

• is_terminal(state)\(\to\)bool — returns True if the game is over.

• returns(state)\(\to\)list[float] — returns the utility vector (only valid on terminal states).

Each state is a Python dictionary containing at minimum board and current_player fields. For imperfect-information games (Section 6) the contract is extended with:

• observation(state, player)\(\to\)obs — returns the observation available to a player at a state.

• initial_states(obs, player)\(\to\)list[state] — returns all states consistent with a first observation.

• infer_states(history_obs, player)\(\to\)list[state] — returns all states consistent with a sequence of observations.

This contract mirrors the minimal interface required by UCT-MCTS for perfect-information games and determinized MCTS for imperfect-information games.

2.2 Synthesis and the gate↩︎

An LLM (Azure OpenAI Global Standard deployments gpt-5.4, gpt-5.4-mini, gpt-5-nano; snapshot gpt-5.4-2026-03-05) is prompted with the game’s RULES_TEXT and a set of random-policy trajectories. The prompt asks the model to synthesize a complete Python module implementing the contract.

The synthesized module is then refined in a sandbox: a referee evaluates the sampled trajectories through both the synthesized CWM and the ground-truth oracle, and any discrepancy produces an error message fed back to the LLM for correction. Unless otherwise stated, refinement re-uses the same trajectory sample each iteration (the synthesis-pipeline study of Section 5 is the exception — there refinement draws a fresh batch each iteration). Refinement continues until the synthesized CWM achieves transition accuracy 1.0 on the trajectory sample, or until a refinement budget is exhausted. Passing this test we call passing the gate.

Transition accuracy is the fraction of (state, action, next-state) tuples from randomly sampled play-throughs on which the synthesized CWM agrees with the ground truth. This is the gate’s own lens; Sections 3 and 4 argue it is the wrong lens for play-adequacy.

For imperfect-information games, an analogous inference gate measures accuracy on the infer_states function over the observations generated by random play.

2.3 Planning↩︎

For perfect-information games, planning uses UCT-MCTS with a configurable simulation budget (200–600 per move, depending on the experiment; see individual sections). The planner operates entirely on the synthesized CWM and never queries the true game during search; only the arena referee is the true game.

For imperfect-information games, planning uses determinized MCTS: at each decision point, the planner samples a set of possible hidden-state completions from infer_states, runs UCT-MCTS on each determinization, and aggregates votes [4], [5]. The planner is hardened to tolerate a faulty infer_states (raising exceptions, returning empty lists) via a legal-fallback mechanism, ensuring arena runs do not abort when the CWM is deliberately instrumented to be wrong.

Two alternatives deserve a word on why they are not the deployed planner. ISMCTS [4] is the natural CWM-compatible refinement of determinization-per-decision; we use the simpler variant to reuse the perfect-information harness, not because it is preferable — a choice that is, if anything, conservative for the Beacon result (Beacon is pure disambiguation, the regime where ISMCTS most cleanly outperforms determinization, so the gap would be at least as clean under ISMCTS). CFR [6] is the equilibrium standard; it is not the deployed planner but we do run it as an analysis tool — cwm.cfr implements external-sampling MCCFR [7] and full-tree CFR+ [8] over the same contract, used in Section 6.2 to measure coverage against equilibrium reach.

Throughout the paper, competent play denotes play under the deployed planner \(\Pi\) (UCT-MCTS for perfect information, determinized MCTS for imperfect information, at the stated simulation budget). It is a heuristic proxy for skilled play, not an equilibrium strategy: “competent” should be read as “what the deployed planner does,” never as “optimal.” All gap, danger, and reach statements below are made with respect to this deployed-planner distribution unless we explicitly say “equilibrium.”

2.4 Metrics↩︎

We distinguish two families of metrics throughout the paper:

The gate’s lens (prediction accuracy):

• Transition accuracy — agreement rate on (state, action, next-state) under random play.

• State accuracy — fraction of states in a distribution where the CWM agrees with the ground truth on all contract outputs. Write \(\mathrm{agree}(D)\) for state accuracy measured on distribution \(D\); below, \(D_{\text{gate}}\) is the random-trajectory (gate) distribution, \(D_{\text{cwm}}\) the distribution the synthesized CWM’s own planner visits, and \(D_{\text{truth}}\) the distribution the ground-truth planner visits.

• gap (a.k.a.gap_cwm) — \(\mathrm{agree}(D_{\text{gate}}) - \mathrm{agree}(D_{\text{cwm}})\): how much more the CWM agrees with the truth where it was verified than where it actually plays. This is the quantity the verified-vs-correct gap is about.

• gap_truth — \(\mathrm{agree}(D_{\text{gate}}) - \mathrm{agree}(D_{\text{truth}})\): the same difference but against the ground-truth planner’s visited distribution rather than the CWM’s own.

• gap_max — the maximum of gap across the synthesis seeds of a condition (its worst-case value, used when we report “gap \(\approx 0\), gap_max \(0.016\)”).

• observation_rate — fraction of sampled (state, player) pairs on which the synthesized observation returns the ground-truth observation; the discriminator for a correct belief model (Section 6.6).

• inference_rate — fraction of sampled observation histories on which the synthesized infer_states returns exactly the ground-truth set of consistent states. For both belief-surface rates, a crashing synthesized function is a synthesis-robustness failure, not a wrong belief: execution errors are excluded from the rate denominators and reported separately, so a rate scores only the cases that actually ran (a wrong-but-running output still counts as a mismatch).

The decision-relevant lens (play performance):

• Win rate — fraction of games won by the CWM+MCTS agent versus a ground-truth+MCTS opponent in an arena refereed by the true game, counting draws as \(\tfrac12\) (the per-game score is \(X \in \{0, \tfrac12, 1\}\)), with Wilson score 95% confidence intervals [9] computed as if the score were binomial. The binomial treatment is conservative, not an approximation error: a \(\{0, \tfrac12, 1\}\) score with mean \(p\) has variance \(p(1-p) - \tfrac14 P(\mathrm{draw}) \leq p(1-p)\), so the reported intervals are never too narrow, and every CI-separation claim below holds a fortiori.

Fairness baselines are established by running truth-vs-truth arenas (ground-truth+MCTS against itself), which should produce win rates near 0.5 for balanced games. Deviations from 0.5 in the fairness baseline indicate start-order imbalance or search-budget asymmetry; we report them alongside each play result.

2.5 Experimental configuration↩︎

Table 1 collects the fixed components of the pipeline so the experiments are reproducible from the paper alone; per-experiment quantities (simulation budget, gate size \(N\), game) are stated in each section, and the full harness is in docs/EXPERIMENTS.md and the cited scripts.

2.5.0.1 Note on the exploration constant.

We use \(c = 1.41 \approx \sqrt{2}\), the canonical UCT value [2], as a fixed convention rather than a tuned hyperparameter — search strength is set by the simulation budget, and the planner serves only as a reproducible fixed-strength instrument. The \(\sqrt{2}\) constant is derived for rewards in \([0, 1]\); our returns lie in \(\{-1, 0, +1\}\), so a strictly range-calibrated value would be \(\approx 2\sqrt{2}\). We verified that this does not affect the reported quantities: across the perfect-information games, \(c = 1.41\) and \(c = 2\sqrt{2}\) yield identical win/draw/loss outcomes against fixed opponents (uniform-random and, on tic-tac-toe, a perfect minimax solver) at 200–600 simulations, and on Beacon — the adversarial instrument for the coverage gap — the planner follows an identical forced line under both constants. Trajectories on the open games diverge only by selecting among equally-optimal moves, leaving play strength and gap measurements unchanged, so no re-run with a recalibrated constant is needed.

2.6 Games↩︎

We use the following games, selected to span known, novel, and partially-known regimes:

• Tic-tac-toe — well-known; used to verify the CWM paradigm.

• Connect Four — well-known; used to verify the paradigm and as a negative control for the danger law.

• Generalized tic-tac-toe 6\(\times\)​6 win-4 — a parameterized variant (\(m,n,k\) game with \(m=n=6\), \(k=4\)); model has some prior knowledge.

• army5x5a — a generalized chess game from the DeepMind CWM paper (arXiv:2510.04542, Appendix H.5): a 5\(\times\)​5 board with infantry, cavalry, and general pieces, win by capturing the opponent’s general. The paper’s public release (arXiv, 2025-10-06) post-dates the GPT-5.4 knowledge cutoff (2025-08-31), so army5x5a falls outside the training window; a declarative probe independently confirmed the model does not know the detailed movesets — asked to state the board size, piece counts, movement offsets, win condition, and starting position or decline each explicitly, the model answered “I do not know” to all five parts, while a positive-control question on Kuhn poker in the same session was answered with complete, correct recall (question and full response persisted in results/declarative_recall_probe.json; scripts/declarative_recall_probe.py) — making it a genuine translation target.

• army5x5a + material-at-cap — the above, with an added tiebreak rule: if the game reaches the ply cap (100 plies by default) with both generals alive, the player with more material wins. This is the primary instrument for the rare-rule gap.

• Trike [10] — an abstract combinatorial game in the wrong-prior regime: in a declarative probe that allows declining, the model declines to state the mechanics (“I do not reliably know,” all five parts; results/declarative_recall_probe.json), yet a no-rules synthesis produces confidently wrong mechanics that fail the gate in every seed (0/5, Section 3.2) — the wrong prior manifests under synthesis pressure, not in declarative recall. Real rules: place a disc on an empty cell on the shared pawn’s line, then move the pawn to that disc; game ends when the pawn is surrounded; score = discs adjacent to the pawn.

• Kuhn poker [11] — a minimal imperfect-information game; used to validate the imperfect-information pipeline.

• Leduc poker [12] — a slightly larger poker game (6-card deck, community card, two betting rounds); used for the coverage-bound corollary.

• Beacon — a minimal game constructed specifically to instantiate the positive imperfect-information gap; described in Section 6.

Non-triviality of the novel games is confirmed empirically: MCTS beats random play from both sides on generalized tic-tac-toe 6\(\times\)​6, army5x5a, and Trike with zero losses (Section 3.2).

2.7 Cost↩︎

API synthesis is trivially cheap: approximately $0.043–$0.135 per game family for the known-game runs; roughly $0.81 total for the gap-grid across three games and ten seeds. The CPU bottleneck is MCTS. For the danger law (Section 4) we exploit the fact that \(\mathrm{play\_cost}\) is approximately constant by measuring it precisely once at scale (240 games, 600 simulations) and sweeping \(\mathrm{rarity}\) cheaply (3000 random games per cap setting, no MCTS required). All results and reproduction commands are in docs/EXPERIMENTS.md.

3 The Gap: Accuracy \(\neq\) Play-Adequacy↩︎

3.1 Known games reproduce the paradigm but do not stress the gate↩︎

LLM-synthesized CWMs on tic-tac-toe and Connect Four pass the transition gate in 0 refinement iterations and play at well above baseline performance. For completeness (Table 2):

The CWM+MCTS agents dominate the direct LLM policy, replicating the paradigm’s core claim. That these models reach transition accuracy 1.0 in zero refinements is itself revealing: on well-known games, the model is almost certainly recalling the rules rather than inferring them from trajectories. Here “accuracy 1.0 on sampled trajectories” likely coincides with global correctness for the right reason — but that coincidence says nothing about whether the gate is reliable in general.

3.2 The state-agreement gap does not appear on small complete-rules games↩︎

To measure the gap properly, we ran a grid across three knowledge regimes and two model sizes (5 synthesis seeds each, 20 self-play games, 300 simulations, train-games 40; Table 3):

We report this as an honest null. In every regime the outcome is binary: either the CWM is correct on every evaluated state (no observed divergence on the gate, search, and truth-search distributions), with gap \(\approx 0\), or it fails the gate entirely. No CWM passes the gate yet is wrong on the MCTS-visited distribution. The same pattern holds in a --no-rules variant (synthesis from trajectories alone, with RULES_TEXT withheld): gen_tictactoe passes in 2/5 seeds via recall, with gap 0; army5x5a and Trike fail the gate entirely (0/5).

For the one game small enough to enumerate, gate-passing certifies global correctness on reachable states — a proof, not just an observation. On tic-tac-toe we synthesize a CWM, confirm it passes the random gate (accuracy 1.0), then check it against the truth over the entire reachable state space by breadth-first enumeration (5478 reachable states, 16167 transitions): zero mismatches on the search-relevant relation — legal_actions on non-terminal states, apply_action on every (state, legal action), is_terminal, and returns (scripts/exhaustive_verify_tictactoe.py). (The enumeration also surfaces 880 legal_actions-on-terminal-state divergences — the synthesized code omits the is_terminal guard — but a planner never queries legal_actions on a terminal state, so these are a behaviourally-irrelevant convention artifact, excluded exactly as the gap measurement does.) This is the transition-function analogue of the inference-side coverage bound we prove later (Section 6.2): when the check covers the whole reachable relation, passing it certifies global correctness by exhaustion. For the larger games the reachable space is too large to enumerate cheaply — Trike side-6 alone exceeds 3 million reachable states (measured), and army5x5a and generalized tic-tac-toe \(6\times6\) are far larger — so there the null is a statement about the evaluated distributions, not a proof; consistently, army5x5a (the largest) is the one game with a tiny residual (gap 0.002).

The diagnosis: for small, fully-specified games, the random-trajectory sample appears identifying on the evaluated distributions — no compact wrong hypothesis we observed fits 40 random trajectories yet diverges on the search distribution (proven by exhaustion for tic-tac-toe; an empirical statement on the evaluated distributions for the larger games above). The gate is not weak in these regimes; it is identifying. This makes the gap harder, not easier, to construct: we need a game where random and competent play genuinely diverge.

The null is informative in a second way: it shows that the binding constraint on small games is gate-attainability, not gap size. nano fails army5x5a outright (0/5 gate passes) because the action encoding (a from*25+to integer plus a ply counter) is representationally complex; mini handles it (4/5). The knowledge regime matters less than model scale and encoding complexity — consistent with the translation hypothesis (Section 5).

3.3 The rare-rule instrument: verified but wrong at play (headline result)↩︎

The null result on fully-specified games points to the necessary condition for a gap: a rule whose random-play incidence is near zero but whose competent-play incidence is high. We searched for such rules systematically.

3.3.0.1 The rarity\(\leftrightarrow\)consequence frontier.

We tested six rules across Connect Four and army5x5a (rarity = fraction of random games the rule decides; consequence = performance change between rule-aware and rule-blind MCTS on the true game; Table 4):

Across our six-rule probe set, the pattern is that anything a planner can force, random play also stumbles into. Connect Four admits no rule in the rare-and-consequential quadrant. A random-vs-MCTS game-length measurement (scripts/divergence.py) confirms the diagnosis: army5x5a stands out — under competent self-play, 43% of games run to the 100-ply cap versus 3% under random play (mean length 52 vs 32 plies; the competent length distribution is strongly bimodal — quick decisive wins or cap-length maneuvering) — while Trike and generalized tic-tac-toe behave like Connect Four (no such divergence). The median game length is unstable under this bimodal distribution; the cap-hit rate is the robust signature, and it is the one the instrument construction relies on. A game where random and competent play visit very different parts of the state space is the necessary substrate.

3.3.0.2 The instrument.

We constructed a variant of army5x5a with a material-at-cap tiebreak rule: if the game reaches the ply cap (100 plies) with both generals alive, the player with more pieces wins (rather than drawing). Two rates matter and we keep them distinct. The cap is reached in 5.2% of random games (most are equal-material draws the rule leaves unchanged); the rule’s material-terminal rarity — the rate at which the material-at-cap branch produces a decisive, gate-observable result — is \(r = 0.0253\) (76 of 3000 random games; \(\approx 2.5\%\)). The danger law (Section 4) uses this material-terminal rarity. The same rule decides approximately 50% of competent games. Implementations: groundtruth/gen_chess_material.py with paired specifications army5x5a_material (complete rules) and army5x5a_material_incomplete (base rules, omitting the material-at-cap tiebreak).

3.3.0.3 State accuracy is the wrong lens for play-adequacy.

A CWM that omits the material-at-cap rule passes the gate (transition accuracy 1.0), and the gap_truth is approximately 0 across all seeds (Table 5):

The gate-passing-but-rule-blind seeds correspond to the event that the rule is absent from the \(N \approx 40\) training trajectories, which has probability \((1-r)^N\) (Proposition 1, Section 4). Here the training sample doubles as the gate, so the proposition is instantiated at \(N \approx 40\). On this event the sample is consistent with both the rule-bearing and the rule-omitting world model, so by the sample-identifiability argument (Section 5) the rule is unidentifiable and the rule-blind CWM is admissible. When the rule does appear in the sample — probability \(1-(1-r)^N\) — synthesis is not guaranteed to encode it (Section 5 shows examples do not reliably teach the rule); the observed seeds are consistent with the same Bernoulli miss mechanism. Here \(N\) is the training sample rather than a separate validation gate.

The divergence region (ply-cap states with unequal material) is less than 1% of visited states, and symmetric MCTS self-play tends toward equal material, so the states where the rule-blind CWM is wrong are barely sampled — they are too small a fraction of visited states to move the aggregate state-accuracy number.

3.3.0.4 Play performance is the decision-relevant lens.

We report play in two clearly separated panels: a budget-matched, instrumented, CI’d headline (Panel A) and a budget-matched, CI’d synthesized-pipeline replication (Panel B). We deliberately do not pool instrumented and synthesized evidence into one number.

3.3.0.5 Panel A — budget-matched, instrumented, CPU-only (the headline causal claim).

Identical budget across arms (\(n = 2400\) games per arm — 20 seeds \(\times\) 120 games per seed per arm, 4800 games in total — at 600 simulations), arena refereed by the true game (army5x5a + material-at-cap), measured via scripts/play_cost_ci.py / scripts/play_cost_blind3.py (Table 6, visualized in Figure 2):

play_cost = 0.091 (the fair-baseline win rate minus the rule-blind win rate). The Wilson 95% intervals do not overlap (fair lower bound 0.475 \(>\) rule-blind upper bound 0.424): the two intervals are CI-separated — they share no common value, so the gap is not a sampling artifact. We use “CI-separated” throughout for this non-overlap of 95% confidence intervals.

3.3.0.6 Seed-clustered inference (the seed, not the game, as the unit).

The Wilson intervals above pool games and so treat each game as independent. Because games within a seed share a synthesis/instrument draw and an RNG stream, we also report a more conservative analysis that takes the seed as the independent unit. The paired-by-seed difference (which cancels start-side and budget effects, identical across arms) has mean \(0.091\) with a Student-\(t\) 95% interval of \([0.065, 0.117]\) over the twenty seeds (\(\mathrm{sd} = 0.055\), \(\mathrm{df} = 19\)), excluding zero (Table 7). Per-seed differences range from \(0.00\) (two seeds) to \(0.19\), so the effect is heterogeneous across seeds — and survives the clustering anyway. As a stability check, the estimate is robust to the seed budget: runs at 3 seeds (\(n=360\): fair 0.493, blind 0.376), 5 seeds (\(n=600\): 0.507, 0.376, play_cost \(0.131~[0.083, 0.179]\)), and 20 seeds (\(n=4800\), the numbers above) each yield a point estimate inside the preceding run’s interval.

The rule-blind agent is hand-written base army5x5a. Two distinct equivalences are at work and we keep them separate. (i) Base-vs-truth isolates the rule’s play cost by construction: both arms are exact hand-written games that differ only in the material-at-cap rule, so the contrast is exact at any budget without invoking the LLM. (ii) The bridge to the synthesized pipeline is empirical, not proven: base is play-equivalent to the incomplete synthesized CWM only up to the measured gap_cwm \(\approx 0\) (a tiny residual — gap_max \(0.016\) on one seed, Section 3), not by a proof of functional equivalence outside the rare region. This is why the headline causal claim rests on an instrumented, budget-matched, CI’d comparison rather than on the synthesized runs; Panel B then shows the synthesized pipeline reproduces the play deficit in direction and mechanism, with its own confidence intervals, at Panel A’s budget (at a larger magnitude — see Panel B).

3.3.0.7 Panel B — LLM-synthesized pipeline, at Panel A’s budget, with CIs.

We ran the actual synthesis pipeline (GPT-5.4-mini) at Panel A’s budget — 20 seeds, 120 games/seed, 600 simulations, refinement capped at 5 iterations (scripts/play_cost_synth_ci.py) — synthesizing an incomplete-rules and a complete-rules CWM per seed against the same paired fair baseline. Unlike the hand-written instrument, a synthesized incomplete CWM is rule-blind only when a material-at-cap terminal is absent from its gate sample; when such a terminal is present the material-region transitions are inexplicable to a program that omits the rule, so the gate cannot reach \(1.0\). This is exactly what we observe, and it is the identifiability event made concrete (Table 8):

5pt

The synthesized incomplete CWM, whenever it passes the gate, loses at play with \(\mathrm{play\_cost} = 0.154\) (\([0.135, 0.173]\), seed-clustered over the 9 gate-passing seeds, excluding zero; every one of the 9 is positive, \(0.11\)–\(0.19\)), against the paired fair baseline over those same seeds (\(0.499\)). This replicates Panel A’s finding in direction and mechanism — a positive play deficit whose seed-clustered CI excludes zero — measured end-to-end through synthesis rather than a hand-written instrument. The magnitude is larger, not equal: Panel B’s \([0.135, 0.173]\) is disjoint from Panel A’s isolated rule cost (\(0.091\), \([0.065, 0.117]\)), as expected, since the synthesized program can carry imperfections beyond the omitted rule — so the end-to-end harm is at least as large as the rule’s isolated cost. The gate-pass structure is itself the finding: gate-passing coincides almost perfectly with material-terminal absence (9/9),¹ so material-terminal absence is necessary for the gate to pass here (though not sufficient — seed 11 fails for the synthesis reason above); the harm operates through the sampling-miss event of the danger law (Section 4), and when a material-terminal is sampled the gate rejects the rule-omitting program rather than certifying it. The complete-rules control is near parity (a small residual deficit, \(\mathrm{play\_cost}\;0.024\), whose 95% CI just excludes zero).

3.3.0.8 Summary.

A world model can pass transition-accuracy verification (gate 1.0), be \(\geq 98\%\) state-accurate on its own search distribution and exactly correct (gap_truth = 0) on the truth-planner distribution, and yet lose systematically at play — because the less than 1% it gets wrong is exactly the pivotal tactic. Transition and state accuracy are the wrong adequacy criteria for planning; play performance is the right one.

4 A Quantitative Law of Sampling-Verification Harm↩︎

We now characterize when the harm from a sampling gate is large. The key observation is that a gate of \(N\) random play-throughs fails to observe a rule that fires with probability \(r\) per play-through with exact probability \((1 - r)^N\). We formalize this gate-miss probability and measure the remaining empirical component.

It is worth stating up front exactly which channel of harm this law captures, since the paper documents three and only one is governed by the law. (a) The gate-miss channel: the gate never observes the rule, with probability \((1-r)^N\) — proven exact below. (b) The play-cost channel: conditional on the rule being absent from the synthesized model, how much a competent opponent can exploit the omission — measured empirically (\(\mathrm{play\_cost}\)). The danger law is the product of channels (a) and (b): the gate-miss probability times the play-cost. (c) A distinct synthesis-residual channel, which the law does not model: even when the rule does appear in the gate sample, the LLM may still fail to encode it (Section 5 shows this is the common case under repair-by-example). The law is therefore a lower bound on total harm under an idealized synthesizer that always encodes what it observes; the synthesis-residual channel is reported separately and empirically.

4.1 The gate-miss proposition↩︎

The approximation \(e^{-Nr}\) is useful for intuition but the exact expression \((1-r)^N\) is what the table below uses.

4.1.0.1 What \(N\) counts.

\(N\) is the number of distinct, independent i.i.d.uniform-random play-throughs the verification pipeline actually draws that could reveal the rule. The proposition is agnostic to which pipeline stage a draw belongs to, but only fresh draws count — re-using the same trajectories does not increase \(N\). In our synthesis pipeline the draw is a single set of training trajectories that doubles as the gate: refinement re-checks the same trajectories (it collects no new games and so contributes nothing to \(N\)), and we run no separate held-out validation gate. We verified this against the implementation. The numerical instances therefore are: in the Section 3/Section 3.3 gap grid \(N \approx 40\) (the training trajectories are the gate, refinement reuses them); Beacon (Section 6.4) draws a separate gate of \(N = 2000\); the danger-curve sweep below reports \(N \in \{20, 40, 80\}\).

The \((1-r)^N\) factor is exact (Proposition 1); \(\kappa\) is the empirically-measured, game- and planner-specific consequence magnitude.

Although the exact value of \(\mathrm{play\_cost}\) stays empirical, more of it is provable than the factorization above suggests. We record the provable upper bound here and collect the full picture in Remark 4.

4.2 Measured danger curve↩︎

We measure \(\mathrm{play\_cost}\) precisely once (\(\mathrm{play\_cost} \approx 0.09\)–\(0.13\) depending on sample size; the headline play_cost_ci.py run returns 0.091 at cap=100, n=4800 (20 seeds), 600 sims, with independent runs at smaller samples bracketing it: 0.131 at n=600, play_cost.py 0.117–0.121 at n=240, law_sweep 0.112 at cap=30) and sweep \(\mathrm{rarity}\) cheaply by varying the ply cap (a lower cap makes the cap-and-equal-material event more common, hence a larger firing rate \(r\); a higher cap makes it rarer). Rarity per cap is measured over 3000 random games. Results (Table 9, plotted in Figure 4a):

The result is a threshold law in rarity. Danger is approximately zero while the rule is common enough for a size-\(N\) gate to catch it (cap \(\leq 50\)), rises through a threshold as the rule becomes rare (cap 60–100), and plateaus at approximately the full play_cost once the rule almost always escapes the gate (cap \(\geq 120\)). The gate size \(N\) shifts the threshold: larger \(N\) pushes it toward rarer rules.

4.3 Why Connect Four lies safely below the threshold↩︎

Recall the six rules tested across Connect Four and army5x5a (Section 3.3). All of Connect Four’s consequential rules have rarity 0.12–0.38, giving \((1-r)^{40} \approx 0\) — they are caught by even a modest gate. army5x5a’s material-at-cap rule at cap=100 has material-terminal rarity 0.0253, giving \((1-r)^{40} \approx 0.36\) — deep in the danger zone. The structural reason is the same as before: in Connect Four, any rule a planner can force also appears regularly under random play (the rarity\(\leftrightarrow\)consequence tension); in army5x5a, competent play drives the game to the deep-ply-cap region that random play almost never reaches.

5 Repairing the Gap: Translation, Not Inference↩︎

If the gap is caused by a missing rule, can it be repaired by providing example transitions that demonstrate the rule? We ran a systematic set of repair attempts on army5x5a + material-at-cap, synthesized from incomplete rules.

5.1 Repair experiments↩︎

Table 10 reports every repair condition. All conditions use the mini synthesizer unless noted; play winrate is vs the true game, 40 arena games at 400 simulations (30 for the DAgger rows), one synthesis seed per condition; baseline 0.28, fair truth-vs-truth 0.50. Discriminating examples are transitions that involve the material-at-cap rule. The proper-DAgger condition follows Ross et al.’s dataset-aggregation scheme: each round self-plays the current (flawed) CWM, labels its game-path states with the truth, and adds them to a growing dataset (0, 3, 5, 11 discriminating transitions accumulated over three rounds); the rule is never learned despite the growing on-distribution evidence. ^\(\dagger\)One of the three rounds’ synthesis collapsed at the gate (accuracy \(0.00\)); the other two reached only \(0.994\)–\(0.997\), below \(1.0\) precisely because the aggregated dataset now contains rule-bearing transitions the rule-blind CWM cannot match — the same signal as the sweep of Section 5. (In the artificial-states condition, constructed states were validated pre-move, so a random action can equalize material or capture the general: of the 120 constructed transitions, 115 demonstrate the rule decisively — 4 end in general capture and 1 in an equal-material draw. The harvested-real condition validates post-hoc and its count is exact.) “Rule learned” is judged by code inspection (does the synthesized module contain the material-at-cap branch?) cross-checked against play parity with the complete-rules control; it is a binary structural fact about the synthesized code, not a winrate threshold. With one seed and 40 games per condition, each individual winrate carries a wide interval (e.g.\(0.28\) is Wilson 95% \([0.16, 0.43]\)); the load-bearing signal is therefore not any single cell but the consistent no-learn outcome across every repair form together with the clean parity of the complete-rules control — not a precise per-condition effect size.

5.2 Findings↩︎

5.2.0.1 Detection works, repair does not.

Verifying on the play/search distribution rather than on random trajectories drops the gate below 1.0, detecting the inadequacy that random-trajectory verification missed. But neither mini nor large can infer the missing rule from examples. Even 54 real, on-manifold discriminating transitions with 12 refinement iterations leave the gate at 0.959 and the rule unlearned.

5.2.0.2 Spec completeness, not code-writing ability, is what binds.

Given the rule in RULES_TEXT, the model encodes it correctly in 0 refinement iterations and plays at parity with the baseline (0.53 \(\approx\) 0.50). The complete-rules control isolates the cause: the limitation is not the synthesizer’s code-writing ability but the absence of the rule from the specification.

5.2.0.3 Scale helps marginally but not sufficiently — and only where there is signal to help.

The large model (0.42) exceeds mini (0.35) on real on-manifold data, but both remain far below the complete-rules baseline (0.53). The inference ceiling is not a mini-specific artifact: the marginal gain lives in the on-manifold regime, where the discriminating transitions are actually sampled and the task is generalizing observed rule-firings into code. In the unsampled regime the scale effect does not merely shrink — it is provably absent (Section 5.3): no model, at any scale, can prefer the correct rule from a sample that carries no evidence for it.

5.2.0.4 Off-manifold repair data corrupts synthesis.

Artificial (unreachable) discriminating states cause catastrophic failure in the large model (accuracy collapses to 0.004, win rate 0.05). The synthesizer attempts to fit transitions that cannot arise in real play and damages the parts of the CWM it had already learned correctly.

5.3 Sample-identifiability: the provable core of “translation, not inference”↩︎

The repair experiments above are empirical and scoped to the GPT-5.x family. They are, however, sitting on top of a result that is provable and universal — and stating it does not soften “translation, not inference” but strengthens it, by separating a theorem from a conjecture.

Let a rule \(R\) be omitted from the specification (the incomplete-rules / no-rules regime), so the only possible source for it is the trajectory sample. Let \(R\) fire on a set of play-throughs whose probability is \(r\) under the verification (uniform-random) distribution \(D\). Write \(M_R\) for the world model with \(R\) and \(M_\emptyset\) for the otherwise-identical model without \(R\); they agree on every transition except those in the rule region. The pipeline draws \(N\) i.i.d.play-throughs from \(D\) (the training sample, which is also the gate — see “What \(N\) counts,” Section 4).

This splits “translation, not inference” cleanly into a provable core and an empirical residual.

• (a) Provable, universal. When the rule is absent from the sample (probability \((1-r)^N\)), the sample provides no evidence to infer it — for any learner; this is a property of the data, not a limitation of LLMs (Proposition 3). The gap-exhibiting seeds in Section 3.3 are consistent with this event. This part is a theorem.

• (b) Empirical, LLM-specific. Even when the rule is present in the sample (probability \(1-(1-r)^N\)), the LLM synthesizer does not reliably encode it: the Section 5 repair battery (proper DAgger, targeted on-manifold examples) supplies discriminating transitions and the rule is still omitted. This is the genuinely LLM-specific, scoped finding — established under the GPT-5.x family (mini, large) across the Section 5 regimes. Its universal-for-all-models form remains a conjecture.

We measure (b) directly on the synthesis pipeline (scripts/danger_synthesis_sweep.py): synthesizing from the incomplete rules and \(N\) true-game trajectories, with refinement drawing fresh trajectories each iteration, the fraction of seeds whose CWM is rule-blind is essentially \(1\) regardless of \(N\) for both model sizes (Table 11):

On the floor. Two identifiability floors apply, and they bracket the result. The \((1-r)^N\) column is the initial-batch floor — the chance the rule is absent from the first \(N\) games. But because refinement draws fresh batches each iteration, a run that refines for \(k\) iterations is exposed to \(\approx N(1+k)\) distinct games, so the full-pipeline exposure floor is \(\approx (1-r)^{N(1+k)}\), which for the refined seeds (up to \(\sim\)​1400 games at \(N=200\), \(k=6\)) is effectively \(0\) — i.e.the rule is present in the pipeline with probability \(\approx 1\). The gate accuracy makes this concrete: at \(N=200\), no large seed reaches gate \(1.0\) (0/20), meaning the rule-bearing transitions are in every sample (the rule-blind CWM mismatches them, so the gate cannot reach \(1.0\)), yet after six refinement iterations all 20 CWMs are still rule-blind. So the result is not an instance of the unidentifiability event \(\neg E\): the rule is present (\(E\) holds) and simply not learned — the pure (b) residual. (Some seeds do reach gate \(1.0\) while blind — 6/20 mini and 3/20 large at \(N=120\) — which is the batch-miss event: refinement stops as soon as accuracy hits \(1.0\) on the current batch, and with a per-batch miss rate of \((1-r)^{120} = 0.046\) compounded over up to seven fresh batches, stopping on a rule-free batch has probability \(\approx 0.28\) — matching the observed 6/20. The \(N=200\) large column, where no seed reaches the gate, rules that explanation out for the headline cell.) Note the contrast with the main pipeline, where refinement re-checks a fixed trajectory set (Section 2.2): under fresh resampling the rule had every opportunity to appear and still was not learned.

A feedback-channel confound, found and closed. Auditing the harness surfaced a confound in the statement above: the refinement feedback truncated every failure line at 200 characters and never included the expected values — the header said “expected vs got” while the body carried neither — and the synthesis prompt shows only the first 30 transitions of the trajectory stream — a deterministic prefix that can never contain a material-at-cap terminal, whose global index is \(\geq 99\) by construction. So although the rule was present in the gate’s trajectories, it almost never reached the model in legible form: the sweep above measures the pipeline as deployed, but by itself cannot attribute the blindness to the model rather than to the harness’s feedback channel. We fixed the channel (failure lines now show expected= and got= for each mismatched field) and reran the headline cell as a discriminant experiment (scripts/refine_feedback_cell.py): with the rule’s expected returns printed in the feedback — e.g.returns: expected={1: 1.0, 2: -1.0} got={1: 0.0, 2: 0.0} on cap states with unequal material — the result is 12/12 rule-blind (6 mini + 6 large seeds, zero crashes). The signature is sharper than in the deployed-pipeline sweep: in 9 of the 12 seeds the model repairs everything except the rule, stalling at gate accuracy \({\approx}0.999\) with exactly the material transitions unfixed (the remaining three end at low gate accuracy, 0.11–0.59 — refinement collapse, a different failure mode — and are rule-blind too). The (b) residual is therefore not an artifact of the feedback channel: shown the discrepant expected values directly, the model corrects the dynamics around them and still does not posit the rule.

So “translation, not inference” should be read as the conjunction: (a) an omitted rule is unidentifiable from a sample that misses it (provable, universal, exactly the danger-law gate-miss event), and (b) even a sample that contains it does not reliably teach the LLM (empirical, tested on GPT-5.x mini/large across the Section 5 regimes). Stating (a) as a theorem strengthens the claim: the part of the failure that looks like an LLM weakness is in fact information-theoretic and binds every possible learner; only the residual (b) is a model-specific finding, and we are explicit that its universal form is conjectural.

5.4 Conclusion: translation, not inference↩︎

Under the tested regimes, LLM CWM synthesis behaves as rule translation: it correctly encodes rules it was given and, across the two model sizes tested (mini, large) and every data regime we ran, did not infer the omitted rule, even when that rule was demonstrated by example transitions. Beneath this empirical finding sits a universal one (Section 5.3, Proposition 3): when the omitted rule is absent from the sample — probability \((1-r)^N\), the danger-law gate-miss event — no learner can recover it from those sampled transitions alone; any recovery must come from a prior or the specification, not from the sample. The actionable implication is that the specification must be complete before synthesis, and that verification on the play distribution detects incompleteness but does not repair it. Feeding example transitions is not a reliable substitute for a complete specification.

6 Imperfect Information: The Inference Function as a New Failure Surface↩︎

The danger law applies not just to the transition function (the CWM’s model of how states evolve) but also to the inference function (the CWM’s model of how to reconstruct hidden state from observations). We extend the contract, prove a coverage bound that explains when the inference gate is provably safe, and construct a minimal game where it is not.

6.1 Pipeline validation: Kuhn poker↩︎

Before constructing a gap, we validate the imperfect-information pipeline on Kuhn poker, a well-understood minimal game (3-card deck, 1 betting round per player, net-chip payoff; Table 12).

Both model sizes pass the transition gate and synthesize an exact infer_states (inference rate 1.000), and both play at parity with the truth-vs-truth baseline — consistent with a near-zero gap, as expected when the model has the game (large recalls Kuhn; mini reconstructs it from the specification). The mini synthesis differs from the ground truth only in an observation convention: it places player 2’s own hidden card at a different index of the observation vector (observation rate 0.500 — every player-2 observation mismatches by this relabeling), a wrong-but-running convention divergence that leaves play unaffected.

6.2 When the inference gate is provably sufficient: a coverage bound↩︎

We now formalize when the inference gate, sampled on random play, is identifying — that is, when every competent-play-relevant inference error would be caught by the random-trajectory gate.

6.2.0.1 Setup.

Consider a finite two-player extensive-form game with perfect recall, chance (the deal) and imperfect information. We use the following notation:

\(b\):

maximum, over player information sets \(I\), of \(|A(I)|\) (the number of actions available at \(I\)), with chance handled separately through \(p_{\text{chance}}\);

\(d(I)\):

number of player-action edges on a shortest history reaching information set \(I\);

\(d_{\max}\):

\(\max_I d(I)\), the maximum such depth;

\(p_{\text{chance}}\):

minimum probability of a deal consistent with any reachable info-set;

\(\mathcal{I}\):

set of reachable info-sets;

\(\pi^\sigma(\cdot)\):

realization (reach) probability of a history or info-set under strategy profile \(\sigma\);

\(\mathrm{supp}(\cdot)\), \(\mathrm{reach}(\cdot)\):

the histories, resp.info-sets, given positive probability.

The uniform-random policy \(\rho\) plays every legal action with probability \(1/|A(I)| \geq 1/b\), and therefore assigns positive probability to every legal action (full support).

6.2.0.2 An enumeration-free companion certificate: bounding the error mass.

Theorem 1 certifies the strongest possible conclusion — every reachable info-set is visited, so any error pattern confined to reachable info-sets is caught — but instantiating its constants requires enumerating \(\mathcal{I}\) and the exact reach probabilities. That is feasible for Kuhn and Leduc (the corollary above) and intractable in general; indeed the Leduc guarantee already stops at the sampled competent subset precisely because the full competent support would have to be enumerated. We therefore add a companion certificate that trades conclusion strength for generality: it certifies not that every info-set was visited, but that the undetected error region of the accepted artifact has small sampling mass. Its constants involve no enumeration — no \(|\mathcal{I}|\), no \(\pi_{\min}\), no reach probabilities — so it applies verbatim to games of arbitrary size. The two results answer different questions and neither subsumes the other (Remark 6); we keep both.

Fix a candidate inference function \(f\) and let \(E_f \subseteq \mathcal{I}\) be the set of reachable info-sets on which \(f\) errs. For a per-game sampling distribution \(\nu\) (a policy profile, or a mixture of profiles resampled per game), write \[\mu_\nu(E) \;=\; \Pr_{\text{game} \sim \nu}\!\big[\text{the game visits at least one info-set of } E\big]\] for the per-game hit probability of \(E \subseteq \mathcal{I}\). Let \(\bar d\) denote the player-move horizon — the maximum number of player-action edges on any complete history — so \(\bar d \geq d_{\max}\), strictly for Kuhn and Leduc (\(\bar d = 3\) and \(8\) vs \(d_{\max}= 2\) and \(6\): an info-set is reached before an action is taken from it, and Leduc’s round-1 observation merge shortens shortest histories further).

6.3 Leduc depth probe: poker depth does not create an inference gap↩︎

To confirm that poker cannot supply the necessary depth, we swept Leduc’s per-round raise cap to artificially deepen the betting tree (Table 13):

A coverage gap appears only at cap 6, and even there it is marginal (1.26% of competent visits, 5 info-sets) — insufficient for a CI-separated play deficit. The mechanism is fundamental: in poker, betting depth comes from aggression, and competent play minimizes aggression. In game-theoretic terms, the deep betting region is off the equilibrium path, because equilibrium folds or calls dominated hands rather than raising into them — so the deep region is off-best-response-path, not a region optimal play relies on. Competent info-sets are always a strict subset of the random-covered ones — the opposite of the structure needed for a coverage gap. Poker is the wrong family.

6.4 Beacon: a minimal positive imperfect-information gap↩︎

A positive gap requires a game where depth comes from survival: optimal play reaches a deep region by staying alive, while random play blunders out early. This is the exact imperfect-information analogue of the rare-rule gap in army5x5a, where competent play reaches the ply cap (the deep region) and random play ends much earlier.

6.4.0.1 Hand-instrumented vs LLM-synthesized.

It is important to be explicit about which artifacts are which. Beacon (this section) and the masked-tic-tac-toe instrument of Section 6.6 are hand-constructed ground-truth oracles carrying a deliberately wrong belief function — formal counterexamples (witnesses), not LLM-synthesized world models. The LLM-synthesis evidence on the imperfect-information surface lives elsewhere: the Kuhn pipeline validation (Section 6), where the dynamics and the inference function are synthesized and gate-passed, and the masked-tic-tac-toe probe (Section 6.6), where the dynamics are synthesized. Beacon’s belief function is never synthesized; it is an instrument we wrote by hand to prove the coverage gap can exist with the exact predicted form.

6.4.0.2 Game construction.

Beacon is a two-player game with the following structure:

1. Setup. Each player is assigned a hidden type (0 or 1) uniformly at random. The game has \(T\) rounds.

2. Survival walk (rounds 1 to \(T\)). Players alternate; on a turn, a player of hidden type \(t \in \{0,1\}\) at their own step index \(k\) (the number of safe steps they have completed so far) must play the safe action \(a = (k + t) \bmod 2\) — a deterministic function of the mover’s own (known) type. Any other action loses immediately. A uniformly-random player survives all \(T\) of its steps with probability \((1/2)^T\); a player who knows its type plays safely always and survives with probability 1.

3. Final round (round \(T+1\)). Each player guesses the opponent’s hidden type (inferable from the opponent’s observed moves; see below). Each scores 1 if its guess matches the opponent’s type and 0 otherwise; the higher score wins and equal scores draw — so the round is a draw whenever the two guesses are both correct or both wrong, and is decided only when exactly one player is right.

The region “game reaches the final round” is called D (the deep region). Random play reaches D with probability \((1/2)^{2T}\) (both players must survive); optimal play reaches D with probability 1.

6.4.0.3 Why the type is inferable, and why the fair baseline is a draw.

The safe action is a deterministic, invertible function of the mover’s type, so a single observed move reveals it: a type-\(t\) player who moved at step index \(k\) played \(a = (k + t) \bmod 2\), hence \(t = (a - k) \bmod 2\). The belief is genuinely ambiguous only before a player’s first move (support \(\{0,1\}\)) and collapses to a singleton the instant one move is seen; since D is reached only after both players complete \(T \ge 1\) safe steps, at D each type is always pinned down, and a planner with the correct infer_states guesses right with probability 1. Two consequences are central to reading the numbers. (i) Both-right and both-wrong both draw. Scoring is comparative (higher number of correct guesses wins), so correct inference on both sides yields a \(1\)–\(1\) outcome — a draw — which is why the fair truth-vs-truth baseline scores \(0.500\) (all draws, not “wins half”); the symmetric \(0\)–\(0\) outcome is likewise a draw but never arises, since the fair arm has both sides correct and the instrument arm corrupts only one. (ii) The draw baseline is the cleanest possible control, not a weakness. Because symmetric correct inference is an exact draw, the game carries no structural, positional, or first-mover edge to disentangle from the inference effect; corrupting exactly one player’s belief on D breaks the symmetry into a decisive \(1\)–\(0\) (the flipped side scores 0, the correct side scores 1 and wins every reached-final game), so the entire measured deficit \(0.500 \to 0.000\) is attributable to the flipped infer_states alone. Had the baseline had a structural winner, one would have to subtract that edge to isolate the inference cost; the draw makes that subtraction trivially zero. (Corrupting both sides would restore the \(0\)–\(0\) draw — but that is not the experiment; it would merely pit two equally-wrong beliefs against each other.)

6.4.0.4 The instrument.

A CWM whose infer_states is correct except that it flips the inferred opponent type at final-round states (status == 1) — wrong only on D. Random play almost never samples D, so the inference gate almost never sees the error. The correct inference function enables the determinized MCTS planner to make the right guess; the flipped inference function causes the planner to guess wrong.

6.4.0.5 Beacon as a signaling game.

Beacon is naturally read as a Bayesian (signaling) game: Nature draws each player a type \(\theta_i \in \{0,1\}\); the survival walk emits type-correlated signals (the safe move depends on the type); and the final guess is a belief-dependent action. The correct infer_states is the Bayesian posterior support \(\mu(\theta_{-i} \mid \text{observed actions})\) over the opponent’s type, while the flipped instrument encodes a wrong, non-Bayesian belief. An infer_states error is thus a non-Bayesian belief, and under it the planner’s final action is no longer a best response to the true type distribution. This connects directly to sequential equilibrium [14] — a solution concept that, unlike Nash, also constrains beliefs at information sets reached with zero probability: an assessment (a (strategy, belief) pair) is sequential when its beliefs are Bayes-consistent on the equilibrium path, and an action optimal against wrong beliefs is part of no sequential equilibrium. The gate certifies the strategy component of the assessment while leaving the belief component unconstrained off the random-reach path — exactly the off-path region where Beacon’s error lives. Two qualifications keep the picture honest: infer_states returns a set-valued belief (the support / info-set), and determinized MCTS then imposes its own weighting over that set — so even a correct infer_states leaves the belief weights to the planner.

6.4.0.6 Why the result is planner-robust.

One might worry that the Beacon result is an artifact of determinized MCTS being a weak planner. The PIMC (perfect-information Monte Carlo, the family of determinized planners that solve sampled complete-information games) error decomposition [5] shows the opposite. Beacon’s decisive move is a pure disambiguation task, and determinization is weakest exactly when disambiguation dominates; but here a correct posterior makes the optimal guess deterministic, so determinized MCTS with a correct infer_states recovers the optimal action despite strategy fusion, while with the flipped infer_states it is forced to the wrong action. The result is therefore not an artifact of planner suboptimality — if anything, Beacon is the cleanest possible setting for a determinization planner to succeed in.

6.4.0.7 Result (\(T=8\), GATE_GAMES=2000, arena \(N=400\times 3\) seeds, 100 simulations, 2 determinizations; Table 14).

The instrument passes the inference gate perfectly — 0 mismatches on 8156 sampled observations — yet loses every game. This is the imperfect-information analogue of the rare-rule gap: a verified-but-wrong inference function that is nonetheless play-inadequate.

What is proven vs measured: the reach bound \((1/2)^{2T}\), the fact that optimal play reaches D with probability 1, and the logical implication that flipping the inference on D causes the planner to guess wrong are all analytic properties of the Beacon construction. The 0/8156 gate mismatch count is measured. The play side is not merely measured; it is exact:

The proposition lives at the belief\(\to\)guess abstraction (any planner satisfying (a)–(b)); that determinized MCTS realizes (a)–(b) is the planner-conversion fact noted above (verified by whole-branch code review, and re-verified by the same script driving the eight games with the actual determinized-MCTS policy, which reproduces all-draws / all-losses). The measured 0.000 [0.000, 0.003] over \(n = 1200\) arena games is thus the confirmation of a theorem rather than a standalone estimate.

6.4.0.8 Caveat.

Beacon is a minimal, strategically trivial witness. Its purpose is to prove that the coverage gap can exist and can have the exact form predicted by the coverage-bound design corollary, not to model a realistic game. The reach-probability structure is engineered specifically to satisfy \(b^{d_{\max}} \gg N\); natural games with this structure would involve hidden information in genuinely complex board games.

6.5 The danger law on the inference axis↩︎

The danger law from Section 4 applies directly to the inference gap. Sweeping \(T\) (so \(\varepsilon = (1/2)^{2T}\), the probability that a random game reaches D) against a fixed gate \(N = 2000\) and \(\mathrm{play\_cost} = 0.5\) (Table 15, plotted in Figure 4b). Since \(\mathrm{play\_cost} = \tfrac12\) is exact on Beacon (Proposition 4) and the gate-miss factor is exact (Proposition 1), both factors of the law are analytic on this axis — the danger column below is a theorem, not a fit:

At \(T=4\), the deep region is frequent enough that a gate of \(N=2000\) catches the inference error (danger \(\approx 0\)); by \(T \geq 8\), the gate is blind and harm saturates near play_cost (\(\approx 0.5\); danger T=10 = 0.499) — the maximum possible given the game structure. The same threshold law and the same \((1-\varepsilon)^N\) factor, now instantiated on the inference half of the contract (Figure 4b shows it tracing the identical threshold as the transition axis in panel (a)).

6.6 The gate-blindness claim: the belief model is invisible to a transition gate↩︎

Beacon (Section 6.4) shows that a verified-but-wrong belief model can lose at play — the play claim (a witnessed existence result: in Beacon, decisively, with a 0.000 win rate at 0/8156 gate mismatches). The complementary verification question is whether a transition-accuracy gate could have caught the wrong belief model in the first place. It cannot, and for a structural reason: the belief model is invisible to a transition gate — the gate-blindness claim this section establishes.

6.6.0.1 Demonstration (masked tic-tac-toe).

We take standard tic-tac-toe dynamics (which GPT-5.4 synthesizes at transition gate 1.000 by recall) and overlay an arbitrary, non-recallable masking rule: the center cell is hidden from both players (shown as \(-1\)), even after it is played. We synthesize the contract two ways — with the masking rule present (full) and with it removed (withheld, leaving tic-tac-toe + an imperfect-information framing that still demands observation/infer_states but does not say what is hidden) — and gate each on transitions and on inference (Table 16):

The transition gate is 1.000 in both arms — the dynamics are recalled, unaffected by the masking rule, and the gate (which calls only apply_action/legal_actions/is_terminal/returns) never invokes the belief functions. With the rule, the model masks the center correctly (observation_rate 1.000); without it, the synthesized observation does not mask the center (observation_rate 0.020) — a wrong belief model that the transition gate nonetheless certifies at 1.000. This is Proposition 5 instantiated: a wrong belief model is invisible to a transition gate.

Both belief-surface metrics discriminate cleanly: observation_rate 1.000 vs 0.020 and inference_rate 1.000 vs 0.180. Given the full rules, the model synthesizes an exact infer_states; with the masking rule withheld, it synthesizes a confidently wrong one. The masked tic-tac-toe experiment therefore establishes two things: (a) the masking/observation rule is not recoverable without being specified, and (b) a transition-accuracy gate is structurally blind to it (transition gate 1.000 in both arms).

6.6.0.2 A pitfall worth recording: a recurring infer_states crash induced by our own contract, not the model.

The synthesized infer_states raised ’list’ object is not callable even with full rules, recurring across three distinct games (Kuhn-mini, Beacon, masked tic-tac-toe); we initially read it as a synthesis-robustness failure of the model. The root cause was ours. The synthesis contract prescribed the signature infer_states(observation, player) — a parameter named observation that shadows the contract’s own observation() function — while the very next contract sentence instructs the model to relate infer_states to calls of observation(s,p), inviting exactly the collision that produces this TypeError. After renaming the parameter (obs) and adding an anti-shadowing note to the contract, we reran all three games: zero execution errors (masked tic-tac-toe, Kuhn, Beacon), and the full-rules infer_states is exact. We flag this explicitly because we had attributed to the LLM a fragility that our own prompt induced — a small, concrete instance of the paper’s broader theme that the specification, not the model, is often the binding constraint.

6.6.0.3 Synthesized corroboration on Beacon (single-seed probe).

The same withheld-rule construction on Beacon (\(T=6\)), with real LLM synthesis end-to-end, corroborates gate-blindness on a second game: withholding the revelation rule yields a synthesis that passes the transition gate at 1.000 (2 refinement iterations) with inference_rate 0.000 — a transition-certified, belief-wrong CWM, this time synthesized rather than hand-instrumented. (The full-rules arm of this probe fails the transition gate outright — accuracy 0.456 after 10 iterations; Beacon’s revelation dynamics are hard to synthesize — so the probe corroborates the gate-blindness face only, and we report it as a single-seed probe, not a headline result.)

Together, Beacon (the play claim) and masked tic-tac-toe (the gate-blindness claim) are the two faces of belief-model verification: a wrong belief can lose at play and is invisible to a transition gate.

7 Related Work↩︎

7.1 Objective mismatch in model-based reinforcement learning↩︎

The closest conceptual antecedent is the objective mismatch problem in model-based reinforcement learning identified by [15]: the prediction accuracy of a learned world model and the downstream control performance of a planner using that model can diverge substantially, because they optimize different objectives. Our work is in the same spirit but differs in setting and mechanism. We work in the LLM-code-synthesis regime (the world model is a synthesized program, not a learned neural model), the verification step is a discrete sampling gate (not a continuous loss), and the failure mode we characterize is a rule-coverage blind spot in that gate rather than a model-capacity or distribution-shift issue. We also provide a closed-form danger law and a proof that the gate-miss probability is exact under i.i.d.Bernoulli sampling — not merely an empirical observation.

The broader literature on model-based RL world-model quality [[16]][17] largely focuses on learned continuous-state models where world model error is pervasive rather than localized. Our rare-rule gap is a localized, discrete failure that state-accuracy metrics mask by dilution — a point that may be worth revisiting in continuous settings as well.

7.2 Code World Models and LLMs for game playing↩︎

The Code World Models for General Game Playing paper [3] introduces the paradigm we build on: an LLM synthesizes an executable world model from rules and trajectories, which a classical planner (in their case, MCTS) then uses. Their results on a set of novel DeepMind board games show that CWM+MCTS outperforms the direct LLM policy. We reproduce this result on tic-tac-toe and Connect Four (Section 3.1) and extend the paradigm to ask whether the gate they use — transition accuracy on random trajectories — certifies play-adequacy. Our contribution is essentially a rigorous negative answer to that question, together with the mechanisms that explain it.

Related work on code-as-policy [18], [19] uses LLMs to synthesize executable plans or robot controllers, typically verified by execution rather than by sampling. The distinction between what the LLM was told and what it can infer is implicit in much of this work but has not, to our knowledge, been studied with a controlled rare-rule instrument.

The gg-bench effort [20] generates novel games procedurally specifically to avoid LLM contamination. Our army5x5a instrument is chosen partly for the same reason (verified non-recall of movesets, Section 2.6) and the gg-bench approach is an attractive complement for future scaling.

7.3 DAgger and dataset aggregation↩︎

Our Section 5 repair experiments are directly inspired by the DAgger framework of [21]: iteratively label, under the oracle, the states visited by the current learned policy, and retrain. In DAgger’s original imitation-learning setting, this reduces covariate shift. Our finding — that DAgger fails to teach the rare rule — is consistent with the translation hypothesis: DAgger addresses distribution mismatch between training and test, but the bottleneck here is not distribution mismatch. The model receives discriminating examples of the rule; it simply cannot infer the rule from them. This is a different failure mode from the one DAgger was designed to address.

7.4 Imperfect-information planning and determinization↩︎

Determinized MCTS (also called single-observer MCTS, SOMCTS, or information-set MCTS in some formulations; [4]; [22]; determinization analysis, [5]) resolves imperfect information by sampling a consistent complete-information game at each decision point. It is not game-theoretically optimal — it is subject to the two canonical PIMC pathologies, strategy fusion (the planner behaves as if it could pick different actions in states it cannot actually tell apart) and non-locality (a node’s true value depends on how play reached it, not only on the subtree below it) [23], and in the vocabulary of [5] its error is governed by leaf correlation, bias, and a disambiguation factor — but it is a practical planner for moderate-sized imperfect-information games. We use it as the planner in Section 6, holding the planner fixed across conditions (the baseline is truth-vs-truth under the same determinized MCTS) so that the contrast isolates the CWM inference function rather than planner quality.

The planner alternatives a reader will expect — ISMCTS [4] and CFR [6]–[8] — are discussed where they bear on the work: the choice of determinization over ISMCTS, and why it is conservative for our results, in Section 2.3; the equilibrium (CFR+) coverage analysis, including a practical imperfect-recall pitfall of instantaneous-observation info-set keys, in Section 6.2; and the remaining equilibrium gaps in Section 8.

7.5 Verification, testing, and rare events↩︎

The sampling gate at the heart of this paper is, in software-engineering terms, random property-based testing of a synthesized world model: it draws random inputs (uniform-random play-throughs) and checks a property (transition agreement with the oracle). Property-based testing in the QuickCheck tradition [24] is exactly this idea, and its classic, well-documented weakness is the one our danger law makes quantitative: randomly generated inputs under-sample rare-but-important corners of the input space unless the generator is biased toward them. Our \((1-r)^N\) gate-miss factor is the closed-form version of that coverage gap for a single rare rule.

Detecting a rule that fires with vanishing probability under random play is a rare-event detection problem, and the \((1-r)^N\) miss probability is precisely a rare-event miss. The rare-event-simulation and importance-sampling literature [25] is built around the fact that naive Monte Carlo is exponentially inefficient at estimating or surfacing rare events, and that one must tilt the sampling distribution toward the event to detect it efficiently. In our framing, verifying on the play (or equilibrium) distribution rather than the uniform-random one is exactly such a tilt: it concentrates samples on the region competent play reaches, which is where the rare rule matters.

The contrast with formal verification and exhaustive conformance / model-based testing is instructive. Where formal methods (model checking, exhaustive conformance testing of state machines) certify a property over all reachable states by construction, a sampling gate certifies only over a finite random draw — trading exhaustiveness for the cheapness that makes the CWM paradigm attractive. The coverage hole we characterize is the price of that trade, and it is fundamentally a sampling-certification phenomenon, not present under exhaustive certification. We state this contrast at the level of the area rather than attaching it to specific results.

Finally, the failure has a direct analogue in model-based reinforcement learning as model exploitation: a planner optimizing against a learned or synthesized model is driven toward regions where the model is most wrong, because those are where it (incorrectly) predicts the highest return. This is the mechanism behind the objective-mismatch and model-trust discussions in model-based RL [15]; the model-trust horizon limits of MBPO [17]. Our rare-rule gap is a localized, adversarially-reachable instance: the planner does not merely tolerate the model’s blind spot, it actively seeks the cap region the verification distribution never disciplines.

8 Limitations and Honest Assessment↩︎

8.0.0.1 Model families: one sweep, two cross-family probes.

All sweep-scale synthesis experiments use Azure OpenAI GPT-5.x (mini, nano, large). To test whether translation-not-inference is a GPT-5.x quirk, we ran the headline cell (\(N=200\), same contract, same pipeline messages, same classification; scripts/crossfamily_probe.py) on two further families as declared spot-checks, not sweeps: Qwen3-Coder-30B (open, code-specialized; via the Hugging Face inference router) is rule-blind in 3/3 seeds with zero crashes (it also fails to reach gate 1.0 in 2/3 seeds — a gate-attainability limitation, like nano’s); and Claude Sonnet (agent-relayed with pipeline-identical messages; 2 single-seed probes, 1–2 refinement iterations each) produced only rule-blind compositions, in one case explicitly reasoning about the mismatching material states and concluding that its draw-at-cap “already matched the specification” — choosing the incomplete spec over the data, which is the translation mechanism verbalized. (A DeepSeek arm was attempted and aborted on inference-credit exhaustion.) The finding now replicates in three model families, but the universal form (“no model can infer an omitted rule, regardless of scale”) remains a conjecture consistent with our data: the cross-family evidence is a handful of seeds on one cell, and stronger code-reasoning models or agentic scaffolds may yet break it. Throughout we state the sweep-scale finding as scoped to the GPT-5.x family and the Section 5 regimes, with “rule translation” as a mechanism hypothesis consistent with the data rather than a proven universal.

8.0.0.2 The rare-rule instrument is engineered.

The material-at-cap rule was selected specifically because it falls in the rare-and-consequential quadrant. We do not claim that all or even most rules in arbitrary games will produce this kind of gap; the rarity\(\leftrightarrow\)consequence tension found across our six-rule probe set on Connect Four (Section 3.3) shows that the gap requires a specific structural condition. The point is that the gap can exist and does exist in a game where random and competent play diverge — which is itself informative about when the sampling gate is unsafe.

8.0.0.3 Pure-Python MCTS limits arena size.

Our MCTS implementation is a pure Python reference. This limits the number of simulations and arena games that are computationally tractable, which in turn limits the tightness of confidence intervals for some conditions. We mitigate this with the cheap/expensive separation in the danger law (Section 4) — rarity is swept cheaply, play_cost is measured precisely once at scale — and with Kuhn poker’s small game size (tight CIs). The headline play result (rule-blind 0.404 [0.384, 0.424] vs fair baseline 0.495 [0.475, 0.515]) is measured over 20 seeds, the Wilson 95% intervals do not overlap (n=4800), and a seed-clustered paired interval (\([0.065, 0.117]\), the seed as the unit) excludes zero despite real between-seed heterogeneity.

8.0.0.4 Determinized MCTS is not game-theoretically optimal.

As noted in Section 7, determinized MCTS is subject to strategy fusion and non-locality and is not a Nash-equilibrium strategy. The baseline for the imperfect-information experiments is truth-vs-truth under the same determinized MCTS (not an equilibrium baseline), so the contrast is internally consistent but not a statement about how a game-theoretically optimal player would interact with the gap. Holding the planner \(\Pi\) fixed across the two arms is deliberate: any pathology intrinsic to \(\Pi\) is present in both arms, so the performance difference is attributable to the CWM rather than to the planner. We are careful, though, not to overstate this as a theorem. The “cancellation” is really that the wrong CWM is weakly dominated in this specific instrument — by construction in Beacon (proven) and by measurement in army5x5a (0.495 vs 0.404) — not a general guarantee that planner pathologies cancel for arbitrary CWM perturbations; a sufficiently suboptimal planner could in principle let two wrongs cancel. None of the existence claims depends on equilibrium play. The coverage question, however, is now answered against equilibrium reach directly: a CFR+ profile on the true games (Section 6.2, equilibrium-reach upgrade) leaves the coverage conclusion unchanged. What remains open on this front is narrower than before: a full arena under equilibrium play (CFR-vs-CWM matches), and a minimax reference for the perfect-information instruments.

8.0.0.5 Beacon is a minimal, strategically trivial witness.

Beacon was designed to satisfy the coverage-bound design corollary in the smallest possible game, not to model a realistic scenario. Its survival-walk structure is artificial. The experiment establishes existence and confirms the danger law on the inference axis; it does not demonstrate that natural imperfect-information games with the same structure produce an equally clean gap. Building such a game (e.g., a partially-observable variant of army5x5a) is a natural next step.

8.0.0.6 Scope of the gate-blindness claim.

The masked tic-tac-toe result (Section 6.6) establishes that a transition gate is blind to a wrong belief model, demonstrated by withholding an observation (masking) rule that is genuinely independent of the dynamics. It does not establish the stronger claim that the belief model could never be inferred from any richer, observation-bearing signal — indeed Proposition 5 is explicit that a dataset of observation-to-observation tuples \((o,a,o')\) would constrain the information partition. The claim is scoped to full-ground-state transition data: such data cannot constrain the belief model (Proposition 5), and withholding the rule yields a wrong, transition-certified belief model.

8.0.0.7 Knowledge cutoff and contamination.

GPT-5.4’s training cutoff is approximately 2025-08-31, and the army5x5a paper (arXiv:2510.04542) was released 2025-10-06 — after the cutoff — so the game falls outside the training window. We additionally confirmed via a declarative probe that the model does not recall the specific movesets — with the question, the full “I do not know” response, and a correctly-answered Kuhn-poker positive control persisted verbatim in results/declarative_recall_probe.json (Section 2.6) — and the gate-attainability difficulty (nano fails 5/5) is further evidence of genuine translation rather than recall. Even so, the “post-cutoff = uncontaminated” argument is not a hard guarantee (cutoff dates are approximate and corpora leak); readers should interpret the “no prior” label as “no detectable recall” rather than “strictly novel.”

9 Conclusion↩︎

The central finding of this paper is that transition accuracy on randomly sampled play-throughs is the wrong adequacy criterion for an LLM-synthesized world model used in planning. A model can pass this gate at 100% accuracy and remain \(\geq 98\%\) state-accurate on the distribution the planner actually visits, yet lose systematically at play — because the less than 1% it gets wrong is exactly the pivotal dynamics.

The failure follows a quantitative law: \(\mathrm{danger} = \mathrm{play\_cost} \times (1 - \mathrm{rarity})^N\). The gate-miss factor is proven exact under i.i.d.Bernoulli sampling; play_cost is empirical. This law identifies the condition under which sampling verification is unsafe: a rule whose random-play incidence is small enough to escape a size-\(N\) gate but whose competent-play incidence is high enough to matter.

The gap is not repaired by providing example transitions. Under the tested regimes, LLM CWM synthesis behaves as rule translation: it encodes rules it was given and, across the two model sizes tested (mini, large) and every repair-data form we tried, did not infer the omitted rule. Off-manifold repair data actively corrupts synthesis. The actionable fix is specification completeness plus verification on the play distribution; the latter detects incompleteness but does not repair it.

The same mechanism appears on the inference half of imperfect-information CWMs. We prove a coverage bound that explains why shallow poker games are safe (their inference gate is provably identifying), and construct a minimal game (Beacon) where a verified-but-wrong infer_states passes the gate yet loses every game, with the danger law recurring on the inference axis. Perfect-information board games (transition rules, rarity \(r\)) and imperfect-information games (inference info-sets, depth \(T\)) are the same statement on two faces of the CWM contract. We note again that the imperfect-information play-loss witness (Beacon) is hand-instrumented, not an LLM-synthesized CWM; the gate-blindness face, however, now has synthesized demonstrations on both masked tic-tac-toe and Beacon (transition-gate-passing, belief-wrong syntheses; Section 6.6), alongside the perfect-information synthesized-CWM study (Section 3–Section 5) and the Kuhn pipeline validation (Section 6.1).

Underneath both faces is a single structural diagnosis (Figure 1): the gate failure is a reach-distribution shift between the verification policy (\(\rho\), full support, mass on shallow histories) and the deployment policy (\(\Pi\), mass on deep histories). The dangerous events are on the deployment-reach path but off the verification-reach path. This is structurally the same situation as off-equilibrium-path beliefs being unconstrained in an extensive-form game — which is exactly why game theory developed equilibrium refinements (sequential equilibrium, trembling-hand perfection [26]) to discipline off-path beliefs. A sampling gate has no such refinement: nothing forces the synthesized model to be correct where the verification distribution places negligible mass, even though the deployment distribution relies on precisely that region.

These results suggest two concrete practices. First, verify on the distribution that planning visits — or measure play directly — rather than on randomly sampled transitions. Second, ensure the specification is complete before synthesis; the model will translate what it is given, and gaps in the specification become invisible to sampling-based verification.

10 Reproducibility↩︎

All code is available at https://github.com/JaviMaligno/code-world-models. All experimental results and exact reproduction commands are in docs/EXPERIMENTS.md, and all code is on the main branch (cwm/ package, scripts/). Research narrative and formal theorem statements are in docs/RESEARCH-DIRECTION.md. Exact commands for the headline results:

# Headline play-cost with Wilson CIs + seed-clustered interval (Sec. 3.3, n=4800)
PYTHONPATH=src python scripts/play_cost_ci.py --seeds 20
# Coverage-bound exact constants - Kuhn & Leduc reachable info-sets (Sec. 6.2)
PYTHONPATH=src python scripts/coverage_bound_constants.py
# Leduc sampled competent-visited subset coverage (Sec. 6.2)
PYTHONPATH=src python scripts/coverage_competent_leduc.py
# Enumeration-free error-mass certificate - Kuhn & Leduc (Sec. 6.2)
PYTHONPATH=src python scripts/error_mass_certificate.py
# Beacon exact play_cost by exhaustion + planner check (Sec. 6.4)
PYTHONPATH=src python scripts/play_cost_exact_beacon.py
# play_cost mechanism: competent vs random reach-cap by cap knob (Sec. 4, n=120)
PYTHONPATH=src python scripts/play_cost_reach.py --games 120
# Synthesis-pipeline danger curve (Sec. 5.2), 20 seeds/cell, one model at a time
PYTHONPATH=src python3.12 scripts/danger_synthesis_sweep.py large 20
# Declarative recall probe - army5x5a / Trike / Kuhn control (Sec. 2.5, Sec. 7)
PYTHONPATH=src python3.12 scripts/declarative_recall_probe.py large
# Equilibrium-reach coverage - CFR+ on Kuhn & Leduc (Sec. 6.2)
PYTHONPATH=src python3.12 scripts/equilibrium_coverage.py

The danger-curve script requires Azure OpenAI credentials in .env; the others are CPU-only. These diagnostic scripts print their results to stdout (some scripts also write per-run JSON under results/, which is versioned in the repo); the numbers quoted in this paper are recorded in docs/EXPERIMENTS.md.

Key scripts:

• scripts/nontriviality_sweep.py — confirms game non-triviality

• scripts/gap_grid.py — state-agreement gap across regimes

• scripts/play_cost.py — play_cost measurement at scale

• scripts/law_curve.py — danger law curve (rarity sweep + cost probes)

• scripts/repair_spikes/ — DAgger and repair experiments

• scripts/run_kuhn_validation.py — imperfect-information pipeline validation

• scripts/leduc_coverage_diagnostic.py — Leduc coverage-gap measurement

• scripts/leduc_depth_probe.py — Leduc depth sweep

• scripts/beacon_claimA.py — Beacon result and danger law sweep

• scripts/mtt_claimB_probe.py — masked tic-tac-toe probe (full vs withheld masking)

All runs use the Azure OpenAI Global Standard deployments configured in .env. Per-run JSON results are in results/ (versioned in the repo). Total API cost across all experiments: approximately $2.

References↩︎

---

1. The coincidence is one-directional: every gate-passing seed is material-terminal-absent, but not every material-terminal-absent seed passes. Of the ten material-terminal-absent seeds, nine reach gate \(1.0\); the tenth (seed 11) stalls at gate \(0.808\) — a base-game synthesis failure (the LLM does not reproduce even the rule-free base game to gate \(1.0\)), distinct from all three danger-law channels, which concern the omitted rule specifically. It is excluded from the play measurement, which conditions on gate \(1.0\).↩︎

2. This proposition is definitional rather than derived: because the information partition is not a function of the transition tuple, consequences (i)–(iii) follow immediately from the statement — there is no separate deductive step to discharge, which is why we mark it self-proved (\(\square\)) rather than attaching a proof block. The masked tic-tac-toe result below is an empirical instantiation of the proposition, not a proof of it.↩︎