# DGM-007 (Track 2) — Findings: the irrecoverability boundary

**Status:** cross-world replication RUNNING; everything else complete. This document is
the artifact bundle (prereg §12); the cross-world verdict section is filled in when the
replication lands.

**Question (prereg, frozen + hashed before any competitor was built):**
> Can a learned latent-inference model beat the *strongest computationally feasible*
> deterministic competitor by ≥15% (the frozen gate), reproducibly across worlds, with
> the advantage NOT closing as the deterministic competitor is given more computation?

Null H0 (to be defended): deterministic computation is sufficient. **The job was to try
to kill H0**, not to help ML win.

**Frozen anchors.** Track-1 freeze `freeze/track1-inference-placement-2026-09-22`.
Parent prereg `prereg/dgm-007-2026-09-22` (sha256 `b51ee352…`). Learner addendum
`prereg/dgm-007-addendum-approx-learner-2026-09-22`. K=12 faults, M=20 diagnostics,
noisy-OR generator, EIG game, CONF=0.90, operational loss = cost + 50·misdx, 15% gate,
paired 90% bootstrap CI, seeds SEED=20260921 (train×7, test×13, learner+999, world×2003).
Manipulated axis: latent dimension **L ∈ {4,8,16,24}** (2^L = 16 / 256 / 65 536 / 16.7 M).

---

## 1. The deterministic order ladder (built and validated FIRST)

The strongest *feasible* deterministic competitor, all closed-form / no latent EM,
behind one uniform (belief, predict_p1) interface driven by a generic EIG game whose
inference path is **byte-identical to Track-1's deterministic lanes** (regression-pinned):

- **order-1** — Laplace marginals (naive-Bayes). Feasible ∀L.
- **order-2** — Chow–Liu tree per fault, exact tree sum-product. Feasible ∀L.
- **order-3** — greedy 2-tree (treewidth ≤2), exact variable elimination. Feasible ∀L.
- **exact-marginal / oracle** — 2^L enumeration; infeasible anchors, L≤12 only.

Validation gates (all machine-precision): world byte-identical to frozen Track-1 at L=4;
order-2 tree BP == brute-force; order-3 VE == brute-force; generic game == Track-1
lanes trajectory-for-trajectory. Bug caught + fixed en route: Prim MST self-loop
initialization (would have made order-2 look artificially weak — biasing *toward* ML).

## 2. Result — the ladder curve (held-out operational loss, ρ=0.8)

| L | order-1 | order-2 | order-3 | feasible ceiling | ceiling vs o1 | oracle | oracle headroom |
|---|---|---|---|---|---|---|---|
| 4 | 33.62 | 32.65 | **30.59** | order-3 | +9.0% (CI>0) | 27.08 | **+11.5%** |
| 8 | 53.74 | **49.91** | 51.87 | order-2 | +7.1% (CI>0) | 46.40 | **+7.0%** |
| 16 | **66.76** | 68.43 | 69.60 | order-1 | +0.0% | — (infeasible) | — |
| 24 | 77.73 | **75.81** | 77.27 | order-2 | +2.5% (CI~0) | — | — |

ρ=0 control holds everywhere (higher orders never beat order-1 — no manufactured
structure). Two decisive facts, before any learner:
1. **Tractable L≤8:** even the ORACLE (upper bound on any model) beats the feasible
   ceiling by only 11.5% (L=4) / 7.0% (L=8) — under 15%. No model can earn a seat there.
2. **Intractable L≥16:** order-2/3 *overfit* and fall *below* order-1 — the feasible
   ceiling collapses to the naive floor; the oracle is uncomputable (2^L).

## 3. Result — data-scaling: the L≥16 collapse is STRUCTURAL, not sample starvation

Scaling training data N: 1500 → 24000 at L=16/24, ρ=0.8 (held-out test fixed):

| L | N=1500 | 3000 | 6000 | 12000 | 24000 | ceiling ever significantly beats order-1? |
|---|---|---|---|---|---|---|
| 16 | +0.0% | +0.0% | +0.06% | +0.73% | +1.80% | **no (CI straddles 0 at every N)** |
| 24 | +2.5% | +1.7% | +0.75% | +0.0% | +1.60% | **no (CI straddles 0 at every N)** |

16× more data does not rescue bounded-order deterministic models. The collapse is
structural: the high-order latent cliques are beyond any bounded-order (feasible)
deterministic family, and more data cannot fix a structurally-insufficient model class.
This closes the critic's obvious attack ("you starved a higher-dimensional estimator").

## 4. The feasibility wall + the approximate-inference learner

The frozen 006H2 learner enumerates all 2^L latent configs (training AND inference) —
exponential in L, infeasible at L≥16, the SAME wall as exact deterministic. So the prereg
premise ("learner feasible while deterministic-exact infeasible") does not hold for the
frozen learner. Resolution (Luke-steered, preregistered in the addendum before building):
a **poly-time variational (mean-field) noisy-OR learner**, same generator-matched family,
exact 2^L enumeration → mean-field. Validated: mean-field == exact 2^L within reported
bias (logZ ~+0.2 nats, ~uniform across faults → cancels in the belief softmax; predictive
<0.35 worst-case); GEM gradient == finite differences (1e-8); never spuriously beats exact
inference of the same model (gate-3, L=4).

## 5. Result — design-world learner sweep (§8 gate + irrecoverability, ρ=0.8)

| L | learner (acc) | fit-valid | vs order-1 | vs order-2 | vs order-3 | seat |
|---|---|---|---|---|---|---|
| 4 | 30.21 (0.800) | ✓ | +10.1% | +7.5% | +1.2% | **no** |
| 8 | 50.59 (0.650) | ✓ | +5.9% | −1.4% | +2.5% | **no** |
| 16 | 67.65 (0.335) | ✓ | −1.3% | +1.2% | +2.8% | **no** |
| 24 | 79.14 (0.195) | ✓ | −1.8% | −4.4% | −2.4% | **no** |

The learner earns a seat NOWHERE. L=4: near-oracle (+10%) but under the gate and only
+1.2% over the ceiling. L=8: worse than the order-2 ceiling. L≥16: worse than the naive
floor itself. `fit_valid=True` everywhere — the learner *is* a better probabilistic model
of the observations, but a better fit does not convert into deployable diagnostic
advantage. At L≥16, **no feasible method — deterministic OR learned — clears the gate**;
the intractability wall defeats both symmetrically.

**Robustness — the failure is not a mean-field artifact (tractable boundary).** At L=4
and L=8 (2^L feasible) the fitted learner was re-run with EXACT 2^L inference of its own
parameters. L=4: exact 29.75 vs order-1 +11.5%, still <15%. L=8: exact 49.29 vs order-1
+8.3%, vs order-2 ceiling +1.3%, still <15%. In both, exact inference is *better* than
mean-field (30.21→L=4, 50.59→49.29 at L=8) — confirming gate-3 (the approximation never
spuriously wins) — yet **exact inference still does not clear 15%**. The learner's failure
at the tractable boundary is genuine signal-inaccessibility, not approximation error.

## 6. Cross-world replication (§8.3 reproducibility — 006R→006S lesson)

40 held-out worlds per L (seeds disjoint, ×2003), screening whether the learner ever
clears the necessary vs-order-1 bar (a seat requires clearing vs the best rung, whose
loss ≤ order-1 loss, so clearing vs order-1 is necessary; 0 ⇒ no seat).

Result (40 worlds × 4 L = 160 cells):

| L | clears vs order-1 | median red vs o1 | max | reproducible seat (≥90%) |
|---|---|---|---|---|
| 4 | 1/40 (2.5%) | +5.7% | +15.8% | no |
| 8 | 0/40 | +4.9% | +13.6% | no |
| 16 | 0/40 | +1.5% | +6.9% | no |
| 24 | 0/40 | −0.2% | +3.6% | no |

Exactly one cell (world 37, L=4) tripped the necessary vs-order-1 screen. Its full rung
check: learner 31.94 vs order-1 37.95 (+15.8%, clears) BUT vs order-3 (the ceiling) 31.82
→ **−0.36%, does NOT clear**. World 37 simply had a weak naive floor (order-1=37.9 vs the
typical ~33); order-3 still beat the learner there. Had the competitor been order-1 alone,
this would have been a **false-positive seat** — the order ladder caught it (the
weak-baseline failure mode, prevented on live data).

**Across all 160 world×L cells, the learner clears the 15% gate vs the best feasible rung
in ZERO of them.** Not one reproducible seat; not even one single-world seat. The learner's
median edge over the naive floor **decays** with latent complexity (+5.7% → +4.9% → +1.5%
→ −0.2%) — the anti-transition. (`replication.json` flagged the cell as MIXED pending this
check; the full-rung resolution is: no seat.)

## 7. Verdict — **OUTCOME A (confirmed across 40 worlds per L)**

H0 (deterministic sufficiency) **holds and could not be killed.** The learned latent model
earns no seat — not reproducibly, and not in a single one of 160 world×L cells against the
strongest feasible deterministic rung. Corroborated on every axis: at L≤8 even the oracle
can't clear 15% (a ceiling argument, and exact-inference of the fitted learner confirms it
— not a mean-field artifact); at L≥16 bounded-order deterministic computation is
structurally insufficient (data-scaling: 16× data doesn't rescue it) AND the
structure-matched learner also fails, dropping below the naive floor. The intractability
wall defeats deterministic and learned inference symmetrically. Failure-directed
development delivered its designed outcome: the job was to kill ML, and ML stayed dead.
The sixth kill — and the one that maps the whole boundary rather than scoring a point.

## 8. The map (the actual scientific object produced)

This is not "the floor beats ML." It is a measured map of the (latent-complexity ×
deterministic-order × learned-inference) space in one honest domain:
- **low complexity** — deterministic computation consumes essentially all economically
  useful structure; even the oracle's headroom is below the deployment threshold.
- **high complexity** — bounded-order deterministic computation collapses (structurally,
  not for lack of data), and a feasible learned latent model does not recover the
  difference either. No feasible method earns a seat.

The place a learned seat could exist — high latent complexity where deterministic order is
insufficient — is exactly where inference itself becomes intractable, and the learner's
only feasible option (approximate inference) inherits the same wall. In this domain, the
computation→inference transition the experiment hunted for **does not open a feasible
door**: where deterministic computation stops sufficing, feasible learned inference stops
sufficing too.

## 9. Reproducibility

Branch `peel-hybrid-v1`. Files under `symbolic-floor/benchmark/`: `dgm7_world.py`,
`dgm7_deterministic.py`, `dgm7_order3.py`, `dgm7_learner.py`, `dgm7_ladder.py`,
`dgm7_datascale.py`, `dgm7_learner_sweep.py`, `dgm7_replication.py`; tests `test_dgm7*.py`.
Results under `results/dgm_007/`: `ladder.json`, `datascale.json`,
`learner_designworld.json`, `replication.json`. Preregistrations
`RUN_DGM_007_PREREGISTRATION.md` (+ hash), `RUN_DGM_007_ADDENDUM_APPROX_LEARNER.md`.
Every artifact carries seeds + preregistration hashes. Failures are first-class artifacts.