Conditional κ = 8.339545889388e-4 on #233's row: the bit word's own retained ledger banked a second time (B1 open, not a witness)

[maxime-fleury]

Conditional κ = 8.339545889388e-4 on #233's row: the bit word's own retained ledger banked a second time, which spends the whole complex branch

κ = 416977294469409/500000000000000000 = 8.339545889388e-4, and binding = complex for the
first time on this ladder: +14.5981% over #246's rung (1819302815717/25·10¹⁴ =
7.277211262868e-4). The schedule those absorptions need is measured here, not merely owed: the
retained bit row is re-derived, every family's two readings of the bank criterion are applied, the
leader's three absorptions are applied by hand -- a whole family out, the padding per bank drawn
out of the singleton bin, the stock falling by exactly the bank count -- and the point is priced
through the unchanged 47-constraint assembly. The claim is still a priced target on a scheduled
row: conditional on C1-C7 and on #219's inherited R1-R4, whose PRs are unmerged and pinned by
digest. Not a witness.

Package: research/complex-bank-run3/, self-contained on the branch, extended in place. It vendors
#219's rung-1 package byte-identically under references/pr219-run1/ and #207's frontier
certificate and #233's row, and pins 66 files by sha256.

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

Result

The ladder has been bit-bound since rung 2, and the leaf that bounded it had been treated as a
constant of #219's word. It is not one: the rung-1 retained row is a ledger with thirteen more
bankable families in it, and every absorption lowers the retained mass, so the leaf itself moves.
The rank-3 rung on #233's row (bitrung.py's baseline, and #246's point):

rung on #233's row (head 109a857, pinned by digest)	value
banks	4,086 (1,362 per copy), 22 rank-3 blocks × 3 registers, padding 0
retained coarse saving	417325324839139/5·10^17 = 8.346506496783e-4, the next 10⁻¹⁸ grid point up excluded
budget	the bit leaf 7.282510899902e-4 — bit-bound, so the complex supplier did not bind
κ	1819302815717/25·10¹⁴ = 7.277211262868e-4, binding = bit

The screen: thirteen of the retained row's 21 families can leave into whole width-72 banks or into
the padded schedule a bank admits, so every rung of up to three of them is priced (13 + 78 + 286 =
377 rungs), by the vendored interval-moment engine. The leading rows, exactly as bitrung.json
records them (the gains are the recorded kappas divided by the rank-3 rung's):

absorb	banks	retained W	bit leaf	kappa	binding	gain over #246
rank 20	5,280 of 3 blocks + 12 registers	45,006	7.957727174054441e-4	397569983356707/500000000000000000 = 7.95139966713414e-4	bit	+9.2644%
ranks 4, 20	6,878 (rank 4 exactly filled, rank 20 as above)	43,408	8.337650404202950e-4	104133806924797/125000000000000000 = 8.33070455398376e-4	bit	+14.4766%
rank 21 alone	15,018 of 3 blocks + 9 registers	35,268	9.319873169802724e-4	416977294469409/500000000000000000 = 8.339545889388e-4	complex	+14.5981%
ranks 7, 8, 20 (the leader)	7,342 (1,224 of 10 blocks + 2 registers; 838 of 9, exact; 5,280 of 3 + 12)	42,944	8.349765438523530e-4	416977294469409/500000000000000000 = 8.339545889388e-4	complex	+14.5981%

against	value	gain	asserted
the rung below, on the same row (#246)	1819302815717/25·10¹⁴ = 7.277211262868e-4	+14.5981%	asserted, by verify.py, offline
the frontier this package prices against (#207)	1366380910073/2·10¹⁵ = 6.831904550365e-4	+22.07%	the comparison is asserted, by verify.py, offline
this package's previous top (the padded rung 4)	711599961413937/10^18 = 7.11599961413937e-4	+17.19%	stated
the record published on main (#186)	330942774629799/5·10¹⁷ = 6.61885549259598e-4	+26.0%	stated, dated
the highest other open claim at the time of writing (#257)	7.104652045e-4	+17.4%	stated, dated

The two asserted rows cannot drift: verify.py → check_bit_rung re-derives both numbers from the
pinned bytes and asserts the comparisons (there, the two gains are exact quotients of recorded
values). The three stated rows are dated observations of this package and of the queue, and are
labelled as such.

Why the bit leaf was the lever, and what the criterion is

#219's rung 1 absorbs the rank-22 family of the PR200/PR205 packed bit word into 6,116 whole
width-72 banks and leaves a retained row of W = 50,286 roles, rank mass 3,614,784, deficit 5,808
and 857,622 children over 21 ranks, whose certified paid saving -- bootstrapped through #185's
three-level chain -- is the leaf 7.282510899902e-4. Every reading of this package so far priced
that row as it stands, which is why the earlier sections concluded that 7.5e-4, 8e-4 and
1e-3 were out of reach on this word. bitrung.py prices the row one rung further: a second family
can leave the same retained ledger into whole banks, the way the rank-22 bin did, and the leaf
rises by +14.6550% to 8.349765438523530e-4.

The criterion is rung 1's, restated on the retained row and read two ways, because the two readings
are not the same rung:

• the volume reading: the family's own volume is a whole number of width-72 banks,
  72 | rank * n_rank;
• the padded reading: what a bank can actually host when the rank does not divide the width --
  capacity = 72 // rank blocks of the family plus 72 mod rank registers of padding in every
  bank, so it needs saturation (capacity | n_rank) and a retained bin that can supply the padding.
  This is T1's padded schedule, one word over, and the module checks rather than asserts that each
  padded step needs its own bank count: rank 7's volume reading prices 1,190 banks where its
  schedule needs 1,224 (1,190 × 10 = 11,900 < 12,240 items), and rank 20's prices 4,400 where its
  schedule needs 5,280 (4,400 × 3 = 13,200 < 15,840 items). The rung prices the schedule, not the
  accounting.

The schedule keeps the retained row's identity: W = 42,944, rank mass 3,086,160, deficit 5,808,
756,192 children over 18 families, the stock dropping by exactly the 7,342 banks, and 65,808
registers of padding in all drawn as a partial removal from the singleton bin -- exactly what T1
does on the complex side.

The binding side changes here, and that is the result. The leader's leaf sits above the
complex branch it has to clear (the rung reaches 1.000390455784346 of that branch), so the budget
is the branch 417325324839138999999999582174675160861/5·10⁴¹ and the kappa is
416977294469409/500000000000000000, the last 10⁻¹⁸ grid point at or below #233's row's complex
ceiling 417325324839139/500417325324839139. So the wall moves rather than disappears: every
further bit rung is capped by the complex side, and the next increment is the complex supplier
again -- or a new bit word that lifts the leaf without spending the branch.

The plateau: 108 rungs, one point

108 of the 377 screened rungs price 416977294469409/500000000000000000, because once a rung's
bit leaf clears the complex branch the budget is the branch and every such rung lands on the same
point: the screen is not choosing among them, the cap is. The point therefore does not depend on
which rung is quoted; only the cheapest bank count does, and the package's own leader rule (highest
kappa, ties broken by the fewest banks, then by the sorted ranks) is why the claimed rung is ranks
7, 8 and 20 at 7,342 banks rather than rank 21 alone (15,018 banks) or ranks 4 and 21 (16,616).
Both sides of the plateau are asserted: every rung that carries the point is complex-bound, and
every bit-bound rung lands strictly below it.

What proves it

cd research/complex-bank-run3
python3 -B verify.py            # check: pins, rebuild, compare with certificate.json, bitrung.json and occurrences-bitrung.json
python3 -B bitrung.py           # the measurement: writes bitrung.json
python3 -B bitinstance.py       # B1: the item maps, bank tables, padding draw and induced ledger
python3 -B importer66.py --self-test   # the harness's own thirteen cases
cd references/pr219-run1 && python3 -B verify.py   # the vendored rung-1 package, in place

verify.py pins 66 files by sha256 -- the 37 this package owns (bitrung.py, bitinstance.py and
their two artifacts among them, and the ranked heads of #233), the two upstream certificates it is
priced against (#207's frontier and #233's row), the 16 the vendored rung-1 package of #219 carries
and the 11 of the bit drop -- and
rebuilds the whole complex-side ladder (base, rung 2, rungs 3 and 4, both paid moments per rung,
the two 47-constraint assemblies with adjacent-grid rejection, the eligibility and width scans, the
PR208 replica, the padded schedule, the instanced inventories and all three export contracts), then
checks the new rung: verify.py → check_bit_rung re-derives the rung-1 retained row from the
pinned packed certificate with plain integer and Fraction arithmetic, no package module and no
engine, re-checks every family's two readings, applies the leader's three absorptions by hand
(whole family out, the padding per bank out of the singleton bin, the stock falling by exactly the
bank count), re-runs the bootstrap chain and the assembly rule, computes the kappa on the grid
below the bound, asserts the leader's minimality on the plateau and both comparisons above, and
compares the whole measurement with bitrung.json. verify.py -> check_bit_instancing does the
same for B1: it rebuilds the instancing, recomputes both digests from the addressing rule rather
than trusting them, re-checks the padding as a partial removal from the singleton bin, asserts that
the induced ledger is the row check_bit_rung prices, and asserts that the pins still export no
block and no occurrence of these three families. verify.py reproduces #207's, #219's and #224's
published grid points, and the rank-3 rung's own, exactly -- the bit rung's complex branch is the
rank-3 rung's recorded coarse saving, which check_bit_rung asserts rather than assumes.

The package's own path-filtered workflow (.github/workflows/complex-bank-ladder.yml, 3.11, 3.13,
3.14: verify.py, the vendored package's self-check, the three contracts' self-tests, then
git diff --exit-code) and the repository test module (tests/test_complex_bank_run3.py, which now
also asserts this rung's kappa, its complex binding, the leader and the plateau) cover it. The
change extends the package's own files (bitrung.py, bitrung.json, verify.py, pins.py,
run3.py, obligations.json, README.md, the regenerated SOURCE.json and certificate.json) and
the test module; the pinned vendored inputs, the other rungs' artifacts and the three export
contracts are untouched.

Status

• B1 is INVENTORY_INSTANCED_AT_SCHEDULE_LEVEL (obligations.json), the bit side's second
  absorption: its schedule half is instanced -- bitinstance.py gives every one of the 35,622
  items of ranks 7, 8 and 20 a bank, a block and an offset, fills every bank exactly with the
  family's blocks plus the padding it draws, names the 65,808 registers of that padding item by
  item out of the retained singleton bin (digested, 1828/10481 of the bin), digests each family's
  bank table, and re-derives the ledger the absorptions induce (stock 50,286 -> 42,944, rank mass
  3,614,784 -> 3,086,160, 857,622 children -> 756,192 over 18 families) from the pinned packed
  certificate. Its provenance half is open, and machine-read rather than asserted: the pins
  carry no key containing block or occurrence for this word -- the packed certificate's single
  assign key is its own rejection control -- so each of those 35,622 items has an address and no
  identity, and the shape owed is Build #208's bank-absorption target: rank-22 residual absorption — certified accounting κ = 7.00427501305159e-4 (R1–R4 open; not a completed witness) #219's rank-22 inventory, key for key (H, H_center, Y,
  src). The no-other-bin-moves proof is owed with it.
• R1-R4 (inherited verbatim from Build #208's bank-absorption target: rank-22 residual absorption — certified accounting κ = 7.00427501305159e-4 (R1–R4 open; not a completed witness) #219) and C1-C7 are unchanged: the normalizer, the formal
  columns, the charts and prime witnesses, the envelope parity and each child's frame/chain
  provenance. The absorbed families need the new residual types the suppliers' proofs reserve,
  exactly as the complex rungs do, and the rows are pinned by digest to unmerged branches.
• No witness, no completed finite witness, no unconditional multiplication theorem, no practical
  multiplier, and no Lean/kernel certificate is claimed -- here or anywhere in this ladder.

Scope and limits

• The measurement is over the retained bit ledger of 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 word at width 72, and over
  rungs of up to three families. Longer rungs are not screened; on this cap they cannot change the
  point, but that is not measured.
• The whole-bank volume condition is necessary and is what the built rungs use; it is not
  sufficient, which is exactly why the padded schedule exists and why the module records where the
  volume-criterion bank count fails to host its own items.
• A moved branch fails check_manifest closed and the measurement must be re-taken: the head of
  A stronger complex supplier: PR200's reuse pairing on the source-assisted v4 word, complex saving 7.0991·10⁻⁴ (+1.28% over #194; no new κ, bit binds) #233's row is pinned by digest.
• Nothing here bounds any other bit or complex lever: a different word, width or frame layout is
  not priced.

Attribution and provenance

Apache-2.0. The vendored inputs -- #219's rung-1 package, #207's frontier certificate and #233's row
certificate plus its earlier heads -- are retained byte-identically with their notices and credits
(NOTICE.md, SOURCE.json); #233's contribution (chafreaky) is the row this result is priced
on and is credited as such, and #233's source-assisted row and #246's rank-3 rung are what make
the complex branch the productive side at this point. Rung 2 and the ceiling argument are #224's,
the ladder and its replica convention are #208's, the bank proof and the engine chain are
#200/#205/#206/#197's (Chafik Boukhalfa and the #197/#205 line), #184/#168-v4's (icekylinx,
eumemic), #183's and #193's, and #185's bootstrap chain is what the bit leaf is read through;
nothing is re-implemented or restated as new. Prepared by Maxime Fleury with Codebuff assistance.

🤖 Generated with Codebuff

Supersedes #246, which carries the same package without the bit-side rung.

[ploniaaaaaaa]

waow

[maxime-fleury]

Second commit on this branch (dd3bec2): B1's schedule half is now instanced. bitinstance.py (checked by verify.py -> check_bit_instancing, recorded in occurrences-bitrung.json) gives every one of the 35,622 items of ranks 7, 8 and 20 a bank, a block and an offset (bank i // k_f, block i % k_f, offset (i % k_f) * rank) over 1,224 + 838 + 5,280 = 7,342 banks, one item per block, every bank exactly filled by the family's blocks plus the padding it draws; the padding is named item by item out of the retained singleton bin -- 2,448 rank-7 and 63,360 rank-20 registers, the first 65,808 of its 377,316 children, 1828/10481 of the bin, digested -- leaving the 311,508 the measured rung's retained histogram holds; each family's bank table is digested; and the ledger the assignment induces (stock 50,286 -> 42,944 with the drop equal to the bank count, rank mass 3,614,784 -> 3,086,160, 857,622 children -> 756,192 over 18 families) is re-derived from the pinned packed certificate and cross-checked against the row check_bit_rung prices.

B1 therefore moves from OPEN to INVENTORY_INSTANCED_AT_SCHEDULE_LEVEL, with its provenance half open and machine-read rather than asserted: the pins carry no key containing block or occurrence for this word (the packed certificate's single assign key is its own rejection control), so each of those 35,622 items has an address and no identity, and the shape owed is #219's rank-22 inventory key for key (H, H_center, Y, src).

Pins are now 66 files. Locally: verify.py exit 0 (check_bit_instancing included, exit status read directly, not through a pipe) and tests/test_complex_bank_run3.py 11 tests, 0 failures; the committed certificate.json matches a fresh rebuild on HEAD and the tree is clean.

[Mister-Meeseeks]

Thank you @maxime-fleury. This contribution is now retained on main in the scoped 100-PR review and contributor credits.

Contribution: Rank3/rank4 bank targets, retained-input bodies and import contracts.

Review and limits: Fresh target-analysis verifier and mutation tests. B1/provenance and remaining export/implementation obligations stay open; the numerically larger target is not an achieved frontier.

The complete original source, notices and relevant execution evidence are retained through the pinned source archive. The review distinguishes fresh local runs, source-bound historical Linux CI and prior exact-head review; it does not claim 100 fresh full mathematical audits. Closing this historical PR as reconciled. This preserves parallel and cumulative credit without replacing the selected frontier or promoting priced research targets to completed constructions.

Reviewed head: dd3bec29abd124b94e8642d84a3552f2459a3faa. Publication: 50d768818f579d4e165b4c257c6ee25bca300802.