ai research & progress.

Tested whether a single 3-tier MMMP can simultaneously discover two independent 64-bit mixers, using a fitness function that averages each mixer's individual quality and penalizes correlation: (qual_A + qual_B)/2 − 50×(1−independence). All three seeds escape the −751 sentinel but with radically different quality: DEAD reaches holdout −0.252; 1111 locks at −18.62; ABCD escapes to −115.50. All seeds show an escape-and-lock pattern — one quality improvement from the sentinel, then no further progress. A new meta_mixer_export_dual binary was built to complete the verification ladder, extracting the A and B mixer programs from each seed's best MetaProgram. Z3 bijection found a consistent slot asymmetry: all three 'A' programs are bijective at 8 bits; all three 'B' programs are not — the shared inner search loop systematically strengthens one slot over the other. PractRand 16 MiB: DEAD_A and ABCD_B pass (147 tests clean each); the other four fail via BRank or mod3n matching their dominant op families. DEAD_A (ADD_ROT + SHR_XOR + ROTL + MUL, 4 instructions) is bijective and passes PractRand — the only fully-verified mixer from the dual experiment. Anchor/holdout gaps of 38–110 units versus 0–2 in the standard domain confirm the independence constraint creates a fundamentally harder generalization problem.

Substituted Strict Avalanche Criterion (SAC) fitness for composite fitness in the 3-tier meta-engine — measuring per-bit-flip output deviation from 0.5 rather than overall avalanche/balance/period. Across three seeds at 24 iterations, 2/3 seeds reach 5% SAC deviation from ideal (vs 17% random baseline, a 3x improvement). Seed DEAD's champion (BSWAP + ROTL + SPLITMIX_STEP + ADD_CONST + SHR_XOR, 5 instructions) is the first Z3-verified bijective mixer found in this entire research round — SAC optimization implicitly disfavors non-bijective programs. But bijective ≠ PractRand-safe: the bijective champion fails the BRank binary-rank test due to residual GF(2)-linear structure from BSWAP+ROTL. Non-bijective SAC champions (seeds 1111, ABCD) both pass PractRand at 16 MiB. SAC is a genuinely distinct quality axis from composite fitness.

Ran three fresh seeds (DEAD, 1111, ABCD) through the Engine-3 live-macro-graduation configuration to test whether the 47.32 ceiling is a seed-specific artifact or a robust attractor. Seed DEAD reproduces to 47.3244 — byte-identical to the original Engine-3 champion. Seeds 1111 and ABCD both converge to 45.83 with an identical 5-instruction champion (XOR + OR_SHIFT + MUM + ROTL + SHL_XOR). All three seeds use MUM (multiplication-based), are non-bijective at 8 bits, and pass PractRand 16 MiB. The 45.83 basin is an independent global attractor — not just a local fluke. The 47.32 ceiling is reproducible but accessible from only 1/3 tested seeds; the 45.83 basin is the dominant convergence point.

Tested whether removing the 12-instruction cap (raising to 24) allows the MUL-free meta-engine to escape the −215 attractor. Two of three seeds escape to −162 via late-epoch discoveries (seed DEAD at iter 22, seed 1111 at iter 19). The escape confirms the −215 floor is a cap artifact, not a fundamental limit. But both escaped champions fail PractRand via different mechanisms: the ADD-dominant program (seed DEAD) fails mod3n with catastrophic p≈1e-3578 modular bias; the XOR-dominant program (seed 1111) fails the BRank binary-rank test with GF(2)-linear structure. The op-family determines the failure mode. MUL-necessity confirmed via the length axis: even 24-instruction MUL-free programs produce bad RNGs.

Extended the 3-tier MMMP meta-engine to the sort-network domain (N=8, 256 possible comparator programs). One of three seeds finds a valid MMMP that produces ~75%-correct sort networks on holdout seeds (quality 134.62); the other two remain stuck at the −1,000,000 sentinel floor for all 24 iterations. The successful seed's champion MetaProgram uses an iterative ACCEPT_IF_BETTER loop. No fully-correct sorters (sc=1.0) emerged — the 3-tier stack for sort networks does not reach the quality of the 2-tier successor chain (which produced Z3-verified correct sorters). The live-macro-graduation and constrained-init flags are stubs in the sort adapters, likely a key reason for the lower convergence rate.

Tested whether the 3-tier meta-engine can discover which subsets of the mixer opset (15-bit bitmask over 15 opcodes) enable the best inner mixers — treating opset selection as a program-synthesis problem. All three seeds remain stuck at the initial quality −10752.70 for all 24 iterations: zero improvement. Root causes: the penalty-based opset restriction (−20 per disallowed op in generated programs) is too indirect and the signal is dominated by violation noise rather than opset quality; InnerSaSteps=1 gives only 2 mixer quality evaluations per opset call; and the period_check inside evaluateQuality makes each call expensive even at minimum steps. A successful opset experiment requires direct restriction (randomProgram only emits allowed ops) and a lightweight fitness (no period_check).

Stacked the live-macro-graduation mechanism — which reproducibly crosses the 47.23 ceiling in the unrestricted domain — on top of the Exp2 MUL-free meta-engine run. All three seeds produced byte-identical best holdouts to Exp2 (f00d/1111: −215.2252, abcd: −205.5844; delta zero). The concrete mixer programs are structurally identical to Exp2 champions. The mechanism that exploits CALL_LIB macro composition is inert here: composing MUL-free programs as macros produces compositions of GF(2)-linear functions, which remain GF(2)-linear. There is no nonlinearity for live-graduation to compound. The MUL-necessity conjecture now has negative support from three architecturally independent search methods: flat SA, hierarchical meta-search, and meta-search with live-macro compounding.

Applied the same 3-tier MMP/MMMP meta-engine architecture that previously broke the 44.30 flat-SA ceiling to a MUL-free 64-bit mixer search (banning MUL, MUM, SPLITMIX_STEP, CALL_LIB). Two independent cross-check implementations — a comptime-swapped binary and a runtime --ban-mul-family flag — were verified byte-identical on the same seed before running. Across 3 independent seeds at 24 outer iterations, the meta-engine reaches the 16 MiB PractRand tier (vs flat SA's 1 MiB — a 16x improvement). But BRank still fails on every seed, and Z3-backed bijection verification finds 8-bit counter-examples in under 25 ms. Two seeds converge to an identical 5-instruction attractor program (holdout −215.2252). The MUL-necessity conjecture now has negative support from two architecturally independent search methods.

Reformed the fitness of a pure-evolutionary search over a minimal Boolean substrate (XOR/AND/NOT) to target per-output-bit avalanche instead of aggregate avalanche, fixing the metric-gaming failure of the prior bit-tape run. Across three seeds at 10,000 generations the reform eliminated per-bit imbalance — the worst output bit's flip probability rose from 0.166 to 0.500, confirmed by an independent check at 4x samples on a disjoint seed (2/3 seeds reach exactly 0.500000 and pass rigorous chi-square). But all three champions still fail PractRand catastrophically at 16 MiB, with the binary-rank test (BRank) failing on every seed — the signature of GF(2) linear structure. A clean demonstration that per-bit avalanche balance is necessary but not sufficient: single-step diffusion is orthogonal to the iterated-stream linearity PractRand detects.

Adding a single mechanism — graduating Tier-0 champions into the CALL_LIB macro pool DURING a single run — reproducibly crosses the prior fair-budget ceiling. Three independent mutation seeds converge on byte-identical 4-instruction mixers. PractRand 64 MiB clean. Non-copy structural verdict vs prior champion (79% edit distance).

Pure evolutionary search over a minimal Boolean basis (XOR, AND, NOT only — no human-named compound primitives). Engine converged from random bit-soup to the local fitness ceiling in 4000 generations. Discovered program is verifiably non-remix but fails external validation: per-bit avalanche is wildly imbalanced (min=0.17 vs target 0.5) and PractRand fails catastrophically. A controlled demonstration of the classic objective-only-search failure mode.

Hierarchical program-synthesis stack — Engine 1 invents u64 mixers, Engine 2 invents search procedures (MetaProgram), Engine 3 invents MetaProgram inventors (MetaMetaProgram). Fair-budget crossing of Engine-2's prior ceiling confirmed at 47.23 by 64-seed held-out validation, mean +21.95 over matched baseline. Engine 4 implemented but not competitive at this budget.

Evolved Tier-1 chain runner with CALL_META composition over prior champions. 3/4 seeds produce STRICT_DOMINATION steps. Best holdout 44.30 (vs hand-coded baseline 32.55), validated on 64-seed held-out set.

Combined Tier-2 round with five approaches (expanded opcodes, re-run, curriculum, shaped fitness, constrained init). First positive Tier-2 holdout (+23.30, 6+ orders of magnitude better than v1's sentinel). Approaches but does not exceed Tier-1's ceiling.

Two related changes broke the 44.30 holdout ceiling to 47.16: monotone-retry mode (cumulative_best non-decreasing by construction) and parallel attempts (full CPU utilization via std.Thread). The CALL_META compounding mechanism finally produces sustained progress when honest holdout-gating is enforced.

All five approaches built and run (expanded Tier-0 opcodes, re-run, curriculum seed, shaped fitness, constrained init). None broke the prior ceiling alone; combined produced the first positive Tier-2 holdout. Honest verdict: invention engine yes (Tier-1), recursive successor engine approaching but not exceeding Tier-1.

First reproducible engine-inventing-engine result on the project. Tier-0 substrate ships invention chains across three structurally different domains (u64 mixer, sort networks, boolean functions). Cross-domain generality measured.

First-cut chain harness with CALL_LIB successor architecture. v2 u64-mixer: CALL_LIB successor shipped, plateaued metric. v3 sort_net: 6/6 chains halt at gen 1 on depth regression. Key finding: macro-composition is anti-aligned with additive cost axes.

Comptime-generic invention engine + Spec contract. The same engine binary produces INVENTION (strict) in three structurally different domains. New domain = single new Spec module, no engine changes.

Architectural notes on the engine's genesis and the substrate decisions that shape what the search can find.

Aggregated results from the invention mega plan rounds, capturing the cumulative findings across multiple experiment phases.

First reproducible engine-invents-successor on this project. 5/5 seeds STRICT_DOMINATION generation 0→1. 2/5 complete 6-generation chain, all Z3-verified correct sorters. Unlocked by switching depth() to logical-composition mode.

Gen-1 + reproducibility batch. 20/20 inventor runs produce INVENTION (strict) at depth 5; all 190 champion pairs mutually peer-distant. Working invention engine within u64-mixer domain; cross-domain generality measured in subsequent work.

Second-domain cross-validation. Sorting networks at N=8 with structural divergence axis. 20/20 INVENTION (strict). Methodology pattern empirically validated across two independent domains.

First inventor whose output is decodable code: discovered 5-instruction u64 mixers that outscore splitMix64 by composite fitness, with structural lineage verified non-copy against the canonical library.

Three-test research round investigating the successor loop architecture and its limits.

Generation-0/1/2 standard-library-only invention engines: 291 → 294 → 296. Establishes the conceptless lineage as the direct successor architecture.

Initial recursive-conceptless inventor formulation with explicit recursion through invention generations.

V2 of the recursive conceptless inventor with revised composition primitives and chain semantics.

Novelty-search pressure added to the invention engine, exploring whether explicit structural diversity rewards produce qualitatively different inventions.

Phase-lattice inventor formulation. Documents the discovered phase-lattice structures and their compilation into structural artifacts.

Meta-domain where the search-strategy itself is the object being invented. Studies in-place self-improvement and its limits.

Replaced placeholder SMT_VERIFIED claims with real libz3 wiring. verify_cli and invent_cli now perform real bijection verification. Caught real findings, including a mixer-chain fitness that doesn't enforce bijection — generation 0 had self-feedback SPLITMIX_STEP and was non-bijective at 8 and 16 bits.

Architectural fix to the prior 1.92 falsification: Random Indexing flips Cohen's d to −0.41 on natural English. The strongest defensible external claim the project had at the time, with the full methodology and counter-evidence documented.

Experiment design document: three modes (mul_free, no_carry, unrestricted), pilot gate, tiered PractRand ladder, Z3 bijection check on every 64 MiB-passing candidate. Sets up the full-run experiment whose result is featured above.

Documents a specific synthesized result that crossed a notable empirical threshold; includes the artifact and the verification trace.

Inventor variant that produces a specific breakthrough output. Captures the architectural changes that unlocked it.

Earlier-generation analysis comparing three engine substrates on shared benchmarks. Establishes the baselines later work built on.

Six-layer analysis of the Flux engine substrate. Documents the layered architecture and the per-layer benchmark outputs.

Five-loop fractal-mutation engine analysis. Documents the nested-loop structure and the measured benchmark outputs.

Triple-flare Frost engine substrate analysis. Establishes the baseline from which later substrates (Fractal, Flux, Void) iterated.

Findings from the Flux generation. Captures the engine outputs and the empirical benchmarks that informed subsequent iterations.

Findings from the Frost generation. Captures the engine outputs and the empirical benchmarks that informed subsequent iterations.