Skip to content

[EPIC] IGLA-Coder: custom multi-language code model for t27 #1032

Closed

Description

@gHashTag

Goal

Build "IGLA-Coder": a small, deployable code-generation model that emits code in any programming language, trained on the IGLA RACE Rust stack (gHashTag/trios-trainer-igla) and wired into the t27 spec-first toolchain as a downstream consumer for the non-sealed language targets. Find the best training parameters with evidence (control ablation on a code loss), not assertion.

Why it matters

t27 already produces a parallel, compiler-verified multi-language corpus: one .t27 spec is deterministically emitted into the same module across many targets (gen/c and gen/verilog ~33 modules each; gen/numeric one catalog in 16 languages). This is a built-in spec->code and code<->code translation signal that no public small code model has. The current Python emitter is an explicit stub (bootstrap/src/codegen_python.rs) -- exactly the gap an ML coder fills.

Source of truth

Deliverable

A pilot 50-200M coder with measured MultiPL-E pass@1 across >=6 languages, an evidence-backed best-parameter table (phi vs standard control), a t27-native executable eval, and an integration path t27c gen --backend ml --lang <X> for non-sealed targets.

Sub-tasks (checkboxes)

Done when (acceptance)

A reproducible pilot coder beats a documented baseline on MultiPL-E and the t27-native eval; the best-parameter choice is backed by a control ablation with confidence intervals and Gamma_tip robustness; phi claims carry claim-status labels.

How to verify

MultiPL-E via the BigCode evaluation harness; t27-native eval runs emitted test/invariant/bench blocks as oracles; F2 dual-mediation CSV attributes BPB deltas; reproducibility capsule (seeds + frozen config + sha256).

Risks / blockers

Real-BPB code pipeline + compute + corpus access are the recurring prerequisites (same blockers as #1021). The deterministic Verilog/silicon emitter is never replaced by the ML model (L6 CEILING). Honesty mandate: the method survives, phi does not (yet); only phi^2 + phi^-2 = 3 is Verified.

Status update -- 2026-06-16

Now: P0-P3 complete. P0 baseline frozen; P1 corpus extracted; P2 architecture shipped; P3 closed with honest null result (no phi-specific optimizer benefit at sub-1M params). P5 evaluation harness advancing (resumable curriculum, n=32 eval bundle, Wilson power front-end).
Next: P4 pilot pretraining gated by compute budget; P5 capacity scan (hidden=192/256) to locate first non-zero compile@1.
Blocked: P4/P6 compute budget approval pending.

Links

Companion #1021; trios-trainer-igla README; The Stack v2; MultiPL-E; Qwen2.5-Coder, OpenCoder, Phi-1, BitNet b1.58 (see research_code_llm_sota.md).

Anchor: phi^2 + phi^-2 = 3

Activity

  1. gHashTag commented on Jun 1, 2026

    @gHashTag
    CollaboratorAuthor

    Compute decision (2026-06-01): Railway control plane + rented GPU worker

    Directive: use Railway. Honest constraint: Railway has no GPU (CPU/RAM/volumes/egress only - Railway Pricing, Railway docs). So:

    Layer Where
    Orchestration / job submission (tri deploy, tri race) Railway
    Run ledger + SSOT (BPB, seed_results, F2 CSV) Railway Postgres (read-only default)
    Checkpoint / artefact storage Railway volume / Object Storage
    Actual GPU training (P3/P4/P6) Rented GPU worker (Runpod / Vast / Lambda), reports back to Railway, then shuts down

    GPU plan, cheapest-first:

    1. P0-P2: $0, runs locally / in sandbox (tokenizer, data spine, arch port, real NTP loss).
    2. P3+P4 (50-200M params, 50-200B tokens): single A100 80GB or 4090/3090-class by the hour. Est. ~$200-800 total, days of wall-clock. [Empirical fit] - phi-1 1.3B used ~770 A100-hours for 50B curated tokens; our pilot is smaller.
    3. P6 (0.5B-1.5B): multi-A100/H100, budget-gated, only after P5 pass@1 gate.

    Net: keep Railway where it is strong (orchestration + ledger + storage); GPU is a disposable rented worker. Start P0-P2 now at $0. Do not put the trainer on Railway.

    Open input: confirm a per-month GPU spend ceiling for the pilot (e.g. cap $500).

  2. gHashTag commented on Jun 1, 2026

    @gHashTag
    CollaboratorAuthor

    CORRECTION to the previous compute comment (2026-06-01)

    The earlier "rented GPU worker" comment was wrong and is retracted. Audited facts:

    • The crate is named cpu_train; Cargo.toml: "Portable Rust-only pipeline that runs on any CPU machine, Railway, Fly, or Docker."
    • Optimizer is hand-written AdamWCpu (pure Rust, no CUDA), used by all trainers.
    • GPU/Candle/CUDA is an optional, off-by-default gpu feature; the canonical path never enables it.
    • The champion BPB=2.2111 was produced ON Railway (hidden=384, 81K steps, AdamW, tiny_shakespeare; README "Results (Railway, 2026-04-27)"), deployed via railway up across 3 seeds with Dockerfile + entrypoint.sh.

    Corrected decision: Railway CPU IS the trainer. No GPU.

    Concern Where / How
    Training Railway services, CPU-only, one per seed (railway up --service igla-seed-$s)
    Optimizer AdamWCpu (phi-arm with_phi_defaults, standard arm with_params)
    Build/deploy existing Dockerfile + entrypoint.sh (extend env with code-data + tokenizer vars)
    Ledger + SSOT Railway Postgres (read-only default)
    Artefact storage Railway volume / Object Storage
    GPU not used

    Model size + token budget are CPU-bound, set empirically in P4 by timing a real cpu_train run on a code corpus. P6 "scale-up" = more steps / wider hidden / more seeds on Railway CPU, NOT GPU. 0.5B-1.5B GPU-scale is out of scope unless the CPU pipeline is explicitly replaced.

    Open input: per-seed CPU wall-clock / Railway spend budget, and number of parallel seed services (champion used 3).

  3. gHashTag commented on Jun 1, 2026

    @gHashTag
    CollaboratorAuthor

    IGLA-Coder P3 update -- full backprop verified, honest phi-vs-standard ablation

    Code: branch feat/igla-coder-v1 in gHashTag/trios-trainer-igla (PR #186).

    What landed

    • Full multi-head, multi-layer backward pass (replaces the v1 attention stub).
    • gradcheck: analytic vs f64 numerical gradient -> PASS, 14 checks, 0 fails
      (emb, w1, w2, wq, wv, wo). Fixed a real transposed-matmul bug in the MLP-input
      gradient found during this pass.
    • ablate: phi vs standard AdamW, N seeds, code-BPB + CI95. Equal learning rate;
      only beta1/weight_decay differ.

    Honest ablation result (CPU, hidden=64, 3 seeds, each arm at its own best LR)

    Arm LR mean code-BPB CI95 stability
    standard AdamW 0.004 5.0542 +/-0.0886 stable on all 3 seeds
    phi (beta1=phi^-1, wd=phi^-3) 0.002 6.3432 (1/3 diverged) +/-1.6560 diverged on seed 43
    phi (2 converged) 0.002 5.4984 +/-0.0371 --

    Verdict [Empirical fit]: phi-specificity for IGLA on code BPB is NOT supported
    by this ablation. Tuned standard AdamW reaches lower BPB and is more stable; the
    phi optimizer prior even loses on its converged seeds (disjoint CI95). Recorded as
    a negative result, stated first. Only phi^2 + phi^-2 = 3 stays [Verified].

    Caveats: code BPB only (not pass@1); small n=3; single 300-step horizon; NOT
    comparable to the tiny_shakespeare champion BPB=2.2111 (different data/vocab/
    model/scale). Positional embeddings fixed (v-series scope). muP LR-transfer probe
    inconclusive at this horizon -- reported as a limitation, no transfer claimed.

    The method survives (verified backprop + ablation harness); the phi prior does not
    (here).

  4. gHashTag commented on Jun 1, 2026

    @gHashTag
    CollaboratorAuthor

    Loop update: pre-norm RMSNorm + trainable positional embeddings

    Closing two audit weak-spots and re-running the control ablation with normalization.

    Engineering (the durable asset):

    • Pre-norm RMSNorm: two norms per block (pre-attention, pre-MLP) + a final
      pre-logit norm, each with a learnable per-channel gain. Full analytic backward.
    • Positional embeddings are now trainable (previously fixed).
    • Fixes W1 (header claimed "pre-norm residual blocks" but the model had no
      normalization) and W2 (pos-emb not trained).

    Verification:

    • gradcheck: checks=23 fails=0 (analytic vs f64 central-difference, gate
      abs < 2e-3 OR rel < 5%). New families covered and passing: pos-emb, final-norm
      gain, pre-attn gain, pre-mlp gain.
    • cargo fmt --all -- --check clean; cargo clippy --all-targets -- -D warnings
      clean.

    Empirical result (negative, stated first). hidden=64, heads=4, layers=2,
    300 steps, 3 seeds (42/43/44), LR re-swept per arm, held-out code-BPB. Not
    comparable
    to the tiny_shakespeare champion BPB=2.2111.

    Arm beta1 weight_decay mean BPB std
    standard 0.9 0.04 4.395 0.095
    phi (both) phi^-1 phi^-3 7.239 0.688
    phi_b1 (momentum only) phi^-1 0.04 5.190 0.021
    phi_wd (decay only) 0.9 phi^-3 7.939 0.033

    RMSNorm did not rescue the phi prior; the failure mode merely shifted from
    divergence (no-norm, prior loop) to under-fitting/freezing (with-norm).

    Attribution (new finding): the phi^-3 weight_decay anchor (~6x the standard
    0.04) is the dominant failure cause under pre-norm -- the phi_wd arm is
    near-frozen, while the phi_b1 (momentum-only) arm still learns. Consistent with
    the weight-decay-dominates-LR-transfer literature. The phi optimizer prior is
    falsified at this scale by a fair equal-LR control. The method survives; phi
    does not (yet). Anchor: phi^2 + phi^-2 = 3.

    Refs #181.

  5. gHashTag commented on Jun 1, 2026

    @gHashTag
    CollaboratorAuthor

    Loop+1 update -- decay isolation (A) + power (B) + F2 mediation (C)

    Commit: bd2b06e on feat/igla-coder-v1. gradcheck 23/0 PASS; fmt + clippy clean; F2 CSV schema PASS.

    Headline (negative result first): phi-momentum does NOT beat tuned standard AdamW. At matched low weight decay the arms are a statistical tie; at canonical wd=0.04 the phi arm is +0.89 BPB worse. The method survives, phi does not (yet). Only phi^2 + phi^-2 = 3 is [Verified].

    A -- weight-decay isolation (hidden=64, 300 steps, lr=0.03, 3 seeds, bootstrap 95% CI)

    wd standard phi_b1 diff (phi_b1 - standard) verdict
    0.04 4.395 [4.311, 4.528] 5.283 [5.100, 5.588] +0.888 [+0.653, +1.182] phi worse
    0.02 3.775 [3.765, 3.794] 3.893 [3.862, 3.920] +0.118 [+0.088, +0.147] phi slightly worse
    0.01 3.641 [3.588, 3.719] 3.641 [3.624, 3.657] -0.0005 [-0.073, +0.054] TIE

    Low wd helps both arms; phi-momentum closes to a tie, never overtakes. The phi^-3 wd magnitude (0.236), not phi-momentum, was the prior-loop killer.

    B -- power run (hidden=128, 800 steps, lr=0.01, wd=0.02, 5 seeds)

    phi_b1 4.313 (sd 0.457) vs standard 4.181 (sd 0.109); diff +0.132 BPB, 95% CI [-0.152, +0.548], p~0.56 -> TIE. Power floor at n=5 is ~0.66 BPB; phi_b1 is ~4x more variable (one unstable seed at 5.11).

    C -- F2 long-form CSV + stratified-CDE mediation

    2x2 factorial, mediators M1=momentum (beta1), M2=decay (wd). CSV is F2-contract compliant (W3C-PROV preamble + INPUT STRATUM = canonical banner + ASCII snake_case headers); schema validator PASS. Pearl CDE + VanderWeele 4-way decomposition, bootstrap CI + Gamma_tip:

    Path-specific effect effect (BPB) 95% CI Gamma_tip status
    CDE_decay | momentum=0 +3.544 [+3.420, +3.643] 65.2 robust [Verified]
    CDE_momentum | decay=0 +0.888 [+0.653, +1.182] 8.20 robust [Verified]
    CDE_momentum | decay=phi^-3 -0.686 [-1.564, +0.024] 3.13 spans 0 [Conj]
    Total effect (both phi on) +2.858 [+2.020, +3.565] 8.87 robust [Verified]
    Mediated-interaction -1.574 [-2.410, -0.844] 5.47 robust [Verified]

    Decomposition identity exact: CDE_dec + CDE_mom + interaction = TE = +2.858. The phi^-3 decay path is the dominant harmful path; the two phi knobs are sub-additive (negative interaction). Refs Pearl 2001, VanderWeele 2015, VanderWeele & Ding 2017, Zhao & Luo 2024.

    Full report + reproducible scripts in coder_ablation/. Three options (A more seeds/curves; B real F2 toolchain bridge + wd0 stratum; C lr x wd frontier + phi-lr arm) in coder_ablation/LOOP_REPORT.md.

    Refs #181

  6. gHashTag commented on Jun 2, 2026

    @gHashTag
    CollaboratorAuthor

    IGLA-Coder Loop+2 -- power (A) + real F2 bridge (B) + lr x wd frontier (C)

    CPU-only. Outcome = code_val_bpb (lower better), not comparable to the
    tiny_shakespeare champion (different corpus). Negative result first: phi
    still does not beat tuned standard AdamW.
    Only phi^2 + phi^-2 = 3 is
    [Verified]. The method survives, phi does not (yet).

    A -- power (hidden=128, 1000 steps, lr=0.01, wd=0.02, 6 seeds, best-checkpoint)

    readout delta (phi_b1 - standard) 95% CI verdict
    final +0.246 [-0.166, +0.742] TIE, phi 2.7x variance
    best -0.005 [-0.136, +0.156] TIE (CI spans 0)

    Best-checkpoint readout collapses the final-step gap to zero. phi_b1's only
    real difference is variance (max best-vs-final instability 1.46 BPB vs 0.33).
    phi-momentum is less stable, not better. [Conj]

    B -- real F2 Rust bridge + wd0 stratum

    New src/bin/f2_dual_mediation.rs (registered in Cargo.toml) reproduces the
    numpy stand-in on the canonical CSV (CDE_decay +3.544 / Gamma 64.8;
    CDE_momentum +0.888 / Gamma 8.2; TE +2.858; interaction -1.574; all
    [Verified]). New wd0 stratum (weight_decay pinned to 0, Pearl
    single-mediator CDE along non-decay paths):

    stratum CDE_momentum (BPB) 95% CI Gamma_tip status
    canonical (wd=0.04) +0.888 [+0.653, +1.182] 8.20 [Verified]
    wd0 (wd=0) -0.268 [-0.367, -0.180] 7.21 [Verified]

    Sign flip: phi-momentum's controlled direct effect is entirely conditional
    on the weight-decay regime
    -- harmful at canonical wd=0.04, helpful at wd=0.
    Real training uses non-zero wd, so the operative regime is the one where
    phi-momentum hurts. 4 unit tests, all green.

    C -- lr x wd frontier + phi-lr arm (hidden=64, 300 steps, 3 seeds)

    phi-lr = 0.03 * phi^-1 = 0.0185410197. Frontier-reach test vs standard
    (lr=0.03, wd=0.02, mean 3.775):

    config delta vs frontier 95% CI reaches?
    standard_philr_wd02 +0.311 [+0.270, +0.342] NO (worse)
    allphi +4.237 [+4.184, +4.274] NO (worse)
    phi_tempered_philr_wd02 +0.457 [+0.384, +0.512] NO (worse)

    No phi-derived config reaches the standard frontier; all CIs above zero. The
    MDL "one phi constant generates a competitive config" hypothesis is
    rejected at this scale. [Efit -> falsified]

    Verification

    gradcheck 23/0; cargo fmt --all -- --check clean; cargo clippy --all-targets -- -D warnings clean; cargo test --release --bin f2_dual_mediation 4/4 pass; F2 CSV schema PASS on canonical + wd0.

    Claim-status summary

    • [Verified] phi^2+phi^-2=3; decomposition identity; four canonical CDEs;
      wd0 CDE_momentum sign flip. These describe phi's regime-dependent / harmful
      effects, not a benefit.
    • [Conj] phi_b1 ties standard at best-checkpoint (no better, higher variance).
    • [Efit -> falsified] no phi-derived config reaches the frontier.
    • [Retr] "phi-momentum beats standard"; delta_CP = 3/phi^2.

    Refs #181

  7. gHashTag commented on Jun 2, 2026

    @gHashTag
    CollaboratorAuthor

    IGLA-Coder Loop+3 -- third stratum (mom_std) + cross-stratum CDE stability

    CPU-only. Outcome = code_val_bpb (lower better), not comparable to the
    tiny_shakespeare champion (different corpus). Negative result first: phi
    still does not beat tuned standard AdamW.
    Only phi^2 + phi^-2 = 3 is
    [Verified]. Method survives, phi does not (yet).

    Audit decision: warmup0 dropped, mom_std added

    The proposed warmup0 stratum is fictitious for this trainer -- igla_coder
    has no LR warmup and no schedule (lr is constant). Pinning a non-existent
    mediator would violate the f2-mediation-loop rule (a stratum must pin a real
    mediator carrying >= 50% of the IE). Replaced with the honest symmetric
    completion of the 2x2 factorial: mom_std pins momentum (beta1=0.9) and
    varies decay (0.04 -> phi^-3), giving a Pearl CDE of decay along non-momentum
    paths.

    The three strata

    stratum PSE effect (BPB) 95% CI Gamma_tip status
    canonical CDE_momentum (decay=0) +0.888 [+0.653, +1.182] 8.20 [Verified]
    canonical CDE_decay (momentum=0) +3.544 [+3.419, +3.643] 64.82 [Verified]
    wd0 CDE_momentum (decay pinned) -0.268 [-0.367, -0.180] 7.21 [Verified]
    mom_std CDE_decay (momentum pinned) +3.544 [+3.420, +3.643] 65.16 [Verified]

    Cross-stratum stability (the Loop+3 finding)

    mediator canonical other stratum CI overlap sign agree stable
    momentum +0.888 wd0 -0.268 No No False
    decay +3.544 mom_std +3.544 Yes Yes True

    The two phi knobs behave categorically differently:

    • decay (phi^-3): regime-independent, robustly harmful -- identical CDE to
      4 dp whether momentum is free or pinned, Gamma ~65 in both. No regime
      rescues it.
    • momentum (phi^-1): regime-dependent -- helpful only at wd=0; harmful at
      the canonical wd=0.04 that real training uses.

    This is the strongest causal statement the coder track supports, and it is a
    statement about phi's liabilities and conditionality, not its benefits. The
    NeurIPS 2024 warmup paper (arXiv:2410.23922) explains the mechanism: warmup
    normally absorbs Adam's beta1 bias-correction shock and interacts with weight
    decay; this trainer lacks warmup, so the phi^-1 momentum arm is the unstable
    one measured in Loop+2.

    Implementation

    • f2_dual_mediation: single-mediator branch generalised to detect which
      mediator is pinned (decay-pinned -> momentum CDE; momentum-pinned -> decay
      CDE). +1 unit test (5 total).
    • coder_ablation/emit_f2_mom_std.py, coder_ablation_f2_mom_std.csv.
    • coder_ablation/stratum_compare_coder.py: cross-stratum comparator with
      stable_across_strata per mediator.
    • validate_f2_csv.py: KNOWN_STRATA += mom_std.

    Verification

    gradcheck 23/0; cargo fmt --all -- --check clean; cargo clippy --all-targets -- -D warnings clean; cargo test --release --bin f2_dual_mediation 5/5 pass; F2 CSV schema PASS on canonical + wd0 + mom_std.

    Claim-status summary

    • [Verified] phi^2+phi^-2=3; decomposition identity; four canonical CDEs;
      mom_std decay CDE; both cross-stratum stability verdicts. All describe phi's
      harmful or conditional effects, not a benefit.
    • [Conj] wd0 momentum benefit is real but regime-specific (wd=0 only).
    • [Efit -> falsified] (Loop+2, unchanged) no phi-derived config reaches the
      frontier.
    • [Retr] "phi-momentum beats standard"; delta_CP = 3/phi^2.

    Refs #181

  8. gHashTag commented on Jun 7, 2026

    @gHashTag
    CollaboratorAuthor

    IGLA-Coder Loop+9 -- iso-everything axis test (pure beta1 momentum, isolated)

    CPU-only. Outcome = code_val_bpb (lower better), not comparable to the
    tiny_shakespeare champion. Negative result first: phi still does not beat
    tuned standard AdamW -- and the pure momentum prior turns out to be a complete
    non-event.
    Only phi^2 + phi^-2 = 3 is [Verified]. Method survives, phi does
    not (yet).

    Code: branch feat/igla-coder-v1 @ 430f71b.

    The question

    Loop+8 (iso-lr) pinned the learning rate and the four momentum axes collapsed
    to a ~0.14 BPB band with phi worst by +0.09. But each arm still carried its
    OWN weight_decay, and the F2 mediation work had shown decay (CDE_decay ~+3.5)
    dominates momentum (CDE_momentum ~+0.9). So that residual phi gap could still
    have been a decay effect. Loop+9 removes the last confound: lr AND
    weight_decay are both pinned to constants (lr=0.002, wd=0.04) for every arm;
    only beta1 varies.

    Result (hidden=64, 800 steps, 3 seeds, lr=0.002 AND wd=0.04 pinned for all arms)

    axis beta1 mean code_val_bpb ci95 delta vs standard
    dyadic 0.5000 2.3556 +/-0.0668 -0.0299
    phi 0.6180 2.3581 +/-0.0683 -0.0274
    e 0.3679 2.3712 +/-0.0563 -0.0143
    standard 0.9000 2.3855 +/-0.0414 (null)

    Provenance sha256[:16] = bef01eab741f9162.

    Verdict [Efit]: phi-momentum NOT distinguishable from standard at
    iso-everything -- CIs overlap, delta -0.027 BPB within noise, whole-band spread
    0.030 BPB (about half a single arm's CI width). With both lr and decay
    controlled, the choice of Adam beta1 in [0.37, 0.90] has no detectable effect
    on code BPB at sub-1M params; phi^-1 is one neutral point among several.

    The confound ladder (the actual finding)

    • Loop+7: 4 axes ranked strictly by prescribed lr; phi "worse" by +0.566 BPB
      -> a learning-rate sweep in disguise.
    • Loop+8 (iso-lr): band 0.14 BPB, phi worst +0.092 -> residual gap suspected
      decay.
    • Loop+9 (iso-everything): band 0.030 BPB, phi-standard CIs overlap ->
      residual gap WAS the decay confound. The pure momentum prior is neutral.

    The only operationally relevant phi liability the coder track ever measured is
    the heavy phi^-3 weight decay (0.236, ~6x standard) -- confirmed here as the
    source of the Loop+8 gap. The momentum and (Loop+8) lr-controlled effects are
    non-events.

    Verification

    • cargo build --release --bin igla_coder clean; gradcheck checks=23 fails=0 PASS; all 12 runs gen_rc=0 valid BPB, no divergence.
    • New committed: ablate_generator_axis_isoall.py, coder_generator_axis_isoall.csv,
      LOOP9_REPORT.md, and build_t27_parallel_corpus.py (closes the prior
      workspace-only corpus reproducibility gap; corpus regenerated from t27 gen/,
      1,044,046 train tokens, vocab 263).

    Claim-status delta

    • [Efit] NEW: pure phi-momentum is indistinguishable from standard once lr+wd
      controlled. Neutral, not a benefit.
    • [Verified] (carried) phi^-3 weight_decay is the dominant harmful knob.
    • [Retr] "phi axis worst" (Loop+8 framing now attributed to decay, not momentum).

    Loop+10 options in coder_ablation/LOOP9_REPORT.md: (A) publish the confound
    ladder as the methodology's headline honesty figure [P8.3]; (B) C-only
    curriculum + --resume to first compile@1 > 0 [P4/P5 gate]; (C) symmetric
    beta2/grad_clip sweep to close the per-knob phi audit.

    Refs #181. Anchor: phi^2 + phi^-2 = 3.

  9. gHashTag commented on Jun 7, 2026

    @gHashTag
    CollaboratorAuthor

    Loop+10 update (A + B + C) -- commit 4bbd5a9 on feat/igla-coder-v1

    User picked all three Loop+9 options. Negative-first, as always.

    Headline: the per-knob phi-optimizer-prior audit is now CLOSED, and it is a null. Across every isolated AdamW knob the coder track can vary -- lr (P3/Loop+7/8), weight_decay (F2 mediation), beta1 (Loop+9), and now beta2 (Loop+10) -- phi structure is either neutral or harmful, never a clean benefit. Only phi^2 + phi^-2 = 3 is [Verified]. The method survives, phi does not (yet).

    (C) beta2 isolation -- no phi benefit. With lr (0.002), wd (0.04), AND beta1 (0.9) all pinned to standard, varying only the new --beta2 flag: phi-native 0.966 (~1-phi^-7) tested -0.164 BPB vs the 0.999 null -- but a non-phi control sweep (0.98/0.95/0.92) beats the null by an identical margin (-0.146 to -0.166). It is a generic "0.999 is too high for a tiny noisy run" effect, not phi. Aggressive phi-native beta2 (0.618, 0.382) is catastrophically worse (+2.3, +32 BPB). The control sweep is exactly the trap the critical-honesty discipline exists to catch. grad_clip reported INERT (printed in the prior but never applied in opt_step) -- not swept, not fabricated as a mediator.

    (A) confound ladder (figure + P8.3 write-up). Published the Loop+7->8->9 sequence as a single figure: the phi-standard delta collapses +0.566 -> +0.092 -> -0.027 BPB as the lr then the decay confound are each controlled. The phi advantage was a confound at every rung; honest endpoint is neutrality. Drop-in P8.3 subsection included in the report.

    (B) first resumable C-only curriculum at hidden=128. New --resume flag warm-starts weights across short CPU sessions (honest: weights only, fresh optimizer state -- no bit-exact-optimizer claim). Lifted the 296K hidden=64 ceiling to 493K params, 12200 steps in 4x3000 resumable chunks. val BPB descended monotonically to a record-low 1.038 -- but compile@1 = 0/4 and pass@1 = 0/4. Doubled capacity bought a better likelihood model, not valid C. The capacity ceiling for compiling C sits above 493K params at this corpus/budget.

    Verification: cargo build OK; gradcheck checks=23 fails=0 PASS (unchanged by new flags); 30/30 beta2 sweep runs returned valid BPB, no NaN. New files ASCII-clean.

    Full report: coder_ablation/LOOP10_REPORT.md. Phase comments on #1036 (C+A) and #1038 (B).

    Three options for Loop+11

    • A -- wire grad_clip into opt_step (it is currently inert dead metadata), re-run gradcheck, then run the symmetric isolation sweep on the LAST AdamW knob. Medium cost.
    • B -- scale the capacity probe: hidden=192/256, layers=3 with the resume machinery, to locate the first non-zero compile@1 budget or document the CPU ceiling as a real negative bound. High compute.
    • C -- external replication packet: bundle the confound ladder + the beta2 control logic into a one-page methods note. Low cost, doc only.

    STOP. Pick A / B / C.

    Anchor: phi^2 + phi^-2 = 3.

  10. gHashTag commented on Jun 17, 2026

    @gHashTag
    CollaboratorAuthor

    Wave Loop 92 audit: closing long-running EPIC with no close criteria — work tracked in newer milestones.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions