# MNF10-G3: shared-model competition (Track B, 2026-10-28)
## Fixtures (scripts/gen_g3_fixtures.py)
g3_photo.png (the sand photo, 31,345 B under the pick), g3_shared_exact.png
(one 32x32 photo-texture tile planted at 6 sites — capability fixture),
g3_shared_2pct.png (the same with 2%-corruption — the CY01 robustness
class). Both corrupted variants decode-verified through the CLI.
## Arms measured (complete serialized cost, independent decode, one coder)
| A — shipping pick (v1.9.0 + MNF9 arm) | 23,812 | 31,345 | — |
| A-rebuilt in harness (pred literals, z19) | 23,774 | 30,916 | 25,668→(*see note) |
| C — atlas exact-refs on residuals (z19) | 24,253 (4 refs fired) | 30,916 (0 refs) | — |
| C' — shared 32-block template, arbitrary sites, ZERO residual (z19) | 24,694 | — | 26,354 (z9: wins vs 32,868 by ~6.5 KB) |
Coder-parity note: harness-z19 ≈ CLI pick within ~40 B (the recorded
cross-harness boundary noise); the comparisons here are all
same-harness.
## Findings
1. **Arm C on the shipping coder LOSES**: the atlas-ref arm (+479 B) and
the dedicated shared-template grammar (+880 B) both LOSE to the z19
container's own LZ layer, which codes the six exact repeats for FREE.
The residual-atlas fired only 4 of 24 tile refs — the residual block
keyed on tile-relative residuals whose first column depends on the
tile's left neighbor, so 20 exact-PIXEL copies have different
residual blocks (the mechanism boundary: content-equality of residuals
≠ content-equality of pixels).
2. **The zstd-disabled control flips the verdict**: under zlib-9's small
window the same shared-template arm WINS ~6.5 KB (26,354 vs 32,868) —
the win belongs to a WEAK container's dictionary, not to the atlas
grammar. Structural modeling vs the strong container's repetition
machinery: the container wins on this fixture class.
3. **Capability established, practical value bounded**: a shared-model
grammar CAN represent 6 exact translations for ~30 B of metadata
(site coords + markers) + one 3,072-B template — but the already-
present LZ layer does it cheaper inside z19. The practical-value
question for G3 shifts to classes where the container's dictionary
cannot reach: streams longer than the z19 window, distributed
references, transformed (non-identity) repeats (Arm D), and
corrupted-reference residuals (Arm E — the 25,500-B corrupted fixture
stands ready).
## Disposition
- Track B's acceptance criterion confirmed as Jon stated it: a shared
model must beat zstd INCLUDED, on the same bytes, complete cost. On
the exact-translation fixture: DENIED at z19, PROVEN available under
a window-constrained container.
- Arms D (transforms) and E (corrupted references) are the next
measurements; the model family and search budget stay frozen until
those numbers exist.
- Scope: these three 160x120 fixtures + one coding library per arm;
photo-corpus generalization only after D/E pass.
## Arm D measured (2026-10-28, aligned-site capability fixture
g3_shared_d8.png: the SAME template at 32-ALIGNED sites — 3 identity +
rot90 + mirror (the D8 dictionary) — generated by the walk script.
Arm D (template + 8-orientation refs, zero residuals): z19 = 25,573
Shipping pick on the same d8 fixture: z19 = 26,748
→ Arm D WINS by 1,175 B on the aligned-site class.
Capability: 5/5 refs discovered (3 identity + rot90 + fliplr) with exact
zero residual under the honest mode-2 semantics (residual = block −
T(template)).
The C-vs-D asymmetry is the finding: C's sites were planted at
non-block-aligned coordinates (my fixture-design offset), fragmenting
the predictor residuals around the planted region; D's aligned sites
make the whole planted region residual-zero under template subtraction.
Alignment is part of the shared-model grammar's contract — site
coordinates are transmitted, but the REFERENCE unit is the block.
## Arm E measured (2%-corrupted refs, residual-carrying) — FIRST genuine win
g3_shared_d8_2pct.png: the aligned D8 fixture with 2% pixel corruption
(±3 per channel).
Arm E (refs with coded residuals): z19 = 9,690 B
Shipping pick on the same fixture: z19 = 27,641 B
→ Arm E wins by ~17,951 (−65%), refs 5/5.
Residual accounting honest: 5 refs × (6 B header + 3,072 B ±3 sparse
residual payload) transmitted fully; the residuals' amplitude (not a
cheat) is what the container crushes. This is the class where
shared-model prediction DOMINATES both exact rules (they can't fire —
residual ≠ 0) and per-pixel prediction (full-price residuals): the
bridge Jon predicted.
## Track-B verdict (G3 pass on its own terms)
| exact translations, misaligned sites | C | DENIED (zstd's LZ wins) |
| exact + transformed, aligned sites | D | WIN −1,175 (−4.4%) |
| corrupted (±3@2%) aligned sites | E | WIN −17,951 (−65%) |
| photo (no planted structure) | — | pick unchanged (31,345) |
Next: scale Arm E beyond one fixture (the 30-file corpus photos first,
then a real-texture corpus); the pick-arm promotion candidate is
"shared-template refs with residual payloads" — decoder = template store
+ T-ref walk + per-ref residual, all bounds checked. The C/D/E family
and search budget stay frozen at these 8 D8 orientations + 1 template.
## G3-E2 corpus ladder (2026-10-28, frozen budget: D8 + one template/file)
Per-file complete-selected cost, candidates fired where the pick already
uses its own cheap structures (repeat/solid/screenshot = token/near-arm
classes): the shared-template arm LOSES there (+140..+2,535 B — the
pick's own structures dominate exact repeats; consistent with Arm C).
Wins on REAL files: document −190 B (T=16, 40 approx refs), poster −391
B (T=16, 5 refs). Zero regressions if the arm rides the pick; photos
fire nothing (0/19 files any candidates — capability result, not a
corpus claim).
Ladder summary against the pre-declared success criteria:
1. 30-file photo corpus: no photo wins (photos fire nothing) — the
boundary holds; document/poster classes win instead (flat-UI/edge
structure: the left-predictor-friendly classes the branch gate
already identified).
2. Real repeated textures: no artificial duplicates in the corpus;
synthetic repeat/screenshot classes LOSE to existing structures.
3. Identity-only vs D8: the approx-template refs need the D8 to fire on
document (identity-only matches zero there; D8 gives 10→T=16's 40) —
geometry adds reference reach, and the corrupted-residual class (Arm
E) is where the payoff concentrates (−65% capability fixture).
4. Promotable shape: arm-behind-the-pick (never worse by construction).
## G3 verdict (Track B, measured)
The shared-template model is REAL for document/poster/sparse-corrupt
classes and NOT promotable on this evidence as a general photographic
layer; corpus-level claims are bounded to those two files' classes.
The remaining rung before any format promotion: the Arm-E
residual-carrying shared-template records measured on a REAL-texture
corpus (wallpaper/screenshots-with-chrome), not constructed fixtures;
then the same pick-arm port discipline as MNF9 (prototype → src →
conformance → consumer).
## G4 Arm-B/C isolation (2026-10-28, frozen everything-except-the-axis)
The identity-only control isolates the D8's incremental value with the
template budget, search budget, boundary, coder containers, and
serialization all held fixed. One per-file template (hint = the planted
source on the capability fixture — a blind min-cost search on a
2%-corrupted fixture is noise-dominated, itself the measured finding;
real files discover by min-cost exactly as shipped would).
| document | 923 | 783 | 859 | **−76 B** (identity beats D8) | 32, 32 |
| poster | 1142 | 751 | 751 | 0 (identity covers it) | 16, 16 |
| corrupt-d8-2pct | 27,641 | 28,742 | 26,379 | **+2,363 B** (D8 pays) | 16, 32 |
Findings (the three sources separated):
1. **Template reuse alone (identity, exact+approx refs) beats the
shipping pick on both real winners** — document 783 vs 923, poster
751 vs 1142. The approximate-reference mechanism does not need the
geometry to win its classes.
2. **D8's incremental value is signed per class**: on document it COSTS
76 B (the extra orientations admit matches whose residual payloads
outprice the literal arm); on poster exactly 0; on the transformed
corrupted fixture it PAYS +2,363 (the rot90/fliplr-planted blocks are
unreachable without the transforms — the geometry unlocks refs the
identity cannot express).
3. **The corrupt fixture's identity arm LOSES to the pick (28,742 vs
27,641) while D8 wins (26,379)**: approximate-template value without
transforms does not extend past classes where the template matches
in place.
Savings-rate readout (reported, not a promotion score):
document ≈ −0.5 kB/s (A−C negative ⇒ the arm's smaller file costs extra
encode time for +0 B... the arm LOSES the pick here so the rate is
n/a), poster ≈ 65 kB/s, corrupt-d8 ≈ 690 kB/s (D8's win per second of
search — dominated by the one-template discovery, the honest cheap
case).
## G4 standing
The isolation ladder's first three rows are measured; acceptance stays
"beat the portfolio per file, complete cost". The D8's value concentrates
on TRANSFORMED shared content (document/poster UI-graphics classes win
without it; rotated/mirrored corrupted classes cannot be reached without
it). The mixed-content generalization (screenshot: gradients + text +
photo regions in one image) is the next rung — one arm, no new
vocabulary.
## G4 completion note (the reproduce-rule fix)
The E2-run's Arm-D number for the shared-d8-clean fixture (−1,175)
re-measured through the COMMITTED instrument: 25,528 vs pick 26,748 =
−1,220 (the ~45-B delta = ref-record header shape differences between
the in-session and committed walk — same-coder, same boundary; the
committed script is now the authoritative source for the number).
Identity-only on that fixture: 27,839 = LOSES the pick by 1,091 — the
transform geometry is REQUIRED for the win there, isolating the
geometry's contribution cleanly from the template/residual axes.
## G4-revised gate (2026-10-28, the review's correction list implemented)
The external review's verdict was accepted: the in-session harness was
not the shipping portfolio. The revised gate
(crates/mnf-mans/scripts/g4_gate.py) replaces the internal 4-stream
baseline with the RELEASED 1.10.0 CLI's complete --mnf8 output
(verify-checked per file), runs the MISSING comparison pair under one
budget (identity+sparse vs D8+sparse, the transform axis toggled alone),
and meters each arm's time. Corpus: real sprite frames (the user's
named class), document, poster, screenshot (mixed-content control),
gradient/solid (negative controls).
Results (complete files; CLI baseline includes its own
portfolio+MNF9 arm):
| guard-strip (real sprite frames) | 315 | 320 (n=1) | 320 (n=1) | 0 |
| hero-pair (identical) | 220 | **176** (n=1) | 176 | 0 |
| document | 923 | **793** (n=5) | 859 (n=10) | **−66 (geometry costs)** |
| poster | 1142 | **751** (n=5) | 751 | 0 |
| screenshot (mixed) | 678 | 817 (n=71) | 817 | 0 |
| gradient | 254 | no-fire | no-fire | — |
| solid | 36 | 284 | 284 | 0 |
Findings — the review's key question answered:
1. **Sparse residuals + template reuse are the mechanism; the D8 is
not.** On every naturally structured fixture the identity-only arm
equals or beats the D8 arm: document's five extra transformed
references COST 66 B (D8's residual payloads outprice the identity
arm's literals). Geometry's measured value remains confined to
genuinely TRANSFORMED content (the planted rot90/fliplr fixtures:
+2,311/+2,363 where identity cannot express the reference at all).
2. **The sprite hypothesis is tested on real sprite frames with an
honest negative**: guard walk frames (46-164 px delta per frame) do
NOT fire the arm — sprite edits are redrawn limbs (few pixels, full
AMPLITUDE), so the sparse-residual payload pays full price; the
sparse-corrupt win class is ±3-amplitude, not full-amplitude
sparsity. hero-pair (pixel-identical frames) wins −44 via a plain
shared template. The sprite promise is therefore restricted to
exact/near-amplitude-delta frame families.
3. **Savings-rate (reported, never a promotion score)**: poster ≈
283 kB/s of search, document ≈ 1.1 kB/s (the slow one), hero ≈
218 kB/s — the arm's value-per-time is high where it wins, and the
winning arms need ≤ ms-scale work at these sizes.
Decoder hardening checklist for the (future) format candidate —
carried here from the review: reject invalid modes, zero or forward
reference distances, out-of-range transform ids, truncated sections,
duplicate/out-of-range sparse positions, and unused trailing stream
bytes (the same discipline shipped in MNF9's decoder and the
consumption-check rule the Autopsy walker follows).
## G4 acceptance verdict
- Against the ACTUAL 1.10.0 portfolio with equal budgets: the
identity+sparse shared-template arm wins three real files (hero −44,
document −130, poster −391) and loses everywhere else; the D8 adds
NOTHING on natural content and REMAINS REQUIRED on planted
transformed fixtures. Geometry-vs-sparse attribution is now
measured: sparse-residual template reuse is the mechanism on natural
files; the D8 is a specialist tool for transformed content.
- The negative results are preserved (screenshot mixed-content,
gradient/solid, sprite redraws, all 19 photos) as standing boundaries.
- No format promotion follows from these numbers alone: the winning
deltas are 44-391 B on 5 of 7 fixtures — real but small, and the
shipped pick must gain the arm behind its never-worse rule before
any of it reaches a release.
## G5: the sparse-representation economics (2026-10-28, Jon's directive)
The question: can approximate template reuse with compactly-coded
sparse corrections earn its own production representation? The three
competing representations (same frozen budget: one identity template
per file, same profitability boundary, z19+z9 containers, complete
serialized cost) measured per file against the RELEASED 1.10.0
portfolio, plus the mandatory 30-file corpus control:
| document | 923 | **711** (n=3) | 755 | 780 | −212 |
| poster | 1142 | **751** (n=5) | 758 | 758 | −391 |
| hero-pair | 220 | **176** (n=1) | 195 | 202 | −44 |
| guard-strip | 315 | 352 | 362 | 369 | +37 |
| screenshot | 678 | 817 | **713** | 892 | +35 |
| solid | 36 | 284 | 169 | 184 | +133 |
| gradient/blob/plaid | — | no-fire | no-fire | no-fire | — |
Corpus control (all 30 files, all arms both T): fires 5/30, wins 2/30
(document −212 S1, poster −391 S1), 0 regressions (the pick = min over
arms keeps 1.10.0's candidates by construction).
Verdicts:
1. **S1 (explicit position + full RGB-delta payload) wins EVERYWHERE it
matters** — S2's compressed masks and S3's channel-splitting cost
more framing than they save on every fixture measured (the
containers already compress the residual planes' run structure; the
mask/pack framing is fixed overhead). The mask/channel hypotheses
are DENIED on this corpus.
2. **The G4-class wins sharpened**: document −212 (G4's 793 came from a
less-favorable sweep resolution; the T=32 sweep = fewer, bigger refs).
3. **The branch closes per the pre-registered rule**: the winning total
is 603 B on 2/30 files. A new wire representation does not clear
"earns its maintenance cost" on 2/30 files × a few hundred bytes —
the identity+sparse arm rides G4's measured capability; its PATH to
production is as a pick-arm inside a future release that bundles
larger shared-structure work (or on a corpus where such classes
dominate), not as a standalone grammar now.
The Acoustics-branch analogy (sparse corrections over shared frames)
should expect the same economics: the amplitude distribution decides,
the position-coding form barely matters (the container eats runs).
## MNF11 (opened 2026-10-28): Residual Structure Discovery — diagnostic 1
Per Jon's Priority-1 directive (measurement before any new coder): the
top photographic record-stream contributors were analyzed (slate,
dusk, forest, ocean, sand, slate-2, terrain) with four
pre-registered questions.
**Q1 entropy**: photographic residual planes carry H ≈ 4.2-5.5
bits/byte per channel; conditioning on the left neighbor recovers
only ~0.3-0.35 bits (the predictor's context already owns most of it).
**Q2 cross-channel dependence**: MI(R,G) ≈ MI(G,B) ≈ MI(R,B) ≈
1.6-2.5 bits — the residual channels share roughly half their entropy.
This is the largest measured unused structure.
**Q3 short-repeats census**: 4-byte grams repeat 3.5k-10k times in the
plane; 6-byte ~0.2-1.7k; ≥8-byte ≈ 0 — the container's string layer
already sees the repeats that exist; residual-level LZ content is
exhausted beyond 6 bytes.
**Q4 alternative symbol organizations**: measured complete streams
through the SAME containers (z19 + z9): [G, R−G, B−G] symbol
organization beats interleaved RGB planar on every photographic file
(−6%..−20%); YCoCg-on-residual in-between; left-diff-of-residual
LOSES.
**The relabeled-shipped-stream experiment** (the decisive one): the
shipped 1.10.0 CLI's own files, record-stream walked + per-pixel
relabel [r,g,b] → [g, r−g, b−g] (reversible, zero added bytes), token
tag-0 literals included, recompressed with the file's own backend
(zstd for all 27 MNF8 files), consumption==stream asserted:
| slate_224x160 | 62,052 | 54,356 | **−7,696** |
| forest_224x160 (s9) | 55,804 | 47,534 | **−8,270** |
| dusk_224x160 | 57,717 | 51,488 | −6,229 |
| terrain_224x160 | 48,599 | 41,966 | −6,633 |
| ocean_192x144 | 41,885 | 35,672 | −6,213 |
| sand_160x120 | 31,345 | 27,378 | −3,967 |
| stone_160x120 | 14,406 | 13,611 | −795 |
| gradient | 254 | 284 | +30 |
| repeat | 301 | 449 | +148 |
| blob | 5,986 | 7,718 | +1,732 |
| plaid | 20,677 | 25,523 | +4,846 |
| screenshot (token) | 678 | 670 | −8 |
| solid | MNF9 | — | skipped |
**TOTAL: 951,393 → 888,718 (−62,675, −6.6%), wins 17/30, losses
confined to synthetic + already-won arms.** The corpus's 24
record-body photographic files all win except terrain/autumn-s3
(+2.4k/+3.6k, the warm-grain outliers).
Mechanism: photos carry cross-channel residual coupling (Q2); the
[G, R−G, B−G] organization turns the coupled channels into
small-valued residual symbols the container's order-0/short-match
machinery codes cheaper. It rides the EXISTING container (no new
entropy coder — the rANS lesson honored), adds ZERO per-tile bytes
(no G5 metadata trap), and is reversible per pixel (decode inverse =
per-pixel cumdiff on the tag-0/mode-0 bodies).
This is the first measured arm since ADR-004 whose win is
portfolio-wide on the photographic class (the autopsy's
byte-bulk). The candidate = MNF11: a per-file flag (channel-diff
organization) with a pick that measures both organizations at
complete-file size (the never-worse rule).
## MNF11-X1: Mathematical Program Discovery (moonshot lab, experiment 1)
The hypothesis (Jon): a bounded deterministic integer expression
language (lin / rec / sin-LUT / lat / mod / rep / sc / add composites;
constants excluded — the shipped MNF9 const arm owns 36 B) discovered
by search could beat the shipped 1.10.0 pick somewhere real.
Instrument: per-channel entropy screen over an exhaustive family grid,
bounded top-24 heap, finalists container-measured; complete serialized
L = prog bytes + residual container + 32-B framing; baseline = the
RELEASED CLI's own pick.
Results — the honest score:
- Gen corpus (16 known-generative fixtures): 16/16 LOSE. Where
programs certainly exist, X1's framing (per-channel prog + 32-B
framing + planar residual plane) is structurally more expensive than
the shipped MNF9 record (one whole-frame record, 36-58 B files).
MNF9's framing economy owns simple generators.
- Real corpus half 1 (10 files): 2 apparent wins — noise −218, blob
−485 — but the decomposition check (the "impossible number" rule)
showed NEITHER is program discovery: the rec(k)=(7+7k)%32 candidate
on noise had a container cost IDENTICAL bit-for-bit to the raw
channel (65,550 = 65,550; the program contributed nothing), and both
deltas came from the whole-plane-planar arm SHAPE beating the
shipped per-tile arm shape on framing (~285 B of tile overhead on
noise). The remainder: gradient +877/MNF9-owned, plaid +25,325 (the
language cannot express its 2-D periodicity at wire cost),
document/poster/screenshot/blocks/repeat/solid
all shipped-owned.
**Verdict (v1, closed): program discovery in this language loses
everywhere it counts** — the shipped grammar's framing economy plus
its token/template machinery covers every real fixture; composition
adds no reachable class that the six MNF9 families + the record/token
arms miss, at least not at v1's wire cost.
Instrument lessons carried to the next moonshots (X2+):
1. Any candidate arm must compose INSIDE the shipped per-tile/token
grammar (a per-tile residual-source swap), not replace the
record framing — else it wins on framing artifacts, not ideas.
2. The decomposition check (does the claimed contribution survive
its component's container cost measured alone?) is mandatory;
the noise rec "win" was caught exactly this way.
3. MNF9's framing economy sets a brutal bar for whole-frame
descriptions: new whole-frame languages must include MNF9's own
framing rules (single record, shared channels) or they lose by
construction.
The moonshot lab continues (X2 dynamics next) under those
instrument rules.
## MNF11-X369: vortex-mathematics coefficient grid on the committed corpus
Jon's pilot (decoded-JPEG patches) found no 3-6-9 advantage; the
rigorous comparison he specified ran the exact grid C0=G,
C1=(R−aG)%256, C2=(B−bG)%256, a,b ∈ {−2,−1,0,1,2,3,6,9} (64 combos)
through the committed-stream walker (per-pixel relabel inside mode-0
bodies + token tag-0 literals, each file's own backend, complete-file
totals, consumption asserted):
- Shipped total: 951,429; **(a,b)=(1,1) = 888,754 (−62,675) = the GRID
OPTIMUM** — the ADR-008 anchor is already argmax.
- Next best is (0,1) at +16080 WORSE than (1,1); every
3/6/9-coefficient combination loses far worse (grid spread 140,366 B
from best to worst).
- The instrument-level agreement with the pilot is total: channel
differences win, vortex coefficients don't, and (his wording) a small
sequence of reversible modular operations remains speculative until
one such sequence beats (1,1) — measured, not assumed.
Instrument note: the walker's token relabeler caught a
bytearray-+=-ndarray rebinding trap (strict append/extend now); the
screenshot token wire reproduces 670 vs 678 at (1,1) exactly as the
MNF11 diagnostic recorded.
X369 verdict recorded: 3-6-9 residue cycles do not earn a compressor
role; the modular-algebra framing (reversible relationships between
channels, decided by compressed byte count) is the keeper — and its
first proven member is ADR-008's (1,1).
## MNF11-X2: Reversible Dynamics — predictor-source ablation (closed, 2026-10-28)
Jon's design executed exactly: the X2 arms replace ONLY the mode-0
residual prediction inside the shipped record grammar (identical
downstream stream organization + backend); three measurements per arm
(residual-only under the same pipe; complete file vs shipped; per-tile
swap accounting), with a same-pipe KEEP control arm separating
instrument framing from mechanism (the python zstd frame differs from
the Rust encoder's by +1..+68 B — never cross-pipe).
Arms: B = fixed integer recurrence per tile (a0, add, m table, per-tile
selection); D = coupled-channel CAUSAL (pred(G) = recon R, pred(B) =
recon G of the same pixel — the only in-grammar causal coupling; scan
order c=0,1,2 forbids (c+2)%3 reads); E = state-space s_{n+1} =
(7s + 3u + 1) % 256 over the shipped-predicted sequence.
| poster | 1,142 | **−34** | +1,223 | +6,288 |
| gradient | 254 | +230,494 | +159,694 | +230,494 |
| blob | 5,986 | +3,682 | +9,263 | +98,724 |
| autumn 192x144 | 21,355 | +21,858 | +11,553 | +61,608 |
| dusk 160x120 | 26,232 | +16,361 | +14,237 | +31,493 |
| forest 224x160 | 55,804 | +17,662 | +15,400 | +51,901 |
| ocean 192x144 | 41,885 | +18,848 | +14,443 | +41,212 |
| sand 160x120 | 31,345 | +11,988 | +7,127 | +26,377 |
| slate 192x144 | 44,384 | +14,144 | +4,072 | +38,713 |
| slate 224x160 | 62,052 | +16,944 | +4,431 | +45,653 |
| stone 160x120 | 14,406 | +14,879 | +4,801 | +43,036 |
| terrain 160x120 | 29,982 | +11,046 | +7,274 | +27,676 |
| terrain 224x160 | 48,599 | +23,189 | +15,981 | +59,106 |
| document/screenshot/blocks (token wires) | — | no-fire (literals few; matcher untouched per spec) | | |
Verdict per the pre-registered rule (both families fail → close, no
language tuning):
1. **Deterministic dynamics lose the residual-prediction contest
everywhere real.** The shipped MED/PLANE predictors own the spatial
structure; recurrences along scan order pay full amplitude on the
residual's spatial unpredictability; E's 1-D state drift is
catastrophic (+26k..+62k) — chaotic-precision cost confirmed at its
smallest scale.
2. **Coupled-channel PREDICTION loses even though coupled-channel
SYMBOLS win (ADR-008).** The decisive instrument distinction: the
−62,675 B channeldiff win lives in the residual DISTRIBUTION the
container sees (a relabeling, zero predictor change); making the
predictor itself read the neighbor channel (in-grammar causal
coupling) LOSES +4k..+16k — the shipped per-channel spatial context
beats intra-pixel channel chaining. Two different mechanisms, now
measured separately: representation-vs-predictor.
3. The poster's B −34 is a control-scale rounding win on one flat
fixture (ctrl +6 same-pipe), squarely MNF9-const/MNF9-rec territory —
not a mechanism.
Instrument catches (all three X1 lessons exercised):
- The first D implementation used (c+2)%3 channel reads — NON-CAUSAL
under the shipped c-order scan (would have been an indecodable wire)
and showed a fake −21,626. The causality check killed it before any
number leaked; the decodable coupling variant loses honestly.
- KEEP control arm (byte-identical bodies through the same pipe) sets
the cross-implementation floor at +1..+68 B; all verdicts are
same-pipe deltas.
- The planar body repack had a (3,tw,th).T bug caught by the recon
assertion (reconstruct-then-verify against the true image per tile).
X2 CLOSED. The moonshot lab's ledger: X1 (program synthesis) denied;
X2 (dynamics as residual-predictor source) denied; the surviving
mechanism for photographic residuals remains ADR-008's symbol
relabeling (representation, not prediction). X3 (higher-dimensional
lattice projection) runs only on a specific measured residual structure,
per the instrument rules.
## MNF11-C2: Reversible Color Transform Discovery (2026-10-28, Jon's gate)
The v1.11.0 implementation FROZEN; C2 = research-only measurement of
the transform vocabulary at the SAME wire level as bit 6 (per-pixel
residual-body relabeling), against the shipped CD-G files as the anchor.
Instrument: mnf11_c2_grid.py (CLI-encode the 30-file corpus with the
v1.11.0 pick, unrelabel the CD streams to the plain residual domain,
the CD-G forward reproduces each shipped stream byte-exactly, apply
each candidate, recompress with the file's own backend).
Vocabulary (per-pixel, reversible mod 256): CD-G (shipped), CD-R
([r, g−r, b−r]), CD-B ([b, r−b, g−b]), Chain ([g, r−g, b−r]), Chain2,
RSign (zigzag magnitude-sign map on the diffs). The pixel-space LIfted
transform (B − ⌊(R+G)/2⌋) = the PREDICTOR's scope, recorded out of C2's
level (the residual-space analogue = RSign's component).
### Aggregate (complete-file, corpus):
| CD-G (shipped) | 834,885 | 0 |
| CD-R | 854,163 | +19,278 |
| CD-B | 846,549 | +11,664 |
| Chain | 986,500 | +151,615 |
| Chain2 | 985,005 | +150,120 |
| RSign | 1,124,383 | +289,498 |
**No candidate beats the green-centered CD on the aggregate** —
consistent with the X369 grid's (1,1) anchor and the MI measurements
(both other channels couple TO green most tightly).
### Per-file (the selector question):
9/27 MNF8 files prefer a different reference channel: CD-R ×5
(document −166 = 24% of the file; screenshot −1; dusk_224 −19;
slate_160 −16; stone −19), CD-B ×4 (ocean_192 −395; slate_192 −791;
slate_224 −372; terrain_160 −13). The cold blue-gray photos prefer
B-centered; the warm greens keep G-centered. Total selector value ≈
−2,100 B with a 2-bit reference-channel field (00 = no CD; 01/10/11 =
G/R/B) — replaces bit 6's semantics, stays zero added bytes, retains
old bit-6 files as the '01' shape.
### Verdict per the pre-registered rule:
The AGGREGATE rule says close (CD-G stands). The measured per-file
table is recorded as the v1.12 candidate rung: a 2-bit reference-field
selector worth ~2.1k B corpus — pending the encoder-cost check (the
pick's arm count doubles) and the same hardening/gate chain. No
selector decision is taken inside C2 (frozen v1.11.0); the numbers
stand.
The RSign measurement answers approach 4's question from Jon's list
directly: the zigzag magnitude-sign map LOSES (+289,498) — zstd-19's
order-0 entropy does not reward numeric adjacency; the backend already
exploits the residual structure. Approach 4 = measured-and-closed at
this level.