Repository navigation
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
Closed
maxime-fleury wants to merge 13 commits into
Conversation
…inite leaf PR200 certifies a strictly stronger bit word but publishes it only with its own complex word, where the complex branch binds; it announces the stacked composition "as separate work". Pricing that composition through PR194's unchanged assembly with PR185's finite ordinary leaf gives kappa = 1693287/2500000000 = 6.773148e-4, +0.1826% over PR197's standing claim and +0.0639% over the value PR200 announced for it. The package vendors the minimum needed to price it: the PR168 v4 assembly, PR184's pricer and finite bridge, PR194's certificate and PR200's bit certificate, all digest-pinned. verify.py reproduces the certificate from those pins, reproduces PR200's announced depth-0 value, shows PR184's grid leaf and PR200's published atom wrapper differ by one grid step at depth 0 and not at all once bootstrapped, requires the claim to beat PR197 and to sit inside one grid step of the word's own C/(1+C) ceiling, and refuses three corruption controls.
…e published values Banking a word's rank-60 exterior corrections is the only validated way to raise a bit coarse saving materially, and this word has the same 2,200 of them per copy that PR197 banked. levers.py solves the paid-moment inequality exactly over the rationals and models that transformation as the accounting PR197 validated: drop the rank-60 entries, keep the per-copy deficit, let the stock fall to what the row identity requires. The model reproduces PR187's unpacked row, PR197's independently certified banked row, and PR200's unpacked row to 1e-13 relative or better, so it is checked on a word it was not fitted to. Applied here it predicts kappa = 6.83061299e-4, +0.8484% over this package's claim, and pins the falsifiable target for whoever builds the banks: total stock 56,402 over three copies, per-copy deficit unchanged at 1,936, no rank-60 child remaining. levers.json records the MODELLED, NOT CONSTRUCTED status and verify.py enforces it.
Fraction has no float-style __format__ before 3.12, so the two gain prints raised TypeError there; both now format floats. verify.py also compares the model's shipped numbers with a tolerance on floats and exactness on integers and exact rationals, so a different libm cannot fail the check by moving digits the model's bisection cannot resolve anyway.
Reusing the vendored interval_moment module on the same 10^-18 grid turns the model's three checks from 1e-13 tolerances into exact reproductions of PR187's certificate, PR197's certified banked word and PR200's certificate, so the predicted 0.8484% gain rests on the supplier's arithmetic rather than on a portable float.
CrocSwap#202 carries the same bit and complex words at exactly the depth-0 value this package prices, so the cross-check now points at it: the whole claimed gain is the finite leaf it does not apply.
The lever model's prediction was built within the half hour: audit.py prices CrocSwap#205's, CrocSwap#206's and CrocSwap#207's banked rows from byte-identical copies of their certificates and reproduces each author's coarse saving to the last digit, confirming every one sits at its own word's ceiling. The cheapest admissible ledger of the frontier row's mass would lift it 76.6%, which bounds the room a better schedule can still buy.
PR207's certificate is stored with CRLF upstream, so the committed blob is the LF-normalised copy while the working tree kept the Windows line endings; the pin now records the digest a clean Linux checkout produces.
The assembly takes the smaller branch budget, so the complex word caps the frontier at +2.52% and the bit word's 377,316 rank-1 children -- dirt the banks refuse -- are enough to reach it. Soaking both rows' small children buys +16% to +76% on the 10^-10 grid; every rung is a target, not a construction, and the calculator is checked against PR184's own assemble() and against PR205's and PR207's published kappa.
Bisecting the bit word's smallest-child population shows 57/1000 of its mass is enough to clear the complex side, so the whole +2.52% first rung is a 5.7% coarsening of one population rather than a new construction. CrocSwap#207's bank proof settles the packing side itself, so the README now points the next move at the word's child inventory, which is where the ledger term actually lives.
Absorbing a family into the banks drops its dirt from the ledger, and by the row identity W = (mass + D)/m the stock drops with it. Searching every family set over all ranks and pricing the best of each subset size exactly sorts the rungs into two tiers. Families whose blocks tile a bank by themselves -- the bit word's ranks 6, 8, 18 and the complex word's rank 11, the shape CrocSwap#207's own schedule has -- are sound schedules: +2.17% for one new residual type, +2.52% for two, +3.67% for three. Keeping only the volume condition, which is what the certified CrocSwap#197/CrocSwap#205/CrocSwap#207 banks satisfy (their absorbed rank 60 does not divide 72 either), opens a bracket up to +79.52%. verify.py re-derives the sound families of both words from the queue's certificate and re-prices the first four sound rungs without using rungs.py. Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com>
maxime-fleury
force-pushed
the
research/banked-family-rungs
branch
from
October 9, 2026 17:13
5a144d3 to
344c3f8
Compare
The queue's own banked rows and CrocSwap#207's BANK-PROOF-PR200.md decide the question this package had left open: the absorbed entries are the rank-60 entrance exteriors on a width-72 word, so an absorbed family's rank is free, and 60 does not divide 72. What must hold is that the absorbed volume fills whole banks (396,000 = 72 x 5,500 over three copies) and that a bank's blocks -- the word's own residual families, 4 and 24 -- tile the width, as their 18 x 4, 3 x 24 and mixed 6 x 4 + 2 x 24 patterns do. So the certified-shape ladder becomes the primary one (+2.52% for a single new residual type, +6.54% for three, +79.52% for eight), and banking each family on its own blocks stays as the conservative subset. verify.py checks the precedent against the vendored banked rows and requires the two tiers to keep that relation. Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com>
…hedule allocate.py answers, from the suppliers' own code rather than from this model, which families their construction may bank: exactly one, the selected entrance-gauge exteriors (`hist[3*z['dim']] += 1`, removed by `H.pop(60)`), and this word has already taken it. Every rank the ladder would absorb is a retained family, needing the "future genuinely different residual types" the proof reserves; rank 2 is the alias children and rank 1 carries the source births, both excluded "from fresh bank allocation". It also fixes the schedule a builder would hand their generator for the two headline rungs, and verify.py re-derives the classification, the block patterns, the retained ledger and the row identity from the queue's certificate. Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com>
maxime-fleury
changed the title
CrocSwap#215 derives from the suppliers' own papers what allocate.py reads out of their code: a gauged role's correction is one child of width 3*dim sigma, the bank replaces exactly that child, and an entrance gauge needs content that is both don't-care and restored -- which targets (they accumulate) and sources (they are consumed) fail. The rung section now names that mechanism, records the two near-misses CrocSwap#215 prices outside it, and keeps the package's verdict unchanged. Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com>
maxime-fleury
marked this pull request as ready for review
October 9, 2026 18:53
This was referenced Oct 9, 2026
Closed
Contributor
|
Thank you @maxime-fleury. This contribution is now retained on main in the scoped 100-PR review and contributor credits. Contribution: Bank-absorption ladder priced against actual allocation rules. Review and limits: Reviewed research target, not a completed stronger multiplication witness. Exact pricing and explicit missing implementation obligations are useful contributions. 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: |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Stacked on #204: this branch contains that package, and these are its last three commits.
The question this settles
The frontier is at its ceiling for every pricing move, so the only lever left is the child
ledger: absorbing a family into the banks drops its dirt and, by the row identity
W = (mass + D)/m, drops the stock with it. The open question in the previous revision waswhat a bank requires of the family it absorbs. The suppliers' own bank proof answers it, and
it is not what I first assumed:
exteriors per vertex from a width-72 word, and 60 does not divide 72.
396000 = 72 x 5500.BANK-PROOF-PR200.md: "allocate the 92,200 selected role-copy occurrences into 1,100 bankswith 18 four-coordinate blocks" and "914,914 other occurrences into 44,742 banks with three
24-coordinate blocks";
retained-packing.pyalso runs the mixed6 x rank-4 + 2 x rank-24pattern. The bit word's own families 4 and 24 tile 72 exactly.The claim, promoted
So the certified-shape ladder is the primary one. Priced with this package's exact model on
the queue's certified rows:
A single new residual type reaches +2.52% -- the unmoved complex side's own cap, with the
complex word untouched -- and 750 of the 1,024 candidate pairs sit above the frontier.
The conservative subset stays in the package and is still a real schedule, just a narrower
one: a family whose own rank divides the bank width and whose own volume is a whole number
of banks can be banked on its own blocks, needing no shape beyond the word's. On these two
words that is the bit word's ranks 6, 8, 18 and the complex word's rank 11, giving +2.17%
(one type), +2.52% (two, the same cap) and +3.67% (three).
One caveat belongs here, from the supplier's proof: which families may be banked is a
family-allocation question, not an arithmetic one. #207 excludes internal alias recipients,
source births and deleted terminals "from fresh bank allocation", and its CROSSOVERS records
that the construction is "ready for future genuinely different residual types" -- so a rung is
a priced target in exactly the sense of the family the supplier would have to allocate banks to.
What is proven here
60 ∤ 72,volume
396,000 = 72 x 5,500, residual families 4 and 24 with18x4,3x24and6x4 + 2x24all equal to 72.banks * mequals the absorbed rank mass), the rowidentity after absorption, monotone
W, adjacent-grid exclusion under PR200's own intervalarithmetic on its
10^-18grid.verify.pyre-derives the tileable families of both words fromthe queue's certificate, re-prices the conservative tier's first four rungs from that
certificate without using
rungs.py, and re-checks that every certified-shape arm fillswhole banks.
assemble()on the vendored pair and reproducesPack PR200 diagonal bit residuals into completed banks (conditional κ = 0.000683061299399923) #205's and Conditional kappa 6.831904550365e-4: coordinated frame optimization and completed entrance banks #207's published kappa to within one grid step.
What building a rung physically needs (not done here)
The rung fixes the arithmetic interface their generator consumes -- the cheapest certified
rung is 6,116 banks of 72 registers on the bit word, volume 440,352 -- but the construction
needs the supplier's pinned tree (a 51,416,352-byte baseline archive plus PR200 at
a1175449...),numpy==2.3.5/scipy==1.17.0, the exact gauge charts, the normalizerrouting, the F2 and defining-integer columns and the 24,401 frame prime witnesses. Named as
the work that remains, not as work that was done. Each rung stays a target with a falsifiable
number, the way this package's lever model predicted #205's banked row before it was built.
Reproduce
Generated with Codebuff