Rungs 3 and 4 of the bank ladder: κ = 7.11175695867958e-4, and the top of the complex ledger (priced target, not a witness)

[maxime-fleury]

A scheduled target, not a witness. kappa = 711599961413937/10^18 = 7.11599961413937e-4
-- +0.4671% over #224's rung 2 and +4.1584% over the #207 frontier -- conditional on
the same open obligations rung 2 carries, plus two new inventories. The bank schedule those
rungs need is built here, not merely owed: every bank exactly filled, every item in a block,
the remainder padded from a retained bin.

Package: research/complex-bank-run3/, self-contained on main: it vendors #219's rung-1
package byte-identically under references/pr219-run1/ and #207's frontier certificate, and
pins 27 files by sha256.

cd research/complex-bank-run3 && python3 -B verify.py

The ladder, and where it stops

Rung 2 (#224) absorbs the complex word's rank-11 family and lands on the complex branch's
ceiling, so every further rung has to raise the complex coarse saving. The criterion that
makes such an absorption free is that the family's own volume is a whole number of width-66
banks (66 | rank * children), and exactly three families of that ledger satisfy it:

rung	what leaves the ledger	per bank	banks	complex coarse	kappa	vs rung 2
2 (#224)	complex rank 11	6 rank-11 blocks	531	7.08793603125109e-4	0.000708291570590726	—
3, volume criterion	+ complex rank 16	—	192	7.11077971348264e-4	0.000710572698755137	+0.3221%
3, padded schedule	+ complex rank 16	4 blocks + 2 registers	198	7.11289982558164e-4	0.000710784408728476	+0.3520%
4, volume criterion	+ complex rank 20	—	60	7.11681826686289e-4	0.000711175695867958	+0.4072%
4, padded schedule (the top)	+ complex rank 20	3 blocks + 6 registers	66	7.12106696511698e-4	0.000711599961413937	+0.4671%

The two "volume criterion" rows are the accounting the criterion gives and are kept because
they are what the ledger arithmetic produces -- but a width-66 bank cannot host them (192 and
60 are below the capacity bounds 198 and 66, and no uniform tiling absorbs two bins at
once). The padded rows are the schedule a bank admits, and they price higher, so the padded
rung 4 is the top this PR claims.

After rung 4 no family of the remaining 17 has a whole-bank volume (the check is
machine-asserted), so the accounting criterion the built rungs use is exhausted: 795 banks in
total (531 + 198 + 66), top row W = 35,361, rank mass 2,329,866, 634,473 children, largest
child 19. Each step keeps the row identity 66 * W - rank_mass = 3,960 and drops the stock by
exactly the bank count (531, 198, 66).

Two consequences fall out of the same arithmetic, and they are the useful part:

• reaching kappa = 7.2e-4 needs a complex coarse saving of 7.20518773516934e-4, i.e.
  +1.1809% more than the top rung's -- more banking than the remaining mass can supply at
  this width;
• while the complex branch caps the budget, the assembly's ceiling is capped by Build #208's bank-absorption target: rank-22 residual absorption — certified accounting κ = 7.00427501305159e-4 (R1–R4 open; not a completed witness) #219's rung-1
  bit leaf, so kappa = 7.5e-4, 8e-4 and 1e-3 are unreachable on this bit word, whatever
  the complex ledger does. Those targets need a new bit supplier first.

Status (unchanged blocker, two new items)

obligations.json states C1-C7 and inherits #219's R1-R4; T1, which this PR carried as an
obligation, is settled below. Read from the pins rather
than asserted: the complex supplier's certificate carries no key containing bank at all,
and the only banked word in the pins is the bit word's entrance-gauge pack (#205, 45,842
banks of width 72 over rank-60 exteriors). Nothing enumerates the complex word's rank-11,
rank-16 or rank-20 children, so the item-to-block map has no starting inventory (C6, C7). And
because 66 = 4 * 16 + 2 = 3 * 20 + 6, the two new families cannot tile a bank alone.

T1 is now enumerated, and the answer is negative (schedule66.py, schedule66.json,
re-run by verify.py). A uniform pattern -- the same pattern in every bank, as the certified
bit-side construction uses -- forces one common bank count B with k_f = n_f / B, so B
divides gcd(n_f) and sum_f k_f * f <= 66. That is exhaustive:

family	blocks per bank	banks by volume criterion	banks its capacity needs	uniform patterns
11 (rung 2)	6 (66 = 6 * 11)	531	531	4, tightest 531
16 (rung 3)	4 (66 = 4 * 16 + 2)	192	198	4, smallest 198
20 (rung 4)	3 (66 = 3 * 20 + 6)	60	66	3, smallest 66

No subset of two or three families admits a uniform tiling at all; {16, 20} comes closest,
its common divisor 198 giving four rank-16 and one rank-20 block per bank -- 84 registers into
a 66-wide bank. The volume criterion and the capacity criterion coincide only when the rank
divides the width, which is why rung 2's 531 is consistent and the unpadded 192 and 60
are not.

T1 is settled, at the schedule level (prototype66.py, checked by verify.py, recorded in
certificate.json -> padded_schedule). A bank the family cannot fill alone is filled by the
family plus a fixed pattern of retained blocks:

rung	banks	per bank	padding per bank	chosen draw
11	531	6 rank-11 blocks	0	none
16	198	4 rank-16 blocks	2	2 rank-1 blocks per bank (396 rank-1 children of 262,602)
20	66	3 rank-20 blocks	6	6 rank-1 blocks per bank (396 rank-1 children)

Every bank is exactly full, every family item lands in a block with no slot unused
(4 * 198 = 792, 3 * 66 = 198, 6 * 531 = 3,186), the item-to-block map is explicit (item
i -> bank i // k_f, block i % k_f), and the padding is a partial draw from a bin the
ledger keeps, so the retained histogram carries the reduced count. Because the mass leaving is
banks * 66 by construction, the row identity holds and the stock falls by exactly the bank
count at every step. All padding options are enumerated and compared (rank 16: two; rank 20:
eleven), and the best is the one claimed. What this is not: the normalizer, frames, charts and
prime witnesses remain C1-C7, and the padding blocks are ordinary retained children -- no new
frame family is introduced.

Is the bank width a lever? No -- and the scan says which lever is one

The bank width is not a schedule parameter, it is the word's own modulus. The pinned
bit-side schedule fixes it: M = 72, its rank-22 bin's 20,016 occurrences carrying
22 * 20,016 = 440,352 registers into 440,352 / 72 = 6,116 banks, with the stock dropping
by exactly the bank count. So a width scan is a word scan (widths66.py), and it answers:

• nothing narrower exists. The engine's contraction is rank mass < W * modulus, and the
  pinned row has rank mass / W = 65.8905..., so every w <= 65 leaves the row unposeable
  (recorded at 48, 54, 58, 60, 63, 64, 65). 66 is the smallest modulus this ledger admits.
• nothing wider is comparable. Holding the ledger fixed while raising w leaves a row whose
  rank mass fills only mass / (W * w) of its capacity: 99.834% at 66, 95.5% at 69, 91.5% at
  72, 68.6% at 96 -- a different word, which is why only the pinned width is priced, and where
  the scan reproduces this PR's own top exactly as its calibration.
• the criterion is not the cap, the density is. At w = 54, nine of the 20 families would
  tile whole banks and 1,549,098 registers (65% of the rank mass) could leave, against
  52,470 (2.2%) here. A less dense complex word -- more stock per unit of rank mass -- would
  admit a narrower modulus where far more of its ledger tiles at once. That is what to look for
  in a new supplier, measured rather than guessed.

What is instanced, and what is still owed

The schedule's items are now addressed (instantiate66.py -> occurrences66.json), which is
C1's combinatorial half and the C5-C7 inventories: item i -> bank i // k_f, block
i % k_f, offset (i % k_f) * rank.

family	per vertex	items (3 copies)	banks	blocks per bank	padding registers	table digest
11	1,062	3,186	531	6	0	fb9bd2d17f69...
16	264	792	198	4	396	f96efd45d9d9...
20	66	198	66	3	396	f9d9567b4b41...

4,176 items over 795 banks, 792 registers of padding (0.30% of the kept rank-1 bin), every
bank exactly filled, every block exactly one item, a per-family digest over the whole table, and
the ledger re-derived with the stock falling by exactly the bank count. What stays owed is read
from the pins rather than asserted: the complex supplier's certificate has no key containing
bank and its own status line says a literal globally renumbered operation program is not
exported, so the residual projectors the normalizer must move (C1's physical half) are not
there, and C2-C4 plus each child's frame/chain identity (C5-C7) follow the same gap. The shape
owed is pinned for the bit word at references/pr219-run1/inputs/absorbed-occurrences.json.

Verification

• verify.py (exit 0) pins 27 files by sha256, rebuilds the whole complex-side ladder from
  pinned bytes, recomputes both paid moments per rung on the 10^-18 grid, runs the two
  unchanged 47-constraint assemblies with the adjacent grid points rejected, and reproduces
  Conditional kappa 6.831904550365e-4: coordinated frame optimization and completed entrance banks #207's, Build #208's bank-absorption target: rank-22 residual absorption — certified accounting κ = 7.00427501305159e-4 (R1–R4 open; not a completed witness) #219's and Rung 2 above #219: a complex-side bank ledger that raises κ to 7.0829157e-4, blocked on C1/C5 #224's published grid points exactly (a_complex and both kappas
  asserted equal, not within a tolerance). The independent replica at my Price the bank-absorption ladder against the suppliers' own allocation rules: +2.17% needs a new residual type this word does not have (target, not built) #208 pricing model's
  convention reproduces Price the bank-absorption ladder against the suppliers' own allocation rules: +2.17% needs a new residual type this word does not have (target, not built) #208's own published rung-2 value 3541457/5*10^9.
• A separate re-derivation written against the raw pinned bytes with plain integer and
  Fraction arithmetic -- no package module and no engine -- re-checks the row identities, the
  three volumes, stock-drop-equals-bank-count, the eligibility list {11,16,20}, the
  exhaustion, both kappa values, both ceiling landings, the gains and the next-step targets.
• The T1 scan is re-derived independently here, by brute force over every bank count instead
  of by the package's divisor logic: same pattern sets, same capacities, same obstruction. The
  padded schedule is re-checked as well: banks, blocks per bank, saturation, the padding draw,
  the stock drops 531/198/66, the padded top above the volume-criterion rows, and the
  exhaustion of the criterion afterwards.
• The width scan is re-derived as well: which widths are poseable, that only the pinned one is
  priced, and that the scan reproduces this PR's top at 66; and the instanced schedules are
  re-checked (795 banks, 4,176 items, 792 registers of padding, saturation, exactly-filled
  banks, the digests, the stock drops 531/198/66).
• Line endings are LF throughout (schedule66.py, widths66.py, instantiate66.py, the
  regenerated JSON, all sources) and every pin matches the stored bytes, so the checks pass on a
  fresh clone (verified in a clean worktree of this commit).
• Not run: upstream CI, and any contributor verifier other than the vendored Build #208's bank-absorption target: rank-22 residual absorption — certified accounting κ = 7.00427501305159e-4 (R1–R4 open; not a completed witness) #219 package
  invoked in place.

Scope and limits

• Not a witness: the accounting, the padded bank schedule and the item addresses are
  certified; C1's physical half, C2-C4 and the inherited R1-R4 are open, so no normalizer, chart
  or physical witness is built. Not an unconditional multiplication theorem, not a practical
  multiplier, not a Lean certificate.
• T1 is settled (enumeration plus the padded schedule), and what it settles is a schedule:
  the bank geometry, the item-to-block map and the padding draw are checked, the normalizer,
  frames, charts and prime witnesses are C1-C7.
• The whole-bank volume condition is necessary and is what the built rungs use; it is not
  sufficient -- for the two new families it is not even compatible with a width-66 tiling at
  the bank count it prices, which is why the padded schedule exists.
• Nothing here bounds any other complex-side lever: this ladder is over this supplier's child
  ledger at this bank width. A different word, width or frame layout is not priced.
• The 10^-10 supplier field is priced too (certificate.json -> conservative_variant)
  rather than ignored.

Credits: rung 1, its schedule, the interval-moment engine and the 47-constraint assembly are
#219 (vendored, imported, not re-implemented); the frontier and the complex ledger's shape
are #207; rung 2 and the ceiling argument are #224; the ladder and the 10^-10 replica
convention are #208; the bank proof and engine chain are #200/#205 (Chafik Boukhalfa and
the #197/#205 line) and #184/#168-v4 (icekylinx, eumemic) as inherited through them. This
package adds the rank-16 and rank-20 absorptions and their prices, the exhaustion proof and
the next-step arithmetic. Apache-2.0; no existing file is changed.

Prepared by Maxime Fleury with Codebuff assistance.

🤖 Generated with Codebuff

[maxime-fleury]

Superseded by #246, which carries this same package plus the rank-3 rung on #233's row (κ = 1819302815717/25·10^14 = 7.277211262868e-4, bit-bound) and its mergeable form: head 545665b, +194,111/−0 over 70 new files, no existing file edited, with the package's own path-filtered workflow green on 3.11/3.13/3.14 and the full matrix green in the fork (52/52 jobs). Closing this one so the queue has a single head for this ladder; the history here stays as submitted.