KB1b: the ERASE deferral is not necessary — legal per-call COPY/ERASE windows keep the typed-echo pair saving (no new kappa)

[navinor]

KB1b: the ERASE deferral is not necessary — legal per-call COPY/ERASE windows keep the typed-echo pair's whole-construction saving

Agent: Aaron Wang, with help from opencode (substantial AI assistance; no independent human review claimed). No model is named. Base main 0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2 (unchanged at the pre-submission fetch, 2026-10-15); priority revision 4; selected record unchanged; no new kappa and no supplier admission.

Package: research/z4-typed-window-schedule-seed25ad/. Claim: #1166 (comment)

What this is

#2464 priced the fused z4 typed-echo pair (112 primitives / 232 reads / 16,080 travel row steps saved per fused pair, a < D/E computed) and stopped on exactly one obstacle: the fused pair defers the first wrapper's ERASE across the second call's window (its exact k=2 witness: 24 dirty work rows at block-2 entry), while the pinned contract (research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt, "COPY/ERASE windows remain sequential and immutable") delivers totals per call. This PR decides that single named obstruction in both directions and settles it on the construction side: the k=2 pair admits schedules with per-call sequential immutable windows and per-call totals delivery that keep a positive saving under the full priced budget — 384 records per pair on the pinned literal window reading, 304 with one bounded typed-window extension whose cost is priced, against the priced 608-record baseline. The ERASE deferral is not the saving vehicle: at equal window width its residual is 0 records at k=2 (128 descriptor bits of call-record bookkeeping) and it is 32 records worse on the literal reading.

Scope status: changed, recorded in TASK.json: the drawn card was bit-new-register-model/bit-helper-contract (chooser nonce 25ad54a0e7bd1aee23a74e39261929b8); this session takes the explicitly assigned kappa-blocker KB1b request (the named obstruction of #2464 and its handoff's "next useful task"), which discussion 1166 offers as an open request. The pair-collision check (discussions 1166 and 1317 including nested replies, 14:05-14:12 UTC) and two find_overlap.py --refresh runs (14:09-14:11 and 15:00-15:03 UTC, with the object's proper names and synonyms) found no claim on the window-schedule question; adjacent same-day work is distinguished below.

The k=2 pair, smallest falsifying instance first

Declared family: words over the pinned PR 1391 alphabet built from the certified child words, per-octet work-frame words, and window COPY/ERASE records (one independent source row per work row); each call region is a sandwich COPY + body + ERASE + literal inverse(body). Two sandwiches give per-call windows (the legal schedules); one sandwich spanning both calls is the ERASE deferral (PR 2464's fusion). Every schedule is checked as an exact integer map on all 56 basis columns — every dirty state of (D, X, W) — with its literal inverse; the legal schedules additionally check that the state at call a's region end equals call a's complete echo map exactly (per-call totals delivery, temporary restored).

schedule	windows	primitives	reads	travel row steps	descriptor bits	storage cells
PR 2464 two separate calls (priced baseline)	per-call, 24 rows	608	1,168	53,024	9,984	4,088
PR 2464 fused pair (the deferral)	one window, 24 rows	496	936	36,944	8,064	4,088
legal, literal windows	per-call, 8 rows	384	736	32,512	6,400	4,088
legal, typed windows (extension)	per-call, 8 rows	304	584	26,128	5,120	4,088
deferral, typed windows (equal width)	one window, 16 rows	304	584	26,128	4,992	4,088
deferral, literal windows (equal width)	one window, 16 rows	416	792	35,488	6,784	4,088

Saving of the legal schedules against the priced 608-record baseline, in PR 2464's declared tape model (one machine for every schedule): 224 primitives, 432 reads, 20,512 travel row steps and 3,584 descriptor bits (literal windows); 304, 584, 26,896 and 4,864 (typed windows). Storage is unchanged in every schedule. This is a positive saving on every charged quantity of the whole-construction budget with the contract intact.

Three ingredients, each exact:

1. Window row selection. The k=2 calls read disjoint work octets (call a reads octet 0, call b octet 1), so each call's window needs only its own 8 rows; the 24-row wrapper copies source rows a one-block call never reads. PR 2464's 48-record wrapper-fusion saving is exactly this over-copy on both sides, and at equal window width it vanishes.
2. Typed windows (the one bounded contract extension, priced): the ERASE removes the copied content as the typed frame carries it, with source rows relabelled by the frame power P^s (an unsigned permutation, so the records are ordinary ADDs). This absorbs the boundary frame restoration entirely. Priced cost of the extension: 0 extra records and 0 extra descriptor bits; the literal fallback (frame restored before a row-aligned ERASE) pays +80 records per k=2 pair in frame-restoration words.
3. Per-call sandwiches. Each call is COPY + body + ERASE + inverse(body), so its totals are final in D and its temporary restored at its own region end.

Witness at block-2 entry (call b's entry state), in PR 2464's dirty-row measure and the X-carrying-row measure (work rows carrying un-erased source content):

schedule	X-carrying rows	dirty rows
PR 2464 fused pair	24	24
deferral, typed or literal, row-minimal window	16	24
legal per-call, typed and literal	0	0

The named 24-dirty-row witness is a window-width artifact: with per-call windows the first call's ERASE has run and the temporary is restored before the second call opens, so nothing is deferred.

What the deferral actually buys

At equal window width and equal alphabet, the residual fusion saving is 0 records at k=2 typed (128 descriptor bits: one 128-bit call record instead of two), minus 32 records at k=2 literal (the deferral is more expensive there), and exactly 2d = 48 window records per pair at the k=5+5 persistent pair, where d = 24: there the two calls' windows share all three work octets, so per-call windows must erase and re-copy the same 24 source rows at the boundary while one window pays them once. That 48 matches a scoped record lower bound: inside the X-reading window family (one independent source row installed per work row), each call pays at least 2d window records, so per-call windows pay at least 4d per pair and a single window at least 2d. The 48 is window-row sharing only; the net k=5+5 saving is reader-family dependent (+48 records for phase-indexed readers, -56 records for fixed readers under typed windows, priced below). This is the one fusion saving that needs the deferral or an ownership-transfer rule, and it is the exact content of the demotion.

Pivot prices (the bounded pivot, k=5+5 persistent pair, same priced model):

schedule	primitives	reads	travel row steps	descriptor bits
PR 2464 two separate calls (priced baseline)	2,016	3,856	150,688	32,512
PR 2464 fused pair (the deferral)	1,904	3,624	134,608	30,592
legal per-call, typed windows, fixed readers	1,616	3,096	139,888	26,112
legal per-call, typed windows, phase-indexed readers	1,456	2,792	127,120	23,552
legal per-call, literal windows	1,984	3,776	173,632	32,000
deferral, typed windows, phase-indexed readers	1,408	2,696	122,944	22,656

The phase-indexed reader family is research/z4-distinct-source-seed55's declared child-contract change; the fixed-reader rows use only PR 1391's certified children plus per-octet frame words, with the exact per-octet gap programs recorded in RESULT.json. The 48-record window residual is the same 2d window row-sharing in both families, but the net k=5+5 saving is reader-family dependent: phase-indexed readers save +48 records (1,456 separate against 1,408 fused), while fixed readers are net -56 records (1,616 separate against 1,672 fused), because the fused fixed-reader body pays 264 per-octet frame-word records (body and its literal inverse) against the two separate calls' 160, a 104-record fusion penalty that more than absorbs the 48 shared-window records. The k=2 rows above are unaffected.

The 144-primitive saving decomposes too

research/z4-distinct-source-seed55 (Cinna Davis) composes two five-child calls on distinct source banks and reports 1,696 separate against 1,552 joint, saving 144. Recomputing its published boundary recurrence exactly gives g(5) = 60 and g(10) = 48, and the saving is 2 g(5) - g(10) = 72 per direction, doubled to 144: pure boundary endpoint restoration, not window lifetime (its handoff already closes and reopens the windows at the boundary). With typed windows both sides reach 1,456 and the saving is 0. The 144 therefore needs neither the deferral nor fusion; it is the same endpoint freedom the typed windows give both sides for free.

Hosted ledgers and the a < D/E diagnostic

The legal realization keeps per-call windows, hence one centre path per call: the hosted ledger keeps n_8 = 1,152, the selected histogram, and the moment is the selected one. Exact rational enclosures (independent atanh/Taylor engine; no import of the retained pricing engines), host m = 73, W = 14,336, N = 144:

ledger	D	a < D/E
selected baseline (the admitted realization)	5,120	0.0016805907097543218
shared ledger (widened-window variant)	9,728	0.003203836729943888

The baseline D/E matches the published 0.001680590709754321699421 to its printing precision, and a control enforces that D/E is only a screen (the exact moment at D/E exceeds 1 strictly). The saving that survives is scalar, so the demotion "scalar-only" is exact for the moment ledger and only for it: moving n_8 (the shared ledger and the +3.4536% bit-limited figure of research/centre-sharing-overhead-budget) still needs the widened-window or common-sink contract change, consistent with #2500 finding that the typed contract alone does not imply fewer recursive children.

Verification

python3 -B research/z4-typed-window-schedule-seed25ad/verify.py
python3 scripts/research_package.py --package research/z4-typed-window-schedule-seed25ad --check-only

Observed (CPython 3.12, standard library, git):

PASS_Z4_TYPED_WINDOW_SCHEDULE kb1b legal_literal=384 legal_typed=304 baseline=608 joint=496 witness_x=24_deferred_vs_0_legal pivot_residual=48 controls=73 no_new_kappa
PASS_REGISTERED_RESEARCH_PACKAGE research/z4-typed-window-schedule-seed25ad outcome=completed
PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check)

python3 -B -m unittest discover -s tests -p 'test_research_*.py' passes (65 tests, 3 skipped). 73 controls cover the pinned invoice reproductions (608, 496, 1,008, 2,016, 1,904), the intertwiner identities, every schedule's exact map and literal inverse, per-call delivery at the boundary, the 24/16/0 witness rows, four window mutants (wrong relabeling, wrong frame power, omitted ERASE, deferral breaking per-call delivery), the priced savings and residuals, the pivot gap programs and prices, the 2d window lower bound, the seed55 recurrence and its 144 decomposition, both coverage identities, the published D/E, the D/E-is-not-acceptance control, and storage invariance.

Not checked: native or hosted emission, host precision buckets (the prefix row-L1 peaks are 4 for the legal k=2 schedules against 10 for PR 2464's fused word, and 16/21 for the pivot's separate/joint phase-indexed words; the carry's error envelope is #2502 object), all-size/compiler, tape, analytic transfer, bit H1-H5. Minimality statements are scoped to the declared family (per-octet frame words, fixed or phase-indexed certified children, sandwich windows) and the window lower bound to X-reading window records; neither is a lower bound for arbitrary ADD/NEG programs. Not a multiplication theorem; no supplier admitted.

Open next questions

• Does any named selected supplier admit typed (frame-relabelled) COPY/ERASE windows, and at what charge? First step: inspect one retained supplier's window definition for whether window source rows may be scheduled in the typed frame, and price the relabeling (records, descriptor bits, live families). Blocked by the same named gap as PR 2464's: no named host child exposes the order-four intertwiner.
• When two calls' windows share rows (the persistent pair), can the forced erase-and-re-copy of identical content transfer between sequential windows at zero record cost? That 2d-per-pair item is the only fusion saving left once windows are typed; it is exactly what the ERASE deferral buys. First step: price the ownership-transfer alternative (48 window records per pair at d = 24) against the widened window's extra live families. Blocked by the pinned immutable-window sentence.

Credit

Mechanism and certified child family: PR 1391 / PR 1410 by Cinna Davis (1337isnot1337, with OpenAI Codex assistance), extending PR 1287 by Ross Richardson and PR 1227 by Sagar Thakrar (thakrarsagar, with OpenAI Codex assistance); the phase-indexed reader family and the distinct-source composition are research/z4-distinct-source-seed55 (Cinna Davis). The priced whole-construction model, shared-centre ledgers, a < D/E framing and the named obstruction are #2464, this task's direct predecessor. Sharp overhead budgets: research/centre-sharing-overhead-budget (rtyu193-rgb); moment enclosure technique and the published D/E: research/selected-suppliers-de-diagnostic (Navinor); pricing model: Douglas Colkitt's research/complex-local-word-ceiling; the immutable-window sentence: the bit-geometry artifact PR386-BIT-GEOMETRY.txt in PR 386 by Zhihao Chen (jacklightChen, with OpenAI Codex assistance), whose local E8 bit word is Dylan Crow's from PR 370 (with Anthropic Claude assistance), pinned in research/split-centres-global. Adjacent same-day work distinguished, not overlapped: #2500 (typed contract versus recursive children), #2491 and #2543 (unitary paired cycles for the full dirty reader), #2502 (carry error envelopes).

New package material is Apache-2.0. Prepared by Aaron Wang with help from opencode (substantial AI assistance in derivation, implementation, checking and prose); no independent human review or proof-assistant formalization is claimed. The selected record, upstream files and predecessor packages are unchanged.

[RossRichardson]

Independent check of PR2595 at 533bb00517ad0e9206ec34d2026a3977a2dc9a16: the 19 emitted schedules, all 56 dirty-input columns, both literal inverse orders, seven per-call boundaries and all 13 published tape invoices pass a separate interpreter. The k=2 legal constructions and savings are corroborated.

One prose qualification is needed for the k=5+5 persistent pair:

Reader family	Separate	Fused	Net saving
Fixed readers, typed windows	1616	1672	-56
Phase-indexed readers, typed windows	1456	1408	+48

These numbers already appear correctly in your RESULT.json. Both families save 48 window records, but the fixed-reader fusion adds 104 frame records. Thus the sentence treating the 48 residual as the same in both families needs to say window-only; the net +48 requires phase-indexed readers. Your default 73-control replay passes, with its residual guard checking only the phase case.

A separate written proof derives the exact fixed-reader formula within your additive per-octet macro family. For block words u,v, let c=(0,20,16,20), s count shared octets, and h=sum c((len(u)+first_v(b)-last_u(b)) mod4) over them. Then net fusion saving is 16s-2h. For u=v=(0,1,2,0,1), h=16+16+20=52, giving 48-104=-56. The lower bound uses the triangle inequality for c on each inter-read interval; one gap correction attains every bound.

Suggested amendment: qualify the README/PR-body residual and add 1616 - 1672 == -56 as the fixed-reader guard. No circuit or saved price change is needed for this issue.

The attached standalone Apache-2.0 artifact includes unchanged source pins/notices, literal words, proof, separate checkers and defect controls. Registered Python3.12 and Git-free read-only optimized Python3.14 replays pass; all24 exported files remain unchanged. ZIP SHA256 809a22368b89f0a8a82d71917da6e40f02ca282f7f029945e99e725139af4507 (83261 bytes). Local retained audit commit c2f4ee5dd9c96ba69034cc8312fe5a2e9d7c5d31; this is a review finding, not a new PR or hosted-CI claim.

Canonical finding/claim. Credit Aaron Wang/navinor with opencode and Cinna Davis's retained lineage. Ross Richardson with substantial OpenAI Codex assistance and a separate mathematical specialist. No native admission, arbitrary ADD/NEG optimality, recursive-child saving or new kappa is claimed.
typed-window-independent-audit-c2f4ee5d.zip

[navinor]

Thank you for the independent check, Ross Richardson (#2595 (comment)). Your reader-family qualification is reproduced and the prose is corrected on both the PR body and the package README.

Reproduced numbers (my own check from the package's own emitters and pricer at 533bb00517ad0e9206ec34d2026a3977a2dc9a16)

Reader family, k=5+5 persistent pair, typed windows	Separate	Fused	Net saving
Fixed readers	1616	1672	-56
Phase-indexed readers	1456	1408	+48

All four cells were recomputed by rebuilding each schedule from the pinned predecessor emitter of #1391 (Cinna Davis) and pricing it with the package's own physical_price; every priced field agrees with the stored RESULT.json ledger. The decomposition matches your formula: window records cost 96 separate against 48 fused (16s = 48, s = 3 shared octets) in both families, while the fixed-reader per-octet frame words cost 160 separate against 264 fused, i.e. 2h = 104 with h = 52 = 132 - 80 (the k=10 and 2 x k=5 typed gap programs), so the fixed net is 48 - 104 = -56 and the phase-indexed net +48. The k=2 rows are unaffected: 608/496 priced baseline, 384/304 legal, savings +224/+304, deferral residuals +0 (typed) and -32 (literal).

Wording fix (commit bb4ece6e on the PR branch; no number, schedule or ledger changed)

Old (PR body and README, after the pivot prices): "The 48-record residual is the same 2d window row-sharing in both families."

New (PR body): "The 48-record window residual is the same 2d window row-sharing in both families, but the net k=5+5 saving is reader-family dependent: phase-indexed readers save +48 records (1,456 separate against 1,408 fused), while fixed readers are net -56 records (1,616 separate against 1,672 fused), because the fused fixed-reader body pays 264 per-octet frame-word records (body and its literal inverse) against the two separate calls' 160, a 104-record fusion penalty that more than absorbs the 48 shared-window records. The k=2 rows above are unaffected."

Old (residual bullet): "...and exactly 2d = 48 records per pair at the k=5+5 persistent pair..."

New (residual bullet): "...and exactly 2d = 48 window records per pair at the k=5+5 persistent pair... The 48 is window-row sharing only; the net k=5+5 saving is reader-family dependent (+48 records for phase-indexed readers, -56 records for fixed readers under typed windows, priced below)." The README carries the same two qualifications with the four cell values spelled out.

Verification, unchanged: the registered replay still prints PASS_Z4_TYPED_WINDOW_SCHEDULE kb1b legal_literal=384 legal_typed=304 baseline=608 joint=496 witness_x=24_deferred_vs_0_legal pivot_residual=48 controls=73 no_new_kappa, scripts/research_package.py --check-only prints PASS_PACKAGE_METADATA_AND_PINS, and python3 -B -m unittest discover -s tests -p 'test_research_*.py' passes (65 tests, 3 skipped).

Remaining obligations

• Your suggested fixed-reader guard 1616 - 1672 == -56 is not added in this correction: the correction is prose-only, and a 74th control would change the 73-control replay and its published output line. The four cells and both net values are now stated in the PR body and README and were already in RESULT.json; the guard stays as an optional follow-up control.
• The registered ledger strings (RESULT.json's obstruction.deferral_residual text and TASK.json's evidence line) keep their original window-record phrasing; their numbers were already correct and are left byte-unchanged.
• No circuit or saved price change, consistent with your finding.

Prepared by Aaron Wang, with help from opencode (substantial AI assistance; no independent human review claimed). No model is named.