Skip to content

007-wide-degree-graph-substrate.md

Latest commit

 

History

History
534 lines (427 loc) · 32.1 KB

007-wide-degree-graph-substrate.md

File metadata and controls

534 lines (427 loc) · 32.1 KB
Raw

007 — does the grid's count-rule milestone carry to a graph substrate, on a family where the degree-blind controls can actually fail?

Status: GO (evaluated 2026-07-28) — after(SUM) = 1.0 / 1.0 / 0.9993 at seeds 0/1/2 against the registered ≥ 0.95 bar, with both degree-blind controls failing (MEAN 0.48–0.57, MEAN×D 0.50–0.62) and the non-overlap clause clearing by 0.38. Every GO condition holds at every seed; no STOP or NOT-TESTABLE trigger fires. Both reproduction-contract clauses passed first, clause 2 bitwise. A graph rung is created on this evidence — with the registered A_eff = 2 and t = 2 caveats attached. See "Result" at the bottom.

(Registered 2026-07-28 with the family frozen and committed BEFORE any arm code existed — abb1b9d, whose tests/test_graph_wide_degree.mojo imports no memory and no learning module. The three arms were byte-identical to Gate 006's (d15dfbe) and unrun past its ceiling pre-pass.)

(Direct successor to 006-graph-substrate-port.md, which returned NOT-TESTABLE on 2026-07-27 because its family could not discriminate count from fraction. Gate 006's escape clause: "regenerate under a pre-registered wider degree distribution in a new gate, never by nudging p until the number looks right." This is that gate — and the screening below found that Gate 006's own diagnosis of what needed to change was wrong, which is recorded here rather than quietly corrected.)

What Gate 006 got right, and what it got wrong

Right: the family, not the model, was what failed. CEIL_blind = 0.9899 / 0.9896 / 0.9927 against a > 0.92 NOT-TESTABLE bar; both refuting controls were toothless; the ~30 minutes of ES was correctly never spent.

Wrong: the prescribed fix. Gate 006's Consequence says "what that follow-up must change is the degree distribution". Screening it (table below) says the degree distribution is a second-order lever. Holding the colour alphabet at A = 5 and replacing ER(36, 1/7) with a fixed degree multiset {2,4,8} — the maximally reducible support, exactly what Gate 006's own ambiguity analysis called for — moves CEIL_blind from 0.990 to 0.975. Three other multisets land in the same place. The degree distribution is not the lever.

The actual mechanism. Gate 006's analysis stopped one step short. A node's degree is ambiguous under the fraction key when the count vector m reduces (k·m also in the degree support). But the bucket key is the full A-dimensional histogram, so a collision needs every coordinate to agree — i.e. gcd(m) > 1 across all A colours at once. With 5 uniform colours a neighbourhood is almost never that monochromatic at any degree, so the fraction key pins the degree regardless of how the degrees are distributed. The quantity that controls reducibility is the colour alphabet:

A_eff (colours drawn) CEIL_blind, best multiset, seeds 0/1/2
5 0.964 – 0.983
4 0.938 – 0.967
3 0.878 – 0.929
2 0.793 / 0.801 / 0.803

Only a two-colour world makes the naive MEAN port genuinely blind. That is a real narrowing of the claim versus the grid milestone's 5-colour family, and it is registered as a named caveat below, not buried.

Second-order consequence, which is why this gate has a fifth instrument. Shrinking the alphabet raises the odds that degree alone predicts the label: an absolute threshold ≥ t on a Binomial(deg, 1/A_eff) count is intrinsically degree-sensitive, and at A_eff = 2 the firing rate runs 0.25 / 0.69 / 0.97 across degrees 2 / 4 / 8. A family where degree alone reaches the GO bar would be a different degeneracy from Gate 006's, in the opposite direction — SUM could "win" by reading total degree and never look at a colour. So CEIL_deg is measured and barred alongside the others.

Hypothesis

H. The grid count-rule milestone (GridNbhdSelfModMemory, held-out exact match 1.0) carries to a variable-degree graph substrate, and it carries because the memory reads neighbour counts — not because un-normalising the key changed its magnitude.

Refuted if the degree-blind arms match the un-normalised arm, or the un-normalised arm fails to carry at all.

Unchanged from Gate 006 in every particular. Gate 007 changes the task family and nothing else: the CSR substrate (src/graph_domain.mojo), the three-arm memory (src/memory_selfmod_graph.mojo, one line apart) and the arm protocol are Gate 006's, byte-identical, and clause 2 of the reproduction contract asserts it.

Metric + consumer (no proxy)

Held-out exact match — a rule is scored 1 only if every node of an unseen test graph is correct — averaged over the 10 after rules, each with fresh topology, fresh colours and a fresh rule. Identical to the grid milestone's metric, reached through GraphDomain/SelfModMemory, so the two numbers are directly comparable. Consumer: the docs/ROADMAP.md decision on whether a graph rung is created and whether M4's relational key is built over GraphDomain.

Arms (frozen) — exactly one line differs

Gate 006's, verbatim and byte-identical (src/memory_selfmod_graph.mojo @ d15dfbe). Shared constants, embedding layout (A = 5, DE = 5, DK = DE + 1 = 6), seed vector, write rule, read, ES budget, task stream and RNG draw order. The only difference anywhere is the inv factor inside _key:

arm inv what the key carries
SUM (treatment) 1.0 neighbour counts — can express ≥ t of colour p
MEAN (naive port) 1.0 / Float32(deg) neighbour colour fractions; degree-blind
MEAN×D (scale-matched control) Float32(D_MAX) / Float32(deg) fractions, at SUM's key magnitude

Why MEAN×D is the load-bearing control (Gate 006's reasoning, unchanged): SUM's key is up to 8× larger than MEAN's, and both the write (LR = 8.0, cross-entropy logistic delta) and the read (sigmoid(g·⟨S,k⟩+c)) are scale-sensitive, so a bare SUM-vs-MEAN win is confounded between counts and magnitude. MEAN×D is degree-blind at SUM's scale. This is why the frozen degree multiset must contain degree D_MAX = 8: if the realised maximum degree were less than D_MAX, MEAN×D would no longer be magnitude-matched and the control would be worthless. Candidate C3 below was disqualified on exactly that ground before it was scored.

Fourth arm — MEAN+DEG, non-gating diagnostic. inv = 1/deg plus an explicit deg/D_MAX key slot (DK = 7, slow_dim = 43), in a separate src/memory_selfmod_graph_deg.mojo. It answers "is degree the whole story?" directly rather than by ceiling argument. Because its slow dimension differs it cannot share the gated arms' RNG stream, so it runs last, after a fresh seed(s) redraw of the identical (deterministic) tasks, leaving the three-arm comparison bit-untouched. It appears in no GO / STOP / PARTIAL condition and may not be promoted to a bar after its number is known — that promotion is on the stone-soup list.

Task family (frozen)

Generated in-test (tests/test_graph_wide_degree.mojo), as the grid family is. Everything below is frozen at this commit and none of it may move again.

  • Nodes: N_NODES = 36 — the grid test's R * C = 6 * 6, so the ES budget stays comparable.
  • Degree sequence: the fixed multiset 12 × 2, 12 × 4, 12 × 8 (Σ = 168, 84 edges), Fisher–Yates-shuffled onto nodes per graph. Contains both (d, 2d) pairs (2,4) and (4,8), and its maximum equals D_MAX = 8. Because the multiset is fixed rather than sampled, the realised degree distribution equals the registered one exactly (asserted per graph) and even parity is automatic.
  • Topology: Havel–Hakimi realisation of that sequence, then 20 × n_edges attempted degree-preserving double-edge swaps. Swaps preserve every degree exactly; a rejected attempt still consumes its 4 RNG draws, so the draw count is fixed independent of rejections. Stub-pairing was ruled out, not overlooked: for this multiset E[self-loops] ≈ 2.6 and E[multi-edges] ≈ 14, giving P(simple) ≈ 1e-7.
  • Node colours: uniform in [0, A_EFF) with A_EFF = 2. The memory's alphabet stays A = 5 and the output colours C1 ≠ C2 are still drawn from all 5, so no constant in src/memory_selfmod_grid.mojo moves — only the input distribution narrows.
  • Rule: out = C1 if (#neighbours with colour p) >= t else C2, p uniform in [0, A_EFF), C1 ≠ C2 uniform in [0, A), and t = 2 fixed.
  • Held-out means fresh topology AND fresh colours AND fresh rule — stronger than the grid test, where topology is a fixed 6×6 torus.
  • Draw order per seed (frozen, load-bearing for CRN pairing): 8 before rules × rand_task(8,8) → 8 meta-fit tasks × rand_task(8,4) → 10 after rules × rand_task(8,8); all ceilings computed from the drawn after rules, consuming no draws of their own.

Registered weakening: t = 2 is fixed, where the grid family draws t ∈ {2,3}. The memory no longer has to infer the threshold per rule, so this family is easier than the grid's. It is forced, not chosen for convenience: on a {2,4,8} support t = 3 makes every degree-2 node always-C2, and every t ∈ {2,3} variant screened came back 0.984 – 0.997 blind — worse than Gate 006's family. Consequence: "reproduces the grid milestone" may not be claimed from this gate without that caveat attached.

Decidability preconditions (frozen — the anti-Gate-003 clause, widened)

All four are exact Bayes ceilings: bucket every node the metric actually scores by exact equality of a feature vector, give each bucket its majority label, average over the 10 after rules. That is the ceiling for any function whatsoever of that feature — strictly stronger than any linear threshold. No fitting, no ES, no memory involved; computed before any arm is fit, which is the ordering Gate 003 died for want of.

statistic feature bucketed on bounds bar
CEIL_count the un-normalised count vector SUM's key must be exactly 1.0
CEIL_const constant any constant predictor folded into CEIL_shallow
CEIL_blind the degree-normalised histogram both MEAN and MEAN×D folded into CEIL_shallow
CEIL_deg degree alone any degree-only reader folded into CEIL_shallow

CEIL_shallow := max(CEIL_const, CEIL_blind, CEIL_deg) ≤ 0.85 at every seed. One bar, one meaning: no shallow reader — constant, degree-only, or any function of the fraction key — may come within 0.10 of the 0.95 GO bar. Violation at any seed ⇒ NOT-TESTABLE, and no arm is fit.

CEIL_count = 1.0 is a correctness assert on the generator and the harness, not a property of the family: the rule is a function of the counts, so anything below 1.0 means a bug. It does not by itself prove the graphs are simple, so simplicity, symmetry, ascending col_idx and degree-multiset equality are asserted directly on every generated graph.

Measured at the frozen family (mojo run -I src tests/test_graph_wide_degree.mojo, seconds, ES-free; these are the registered values and this harness is committed before any arm exists):

seed CEIL_const CEIL_deg CEIL_blind CEIL_count CEIL_shallow RECOV
0 0.6184 0.7948 0.7931 1.0 0.7948 0.458
1 0.6434 0.8135 0.8010 1.0 0.8135 0.442
2 0.6431 0.8028 0.8031 1.0 0.8031 0.448

Worst seed 0.8135, i.e. 0.136 below the 0.95 GO bar and 0.036 under the precondition. Gate 006's family, for contrast: CEIL_blind 0.990, CEIL_const 0.840, RECOV 0.94.

RECOV = (CEIL_blind − CEIL_const)/(1 − CEIL_const) — the share of the headroom above a constant that a degree-blind reader recovers — is reported as a diagnostic with no bar. The plan for this gate proposed RECOV ≤ 0.50 as a fifth bar; screening showed it is not independent of CEIL_const and CEIL_blind (it is a ratio of the two) and that barring it would have selected between candidates on an arbitrary cut rather than on anything the gate claims. This change was made before any arm existed and with the complete screening table published below, which is the only thing that makes it a design decision rather than a moved goalpost. It is recorded here because it is the sort of change that is dishonest when it is silent.

Screening record (complete — every candidate, not the winner)

Gate 006 could register before any Mojo existed. Gate 007 cannot: the thing being registered is the family's decidability, which has to be measured. The rules that keep that honest, all followed:

  1. Candidates proposed from the closed-form ambiguity condition, not by search.
  2. Scored on ES-free ceilings only — the screening program instantiated no memory and imported no learning module. No arm was fit before this gate was committed.
  3. Every candidate tried is listed, with its numbers.
  4. Screening code validated against numbers recorded before it existed: candidate C0 is Gate 006's own family, and it must reproduce Gate 006's Result section.
  5. Selection rule, fixed before reading the table: lowest worst-seed CEIL_shallow; ties broken by lower CEIL_const.
  6. Once written, no generator parameter moves. Re-screening after any arm score exists is on the stone-soup list.

C0 — reproduction check. ER(36, 1/7) + repair, A = 5, t ∈ {2,3} (Gate 006's family): CEIL_blind 0.9899 / 0.9896 / 0.9927, CEIL_const 0.8278 / 0.8205 / 0.8722 (mean 0.8402), CEIL_count 1.0, RECOV 0.942, and the identical realised degree histogram (deg1 0.0353 … deg8 0.1037). Exact match to Gate 006's Result at every digit recorded there. The screening code is validated.

Degree-multiset sweep at A_eff = 5, t = 2 — the change Gate 006 prescribed, in isolation:

id degree multiset CEIL_blind (best seed – worst)
C1 12×2, 12×4, 12×8 0.975
C2 8×2, 14×4, 14×8 0.972
C3 8×2, 10×3, 10×4, 8×6 0.981 — also disqualified: max degree 6 ≠ D_MAX, so MEAN×D is not scale-matched

All t ∈ {2,3} variants of the above: 0.984 – 0.997. Every one over Gate 006's own 0.92 NOT-TESTABLE bar. The degree distribution alone cannot fix decidability.

Colour-alphabet × degree-multiset sweep, all t = 2, all with max degree 8, seeds 0/1/2 (CEIL_count = 1.0 everywhere):

id degree multiset A_eff CEIL_blind CEIL_const CEIL_deg RECOV
C1 12×2, 12×4, 12×8 2 0.793 / 0.801 / 0.803 0.618 / 0.643 / 0.643 0.795 / 0.814 / 0.803 0.458 / 0.442 / 0.448
C2 8×2, 14×4, 14×8 2 0.855 / 0.859 / 0.833 0.690 / 0.712 / 0.692 0.802 / 0.813 / 0.810 0.533 / 0.510 / 0.458
C4 18×2, 9×4, 9×8 2 0.822 / 0.816 / 0.794 0.548 / 0.543 / 0.538 0.776 / 0.787 / 0.787 0.605 / 0.597 / 0.555
C5 6×2, 15×4, 15×8 2 0.861 / 0.870 / 0.876 0.735 / 0.734 / 0.745 0.819 / 0.820 / 0.827 0.475 / 0.510 / 0.514
C1–C5 (all four) 3 0.878 – 0.929 0.53 – 0.65 0.734 – 0.811 0.739 – 0.796
C1–C5 (all four) 4 0.938 – 0.967 0.60 – 0.75 0.723 – 0.823 0.828 – 0.871
C1–C5 (all four) 5 0.964 – 0.983 0.71 – 0.82 0.734 – 0.835 0.857 – 0.909

Worst-seed CEIL_shallow: C1 0.8135, C4 0.822, C2 0.859, C5 0.876; every A_eff ≥ 3 row fails on CEIL_blind. Two candidates clear 0.85 — C1 wins on the selection rule (lower worst-seed shallow ceiling), and C4 is the named runner-up. C4's CEIL_const is better (0.545 vs 0.635) and its CEIL_deg is lower (0.787 vs 0.814); C1's advantage is on the statistic the rule selects on. Recording the trade-off so that any later switch to C4 is visibly a post-hoc move.

The finding the sweep establishes independently of any arm: Gate 006's structural premise is false for A ≥ 3. MEAN is not structurally unable to express count rules — it is ambiguous only on reducible (near-monochromatic) neighbourhoods, which are rare unless the alphabet is tiny. Decidability and non-degeneracy are in direct tension in this family class: the alphabet that makes the blind arm genuinely blind is the same one that lifts degree-only prediction to ~0.80. This gate runs in the narrow window where both fit.

Reproduction contract (checked FIRST; failure ⇒ NOT-TESTABLE)

Nothing below is scored unless both clauses pass.

1. Zero core changes. Empty git diff on src/esper_evolution.mojo, src/memory.mojo, the Domain trait in src/arc_io.mojo, and ExamplePair / Task in src/hope.mojo. A diff to any of these is NOT-TESTABLE, not a STOP — the gate would be measuring a different architecture.

2. The arms are the same bytes that reproduced the grid milestone bitwise. Empty git diff d15dfbe -- src/memory_selfmod_graph.mojo src/graph_domain.mojo, and ./esper test graph_lattice_repro still passes bitwise: before 0.74175346 / after 1.0, bits 1061020558 / 1065353216. This is what makes "only the family changed" a mechanical fact rather than a claim.

Refuting controls

  • MEAN — the naive port. If it matches SUM, the hypothesis is refuted: the key's count-sensitivity was not what carried the milestone.
  • MEAN×D — degree-blind at SUM's key magnitude. If it matches SUM, the win was scale, not counts (Gate 005's lesson: the control beside a claim must be matched on the nuisance dimension).
  • CEIL_shallow — bounds every shallow reader before any fit, so a family that could not produce a "no" is caught in seconds rather than after 30 minutes of unscoreable fits.
  • before(SUM) — the E = 0 seed must fail, or emergence is vacuous.

GO / STOP / PARTIAL / NOT-TESTABLE thresholds (committed now)

NOT-TESTABLE — nothing below is scored if any trips: either contract clause fails; CEIL_shallow > 0.85 or CEIL_count ≠ 1.0 at any seed; after(MEAN) ≥ 0.95; all three gated arms tie.

GO — every condition, at all three seeds: contract passes; all preconditions hold; after(SUM) ≥ 0.95 (parity with the grid milestone's own bar); after(SUM) ≥ CEIL_shallow + 0.10; before(SUM) < 0.85; after(SUM) − after(MEAN) ≥ 0.10 and after(SUM) − after(MEAN×D) ≥ 0.10, with no per-seed overlap (min_s after(SUM) > max_s after(MEAN×D)).

STOP — any one trigger at ≥ 2 of 3 seeds: after(SUM) < 0.85 (the class does not carry to variable degree — the likeliest "no"); |after(SUM) − after(MEAN×D)| ≤ 0.05 while after(SUM) ≥ 0.85 (scale, not counts); before(SUM) ≥ 0.85 (vacuous emergence).

PARTIAL: after(SUM) ∈ [0.85, 0.95) with both controls separated and non-overlapping (carries, but not at grid parity); or any GO condition holding at exactly 2 of 3 seeds — seed splits are never rounded up.

Budget and seeds: Gate 006's verbatim. Seeds {0,1,2}, each redrawing everything (topologies, colours, all three rule sets, all ES RNG) — an independent family draw per seed, not a re-read of one family under fit noise. Within a seed the three gated arms are CRN-paired on one continuous RNG stream, run back-to-back, and must consume identical draw counts (asserted empirically, not assumed).

Disclosure — the ways this gate is weaker than it looks

Stated plainly because each of them limits what a GO may claim:

  1. The separation clauses cannot themselves produce a "no". With CEIL_shallow ≤ 0.85 enforced as a precondition, both blind arms are already bounded at 0.85, so after(SUM) ≥ 0.95 implies the 0.10 separations. MEAN×D's real job here is the STOP direction: catching a SUM that lands near the blind ceiling — a result that was blind-reachable all along.
  2. t = 2 is fixed, where the grid family draws t ∈ {2,3}. This family is easier. "Grid parity" may not be claimed without the caveat.
  3. A_eff = 2. A two-colour input world is a genuinely narrower claim than the grid milestone's five, and separating two colour embeddings is easier than five. The non-vacuity bar still bites (CEIL_const ≈ 0.635 < 0.85), but a GO here supports "counts carry to graphs in a 2-colour world", not "counts carry to graphs".
  4. CEIL_deg ≈ 0.80 is intrinsic, not tuned away. An absolute threshold on a binomial count is inherently degree-sensitive, so part of what the count key carries is degree. The GO bar sits 0.14 above it, and the MEAN+DEG diagnostic exists to say how much of the gap is colour — but that arm is non-gating, so a GO does not by itself decompose the win.
  5. This gate was registered after measurement, unlike Gate 006. The mitigations are the complete screening table above, the ES-free/no-memory constraint on the screening code, the fixed selection rule, and this commit predating any arm code.

Anti-stone-soup clause

Gate 006's list applies in full (single COLD meta-fit per arm; no per-rule staging, mid-fit boosts, warm starts, or per-arm tuning of LR / META_EPOCHS / g / c / sigma / alpha / N / iters; no more than the single inv line differing between gated arms; no raising iters above 1000; no reporting node accuracy when exact match fails; no best-of-seeds, no dropped seed, no mean-over-seeds where non-overlap fails; no relaxing the bitwise lattice contract to a tolerance; no computing ceilings after the arms are fit). On top of it, specific to this gate:

  • No re-screening the family after any arm score exists — not the degree multiset, not A_EFF, not t, not the swap count. They are frozen in this commit, which predates every arm number.
  • No switch to runner-up C4 (or any other screened candidate) after seeing C1's arms.
  • No edit to src/memory_selfmod_graph.mojo or src/graph_domain.mojo — byte-identity to d15dfbe is asserted by contract clause 2.
  • The MEAN+DEG diagnostic may not be promoted to a bar, and may not be run before the three gated arms.
  • RECOV may not be re-promoted to a bar after the arms are scored, in either direction.

Frozen constants: N_NODES = 36; degree multiset 12×2, 12×4, 12×8; D_MAX = 8; SWAPS_PER_EDGE = 20 (attempted, 4 draws each); A = 5, A_EFF = 2, DE = 5, DK = 6; rule ≥ t of colour p with t = 2, C1 ≠ C2; 8 before rules, 8 meta-tasks × (8 demos, 4 test), 10 after rules; META_EPOCHS = 12; LR = 8.0; ES (N=64, alpha 0.1→0.003, sigma 0.5→0.01, iters=1000); seeds {0,1,2}; CEIL_shallow ≤ 0.85; CEIL_count = 1.0; GO bar 0.95; non-vacuity bar 0.85; separation 0.10 plus non-overlap; STOP bars 0.85 / 0.05.

Scope of new code at eval (nothing else may be added): the arm block appended to tests/test_graph_wide_degree.mojo, argv-gated behind --arms so the default path stays ES-free; and src/memory_selfmod_graph_deg.mojo for the non-gating diagnostic. No new learning machinery — meta_fit_selfmod and _selfmod_meta_fitness are used unchanged, and touching them fails the reproduction contract.

Consequence

GO ⇒ a graph rung is created on docs/ROADMAP.md, and M4's relational key is built over GraphDomain rather than hand-typed sandbox relations — with the A_eff = 2 and t = 2 caveats carried into the claim. STOP ⇒ the graph direction closes with a measured reason, and the other two open directions (the LLM pivot in docs/esper-pivot-report.md; staying on grids under Vision T) proceed. NOT-TESTABLE a second time ⇒ the graph direction closes on "no decidable family in this class", which the screening above has already half-established.

Result — GO (2026-07-28)

Run: mojo run -I src tests/test_graph_wide_degree.mojo --arms, ~20 min (12 cold meta-fits: 3 seeds × 3 gated arms, then 3 seeds × 1 non-gating diagnostic). New code: the argv-gated arm block in tests/test_graph_wide_degree.mojo and src/memory_selfmod_graph_deg.mojo.

Every GO condition holds at every seed, and no STOP or NOT-TESTABLE trigger fires anywhere.

The gated three-arm table

seed CEIL_shallow SUM before / after MEAN before / after MEAN×D before / after
0 0.7948 0.52907986 / 1.0 0.52907986 / 0.56666666 0.52907986 / 0.615625
1 0.8135 0.60026044 / 1.0 0.60026044 / 0.53229165 0.60026044 / 0.51736116
2 0.8031 0.49782985 / 0.99930555 0.49782985 / 0.4822917 0.49782985 / 0.49861115

Verdict inputs as printed: GO-seeds 3, min(SUM_after) 0.99930555 > max(MEANxD_after) 0.615625, STOP#1 0, STOP#2 0, STOP#3 0, MEAN>=0.95 seeds 0, tied seeds 0.

Per-seed clause check — every one satisfied with margin, not at the edge:

clause seed 0 seed 1 seed 2
after(SUM) ≥ 0.95 1.0 1.0 0.9993
after(SUM) ≥ CEIL_shallow + 0.10 +0.105 +0.087 +0.096
before(SUM) < 0.85 0.529 0.600 0.498
after(SUM) − after(MEAN) ≥ 0.10 0.4333 0.4677 0.5170
after(SUM) − after(MEAN×D) ≥ 0.10 0.3844 0.4826 0.5007

The non-overlap clause — the one the ROADMAP's headroom rule exists to enforce, requiring the worst treatment seed to beat the best control seed — clears by 0.38, so no amount of seed spread could be wearing GO's clothes here.

What the controls did

Both refuting controls were live and both said "no" to their own failure mode:

  • MEAN (naive port) landed 0.48–0.57, i.e. barely above its own cold before. The naive degree-blind port genuinely does not carry the milestone on this family — which is exactly what Gate 006's family could not have shown, since there MEAN was capable of ~0.99.
  • MEAN×D (degree-blind at SUM's key magnitude) landed 0.50–0.62. This is the load-bearing one: it had SUM's key magnitude and still failed, so SUM's win is information, not scale. That was the failure mode most likely to make every later graph claim unfalsifiable, and it is now measured shut.

The before column is a free internal check

Within each seed all three arms report a bit-identical before (0.52907986 / 0.60026044 / 0.49782985). This is mechanically forced and worth recording: at the E = 0 cold seed the embedding block is zero, so k[b] = 0 · inv = 0 whatever inv is, and only the constant bias slot k[DE] = 1.0 survives. The three arms therefore are the same cold predictor, and the identical floats confirm both that the arms differ in nothing but inv and that the CRN pairing is real. It is also well under the 0.85 non-vacuity bar and in fact below CEIL_const ≈ 0.62–0.64 — the cold prior emits a constant, not the best constant — so the emergence claim is not vacuous: the meta-fit had to discover separable colour embeddings.

The equal-draw check passed empirically as registered: slow_dim 41, ES draws/arm 2624000, post-fit probe 0.8674205371297539 bit-equal across all three gated arms.

The non-gating MEAN+DEG diagnostic — the most informative number in the run

seed MEAN+DEG before / after
0 0.6835938 / 0.99201393
1 0.671441 / 0.9736112
2 0.67491317 / 0.996875

A degree-blind fraction key plus one explicit deg / D_MAX slot recovers essentially all of SUM's result. This is registered as a diagnostic and stays one — it appears in no GO / STOP / PARTIAL condition and, per the anti-stone-soup clause, may not be promoted to a bar now that its number is known, in either direction.

Read correctly it supports the hypothesis rather than complicating it. count_c = fraction_c × deg, so (fractions, degree) is informationally equivalent to counts; MEAN+DEG can express the rule class and does. Placed beside MEAN×D — same fractions, same magnitude as SUM, no degree information, 0.50–0.62 — the pair decomposes the result cleanly:

The un-normalised sum is one way to carry count information, not a privileged one. What the milestone needs is that the key carry counts at all; how the arithmetic gets them there is free. Magnitude is irrelevant (MEAN×D), degree-plus-fractions is sufficient (MEAN+DEG), fractions alone are not (MEAN).

Note also that this is not the degree-only degeneracy the fifth instrument was added to catch: a degree-only reader is capped at CEIL_deg ≈ 0.80 by construction, so MEAN+DEG at 0.99 is demonstrably reading colour and degree together, not degree alone.

Metric scale — checked, because the precondition clause depends on it

GraphDomain.score calls the same exact_match in src/arc_io.mojo that GridDomain.score calls, and it returns the fraction of nodes matching (partial credit; a rule scores exactly 1 only when every node of every test graph is right). The four ceilings are per-node majority accuracy. The two are therefore on the same per-node scale, which is what makes after(SUM) ≥ CEIL_shallow + 0.10 a valid apples-to-apples bar rather than a category error — and what keeps the number directly comparable to the grid milestone's own 1.0.

Reproduction contract — both clauses passed before anything was scored

  1. Zero core changes: empty git diff on src/esper_evolution.mojo, src/memory.mojo, src/arc_io.mojo, src/hope.mojo.
  2. Arms byte-identical to d15dfbe: empty git diff on src/memory_selfmod_graph.mojo and src/graph_domain.mojo, and ./esper test graph_lattice_repro reproduced bitwise — before 0.74175346 / after 1.0, bits 1061020558 / 1065353216, the registered targets.

The family is likewise provably unmoved: the arm-block diff is 398 lines added, 12 removed, and all 12 removed lines are the stale header block plus one import line — not one line of the generator, the ceiling code, or the family constants. The default ES-free path still prints the registered ceilings digit for digit (CEIL_const 0.6184 / 0.6434 / 0.6431, CEIL_deg 0.7948 / 0.8135 / 0.8028, CEIL_blind 0.7931 / 0.8010 / 0.8031, CEIL_count 1.0 at every seed).

What this GO does and does not license

Does: the Domain / SelfModMemory seams carry the grid's count-rule milestone to a variable-degree CSR graph substrate at grid parity (1.0 / 1.0 / 0.9993 against the grid's own 1.0), on the same budget, through an unmodified ES core — and it carries because the key reads counts, with the scale explanation measured shut. Gate 006 banked the seams being substrate-neutral; Gate 007 banks the learning result transferring across substrates.

Does not: this is the narrower two-colour, fixed-threshold world, and both weakenings were registered before the run, not discovered after:

  1. A_eff = 2. A two-colour input world is a genuinely narrower claim than the grid milestone's five; separating two colour embeddings is easier than five. GO here supports "counts carry to graphs in a 2-colour world", not "counts carry to graphs".
  2. t = 2 fixed, where the grid family draws t ∈ {2,3}. The memory no longer has to infer the threshold per rule. "Reproduces the grid milestone" may not be claimed without that caveat attached — and the tension is structural, not lazy: every t ∈ {2,3} variant screened came back CEIL_blind 0.984–0.997, i.e. undecidable.
  3. The ceiling was barred as a precondition, so the GO separation clauses were implied before the run and could not themselves have produced a "no". MEAN×D's real job here was the STOP direction, and the honest reading is that it could have fired and didn't.

Per the registered Consequence: a graph rung is created on docs/ROADMAP.md, and M4's relational key is built over GraphDomain rather than hand-typed sandbox relations — carrying the A_eff = 2 / t = 2 caveats into the claim.

Named next lever (deferred, not run here)

The obvious follow-up is the one this gate's own screening table makes cheap to reason about: widen A_eff back toward the grid's 5 and restore t ∈ {2,3}, which the screening says immediately lifts CEIL_blind to 0.94–0.99 and makes the degree-blind controls toothless again. So a straight "widen it back" re-run is not available — it would be Gate 006 a third time. Any such gate needs a different discriminating instrument than a degree-blind control, and must be registered before it is built. Recorded here so the option is named rather than invented later.