From 777b642e85eb81564d1774e4747cb2313f0b54ec Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Wed, 11 Nov 2026 08:05:33 +0000 Subject: [PATCH] feat(research): certify fixed-profile helper split ceilings --- .../helper-split-headroom-ladder/README.md | 210 ++ .../helper-split-headroom-ladder/RESULT.json | 1893 +++++++++++++++++ .../helper-split-headroom-ladder/SOURCES.json | 30 + .../helper-split-headroom-ladder/TASK.json | 135 ++ .../helper-split-headroom-ladder/VERIFY.json | 35 + .../helper-split-headroom-ladder/intervals.py | 117 + .../helper-split-headroom-ladder/verify.py | 377 ++++ 7 files changed, 2797 insertions(+) create mode 100644 research/helper-split-headroom-ladder/README.md create mode 100644 research/helper-split-headroom-ladder/RESULT.json create mode 100644 research/helper-split-headroom-ladder/SOURCES.json create mode 100644 research/helper-split-headroom-ladder/TASK.json create mode 100644 research/helper-split-headroom-ladder/VERIFY.json create mode 100644 research/helper-split-headroom-ladder/intervals.py create mode 100644 research/helper-split-headroom-ladder/verify.py diff --git a/research/helper-split-headroom-ladder/README.md b/research/helper-split-headroom-ladder/README.md new file mode 100644 index 0000000000..7858840be6 --- /dev/null +++ b/research/helper-split-headroom-ladder/README.md @@ -0,0 +1,210 @@ +# Fixed-profile helper-split headroom on the #7000 invoice + +This package was produced by Nick Petalas. + +Claim type: scoped written proof with exact finite certificates. On the pinned +#7000 invoice, the greatest first crossing obtainable by replacing each helper +with at most two positive-integer-rank pieces is approximately +0.004689286593684114. Allowing all rank-one pieces gives approximately +0.011115356648105199. These are optimistic raw-margin ceilings on +**0 ≤ κ ≤ 0.02**, with the paid profile and every main-origin target fixed. +They do not establish a legal split or a new conditional κ. + +## Model and exact statement + +The source is `research/shared-wire-split-composition/FULL-RESULT.json`, +SHA256 `d9ba709fa5dcefffe3f3abdcf34600ce188224703cfd743e6db8b58ba4816cb7`. +[SOURCES.json](SOURCES.json) pins its Git blob and base commit. The source +construction and its admission are taken as premises, not replayed here. + +Let T_r and P_r be that file's complete productive and paid histograms. Define + + F_0(κ) = Σ_r (T_r − P_r) r^(1−κ). + +The helper histogram h_r is: + +| r | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| h_r | 13 | 18 | 44 | 215 | 68 | 42 | 18 | 67 | 595 | + +The invoice has T_r = 18h_r for r ≤ 8 and T_9 = 18h_9 + 416. +All targets above rank 9, and the extra 416 rank-nine targets, are fixed. +There are 1,080 original helpers, with total rank 7,650. The factor 18 counts +the eighteen LOCAL invocations. One helper split means the same replacement +in all eighteen invocations. + +Replace an original helper of rank r with a partition λ = (a_1,…,a_j), +a_i ≥ 1 and Σ_i a_i = r. Its change to the complete raw margin is exactly + + Δ_λ(κ) = 18 (Σ_i a_i^(1−κ) − r^(1−κ)). + +No new paid jobs are charged in this relaxation. For a piece cap m, let +b(r,m) be the balanced partition of r into min(r,m) parts. If +r = qj + s, 0 ≤ s < j, it has s parts q+1 and j−s parts q. Let + + F_m(κ) = F_0(κ) + Σ_r h_r Δ_b(r,m)(κ). + +For each m = 1,…,9, F_m has exactly one zero κ_m on [0,0.02]. Among all +allowed partitions with at most m **final pieces per original helper**, the +largest first zero on this interval is κ_m, attained algebraically by b(r,m) +for every helper. A sequence of binary splits with more than two final pieces +is outside the m=2 row. Any actual split-only continuation satisfying these +hypotheses has its first zero no later than κ_m. + +| Maximum final pieces m | κ_m, approximate | +|---:|---:| +| 1 | 0.003630058174688367 | +| 2 | 0.004689286593684114 | +| 3 | 0.005653731986780233 | +| 4 | 0.006587917894714106 | +| 5 | 0.007413801865724420 | +| 6 | 0.008144674208796709 | +| 7 | 0.008982372525120905 | +| 8 | 0.009988261544163143 | +| 9 | 0.011115356648105199 | + +[RESULT.json](RESULT.json) gives rational open brackets of width 2×10^-45 +for the roots, rather than treating the displayed decimals as exact roots. +The original source's stored crossing is reproduced numerically as a model +calibration. This is not an independent verification of its construction. + +## Proof + +For 0 < κ ≤ 0.02, x^(1−κ) is strictly concave on the positive reals. +If two integer pieces differ by at least two, moving one rank unit from the +larger to the smaller strictly increases their total credit. Repeating this +finite operation balances every fixed-length partition. If fewer than +min(r,m) pieces are used, splitting a piece of size at least two strictly +increases credit, because a^p+b^p > (a+b)^p for 00, the 595 rank-nine helpers gain strictly when m rises from 1 through 9. + +Here is the numerical part of the uniqueness proof. For coefficients c_r of +one scenario, put + + G(κ) = −F'(κ) = Σ_r c_r r^(1−κ) ln r, + L = Σ_r |c_r| r (ln r)^2. + +For κ≥0, |G'(κ)|≤L. On the eleven grid points κ=j/500, j=0,…,10, +the verifier proves G(κ)>L/500 by outward intervals. Every point in +[0,0.02] is within 1/500 of a grid point, so G>0 throughout. Exact sign +checks at both rational endpoints of each root bracket then certify the +unique root. This argument is applied to every ladder and single-split +scenario, and to the four stock-sufficient plans below. + +The interval restriction matters. At κ=1 the full-split margin is exactly +24,040>0, while F_9(0.02)<0. Therefore another zero exists above 0.02; +this package does not assert global single crossing or a ceiling on [0,1]. + +## Exchange rates and stock + +RESULT contains all 87 nontrivial integer partitions of ranks 2,…,9. Each row +records Δ_λ at the original crossing, the change in its first root after one +helper replacement, and the least integer n for which + + F_0(w) + n Δ_λ(w) > 0. + +The two comparison prices are the complex wrapper's fixed BIT pin +w=0.00376669 and the paired BIT ordinary admission w=0.00385248. The latter +is an accounting comparison point, not a claim that the complex wrapper can +use that price unchanged. These prices come from the two pinned input files. +The least count is proved by a negative interval at n−1 and a positive one +at n. Rows whose counts exceed h_r are explicitly marked unavailable. + +At either price the best gain from touching one helper comes from rank nine. +The verifier certifies this against each rank 2,…,8. Available rank-nine stock +suffices, so the following minima hold even when helper ranks may be mixed: + +| Comparison price | Any partition | At most two final pieces | +|---|---:|---:| +| 0.00376669 | 43 helpers, all 9→1+…+1 | 137 helpers, all 9→5+4 | +| 0.00385248 | 68 helpers, all 9→1+…+1 | 218 helpers, all 9→5+4 | + +For the lower bound, no n−1 touched helpers can supply more than n−1 copies +of the best per-helper gain. For attainability in the relaxation, take n +rank-nine helpers. The stock is 595. Both sides are exact interval checks. +For comparison, using only 9→8+1 needs 269 and 427 helpers respectively. + +## Certificate arithmetic and verification limits + +`intervals.py` uses integers scaled by Q=10^70. To enclose ln r, write +r=2^a u with 1≤u<2, and use the first 100 terms of +2 atanh z = 2Σ z^(2j+1)/(2j+1), z=(u−1)/(u+1). The nonnegative remainder +is at most 2z^201/(201(1−z²)); the same formula supplies ln 2. +Every conversion to Q is rounded outward. + +To enclose r^(1−κ), evaluate r/exp(κ ln r). Here 0≤κ ln r<1/8, since the +largest rank is 145. Eighty positive exponential terms are evaluated with +outward integer rounding. Twice the next term bounds the remaining tail, +since successive ratios are below 1/2. Reciprocal bounds are also outward. +`Decimal` logarithms and Newton steps only nominate rational root endpoints +and printed approximations; they cannot make a failing interval check pass. +All printed receipt approximations have absolute error below 10^-39. + +Every rank's power enclosure at κ=1/100 is additionally checked using exact +integer 100th powers. A separate combinations enumeration checks the partition +table, and exact majorization checks corroborate the balancing lemma. Five +negative controls reject a changed helper count, an out-of-range κ, an +unbalanced purported minimizer, a bracket missing the root and reversed +monotonicity. A sixth control checks signs around the original crossing. + +Power-of-ten scope is the two Python files. Loops are bounded by the pinned +rank set, ranks 1…9, 100 logarithm terms, 80 exponential terms, 60 Newton +steps, eleven grid points, and the finite partition list. Python's managed +allocation is a rule-3 deviation: both inputs are capped at one megabyte, +there are at most 145 ranks, and the independent enumeration has fewer than +100,000 candidate tuples. No process, network access, recursion or dynamic +code generation is used. Static compilation and `-W error` replays cover the +available Python diagnostics. No shared build configuration is changed. + +## Reproduce + +From the repository root, with CPython 3.12 and the standard library: + +```sh +~/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/helper-split-headroom-ladder/verify.py +~/git/integer-mult-bounds/.venv/bin/python3.12 -W error -O -B research/helper-split-headroom-ladder/verify.py +~/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/helper-split-headroom-ladder +~/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/helper-split-headroom-ladder --check-source-history +``` + +The first two commands rebuild the hash-bound receipt and compare every field. +To regenerate it, redirect `verify.py --emit` to a temporary file and compare +before replacing RESULT.json. The receipt binds both verifier files and both +scientific inputs. It does not bind its own bytes. + +Legality of the candidate splits, their pivot/cut/boundary bases, their +ADD/SCALE and ordinary costs, native/compiler admission and every outer gate +remain unproved here. No selected replay, Lean or Docker run is claimed. +Independent human and formal proof-kernel review are unclaimed. + +## Open next questions + +- Which rank-nine helpers admit legal 5+4 splits with no added paid rank? + A small exact prefix/suffix witness and complete cost ledger would test + whether the 137-helper wrapper threshold is relevant to construction. + Physical availability and shared correction costs remain the blockers. +- How does a changed paid profile alter these ceilings? First substitute an + exact successor invoice and redo its helper-origin decomposition; the + current ladder does not apply automatically to changed callers or tariffs. + +## Credit and related work + +Jerry Chen / CubeJerry's #7000 supplies the complete invoice and paired BIT +pin, building on DreamingOfClouds's #6936/#6937, CubeJerry's #6980 caller, +Ali Romman's helper-splitting method and the retained P104 lineage. The +current construction chain includes dillona, ToikY and Rohan Arun. zxv's +#5554 proves a different fixed-local-bill path ceiling. Nick Petalas's #6651 +already records classical balanced-partition optimality in a uniform-fee +model; that theorem and its thresholds are not claimed here. The new result +is the source-specific first-crossing ladder, exhaustive exchange table and +stock-constrained helper minima on the #7000 invoice. New material is +Apache-2.0; predecessor files and their notices are unchanged. diff --git a/research/helper-split-headroom-ladder/RESULT.json b/research/helper-split-headroom-ladder/RESULT.json new file mode 100644 index 0000000000..41e82b360a --- /dev/null +++ b/research/helper-split-headroom-ladder/RESULT.json @@ -0,0 +1,1893 @@ +{ + "claim_interval": [ + "0", + "0.02" + ], + "exchange": [ + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.0904680612098380197772025320730753825889", + "need_paired": 963, + "need_pin": 605, + "parts": [ + 1, + 1 + ], + "r": 2, + "root_bracket": [ + "0.0036302758759103188281331680459057387006652741645941034221454413836717092245561319", + "0.0036302758759103188281331680459057387006652761645941034221454413836717092245561319" + ], + "single_split_dk": "2.177012219517421995912810088390280E-7" + }, + { + "available": 44, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.2149245847170514173720008534378509293051", + "need_paired": 406, + "need_pin": 255, + "parts": [ + 1, + 1, + 1 + ], + "r": 3, + "root_bracket": [ + "0.0036305754094334052680042440234620759754921576525748688603641392139741149704593299", + "0.0036305754094334052680042440234620759754921596525748688603641392139741149704593299" + ], + "single_split_dk": "5.172347450381820706672585651763028E-7" + }, + { + "available": 44, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.1244565235072133975947983213647755467161", + "need_paired": 700, + "need_pin": 440, + "parts": [ + 2, + 1 + ], + "r": 3, + "root_bracket": [ + "0.0036303576720839125919258221730957494567489899424240687300300967978547151843126388", + "0.0036303576720839125919258221730957494567489919424240687300300967978547151843126388" + ], + "single_split_dk": "2.994973955455059922454081988497841E-7" + }, + { + "available": 215, + "available_paired": false, + "available_pin": true, + "gain_at_k0": "0.3614175520560705791871057769197515013931", + "need_paired": 241, + "need_pin": 152, + "parts": [ + 1, + 1, + 1, + 1 + ], + "r": 4, + "root_bracket": [ + "0.0036309280423660913103233023071819101888556913771190937504217073206079550146099625", + "0.0036309280423660913103233023071819101888556933771190937504217073206079550146099625" + ], + "single_split_dk": "8.698676777242243897255422850105162E-7" + }, + { + "available": 215, + "available_paired": false, + "available_pin": true, + "gain_at_k0": "0.2709494908462325594099032448466761188042", + "need_paired": 322, + "need_pin": 202, + "parts": [ + 2, + 1, + 1 + ], + "r": 4, + "root_bracket": [ + "0.0036307102624965992280940897569851996971085986567073506681216806734459144576043274", + "0.0036307102624965992280940897569851996971086006567073506681216806734459144576043274" + ], + "single_split_dk": "6.520878082321421605129920883000244E-7" + }, + { + "available": 215, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.1804814296363945396327007127736007362152", + "need_paired": 483, + "need_pin": 304, + "parts": [ + 2, + 2 + ], + "r": 4, + "root_bracket": [ + "0.0036304925089136074965059336419637865922915270099655082690699649717121247072894698", + "0.0036304925089136074965059336419637865922915290099655082690699649717121247072894698" + ], + "single_split_dk": "4.343342252404105723568770668869196E-7" + }, + { + "available": 215, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.1464929673390191618151049234819005720880", + "need_paired": 595, + "need_pin": 374, + "parts": [ + 3, + 1 + ], + "r": 4, + "root_bracket": [ + "0.0036304107066560455194213648563977956527777639485396789809643215412942962857214802", + "0.0036304107066560455194213648563977956527777659485396789809643215412942962857214802" + ], + "single_split_dk": "3.525319676784334877880915008959801E-7" + }, + { + "available": 68, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.5242787903436374051223036565058894113746", + "need_paired": 167, + "need_pin": 105, + "parts": [ + 1, + 1, + 1, + 1, + 1 + ], + "r": 5, + "root_bracket": [ + "0.0036313201571356087770777635346821848256516329710901972047050317576774472097992959", + "0.0036313201571356087770777635346821848256516349710901972047050317576774472097992959" + ], + "single_split_dk": "0.0000012619824472416911441867697852851530" + }, + { + "available": 68, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.4338107291337993853451011244328140287856", + "need_paired": 201, + "need_pin": 127, + "parts": [ + 2, + 1, + 1, + 1 + ], + "r": 5, + "root_bracket": [ + "0.0036311023299931297889039321430714127463893063448250376431137150908970940278296343", + "0.0036311023299931297889039321430714127463893083448250376431137150908970940278296343" + ], + "single_split_dk": "0.0000010441553047627029703553781745130737" + }, + { + "available": 68, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3433426679239613655678985923597386461967", + "need_paired": 254, + "need_pin": 160, + "parts": [ + 2, + 2, + 1 + ], + "r": 5, + "root_bracket": [ + "0.0036308845291457525000071360094727393846747545606520611073600555206938008728304198", + "0.0036308845291457525000071360094727393846747565606520611073600555206938008728304198" + ], + "single_split_dk": "8.263544573854140735592445758397120E-7" + }, + { + "available": 68, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3093542056265859877503028030680384820695", + "need_paired": 282, + "need_pin": 177, + "parts": [ + 3, + 1, + 1 + ], + "r": 5, + "root_bracket": [ + "0.0036308027091744660731526713290892599179175697925572211898001693383853229135323274", + "0.0036308027091744660731526713290892599179175717925572211898001693383853229135323274" + ], + "single_split_dk": "7.445344860989872190945641923602452E-7" + }, + { + "available": 68, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.2188861444167479679731002709949630994806", + "need_paired": 398, + "need_pin": 250, + "parts": [ + 3, + 2 + ], + "r": 5, + "root_bracket": [ + "0.0036305849444704963514191085775384692310959583742536101194405600989697874801670342", + "0.0036305849444704963514191085775384692310959603742536101194405600989697874801670342" + ], + "single_split_dk": "5.267697821292654855318126415695584E-7" + }, + { + "available": 68, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.1628612382875668259351978795861379099815", + "need_paired": 535, + "need_pin": 336, + "parts": [ + 4, + 1 + ], + "r": 5, + "root_bracket": [ + "0.0036304501007729833525473642540064493184380850903883033292966469494140612820296293", + "0.0036304501007729833525473642540064493184380870903883033292966469494140612820296293" + ], + "single_split_dk": "3.919260846162666137874891095496458E-7" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.7001731413699679371519753970232503972578", + "need_paired": 125, + "need_pin": 79, + "parts": [ + 1, + 1, + 1, + 1, + 1, + 1 + ], + "r": 6, + "root_bracket": [ + "0.0036317437466421347055746639732801521903227675681616145162374901545055500781408632", + "0.0036317437466421347055746639732801521903227695681616145162374901545055500781408632" + ], + "single_split_dk": "0.0000016855719537676196410872083832525176" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.6097050801601299173747728649501750146689", + "need_paired": 143, + "need_pin": 90, + "parts": [ + 2, + 1, + 1, + 1, + 1 + ], + "r": 6, + "root_bracket": [ + "0.0036315258684368739665475810229415366533816091366572565284063071250862277691688597", + "0.0036315258684368739665475810229415366533816111366572565284063071250862277691688597" + ], + "single_split_dk": "0.0000014676937485068806140042580446369807" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.5192370189502918975975703328770996320799", + "need_paired": 168, + "need_pin": 106, + "parts": [ + 2, + 2, + 1, + 1 + ], + "r": 6, + "root_bracket": [ + "0.0036313080165360049966254958074478837876319663017018528447307062791602203730057189", + "0.0036313080165360049966254958074478837876319683017018528447307062791602203730057189" + ], + "single_split_dk": "0.0000012498418476379106919190425509841150" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.4287689577404538778203678008040242494910", + "need_paired": 204, + "need_pin": 128, + "parts": [ + 2, + 2, + 2 + ], + "r": 6, + "root_bracket": [ + "0.0036310901909347349867446909862827570271408383962299961377766855182059519875432781", + "0.0036310901909347349867446909862827570271408403962299961377766855182059519875432781" + ], + "single_split_dk": "0.0000010320162463679008111142213858573545" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.4852485566529165197799745435853994679527", + "need_paired": 180, + "need_pin": 113, + "parts": [ + 3, + 1, + 1, + 1 + ], + "r": 6, + "root_bracket": [ + "0.0036312261774309386347691538807391288477218165801032488952028105020181283860116446", + "0.0036312261774309386347691538807391288477218185801032488952028105020181283860116446" + ], + "single_split_dk": "0.0000011680027425715488355771158422291750" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3947804954430785000027720115123240853638", + "need_paired": 221, + "need_pin": 139, + "parts": [ + 3, + 2, + 1 + ], + "r": 6, + "root_bracket": [ + "0.0036310083616862377853182671504532769235845227336722570221381269147776824211741820", + "0.0036310083616862377853182671504532769235845247336722570221381269147776824211741820" + ], + "single_split_dk": "9.501869978706993846903855563772509E-7" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.2703239719358651024079736901475485386477", + "need_paired": 323, + "need_pin": 203, + "parts": [ + 3, + 3 + ], + "r": 6, + "root_bracket": [ + "0.0036307087565341924260066224735789030377537691302528753792153420865089221116118715", + "0.0036307087565341924260066224735789030377537711302528753792153420865089221116118715" + ], + "single_split_dk": "6.505818458253400730457086820033651E-7" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3387555893138973579648696201034988958647", + "need_paired": 258, + "need_pin": 162, + "parts": [ + 4, + 1, + 1 + ], + "r": 6, + "root_bracket": [ + "0.0036308734864681253391569534000236449299322345651031393503946014236529855031354264", + "0.0036308734864681253391569534000236449299322365651031393503946014236529855031354264" + ], + "single_split_dk": "8.153117797582532233766351267452573E-7" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.2482875281040593381876670880304235132757", + "need_paired": 351, + "need_pin": 221, + "parts": [ + 4, + 2 + ], + "r": 6, + "root_bracket": [ + "0.0036306557132539521101296015093273768985858758473811214256624768623198982990972759", + "0.0036306557132539521101296015093273768985858778473811214256624768623198982990972759" + ], + "single_split_dk": "5.975385655850241960247444304772259E-7" + }, + { + "available": 42, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.1758943510263305320296717405173609858832", + "need_paired": 496, + "need_pin": 312, + "parts": [ + 5, + 1 + ], + "r": 6, + "root_bracket": [ + "0.0036304814686502379224094636265017659891233164992942300597431823225605701475113208", + "0.0036304814686502379224094636265017659891233184992942300597431823225605701475113208" + ], + "single_split_dk": "4.232939618708364758868616048663164E-7" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.8868985374068043226059788446306347346120", + "need_paired": 99, + "need_pin": 62, + "parts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036321935279326512308293957628391707176556610043820992333881206270826199667931233", + "0.0036321935279326512308293957628391707176556630043820992333881206270826199667931233" + ], + "single_split_dk": "0.0000021353532442841448958189979422710450" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.7964304761969663028287763125575593520230", + "need_paired": 110, + "need_pin": 69, + "parts": [ + 2, + 1, + 1, + 1, + 1, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036319755955098371564758833074404680300071952174370088439301327968626247577632617", + "0.0036319755955098371564758833074404680300071972174370088439301327968626247577632617" + ], + "single_split_dk": "0.0000019174208214700705423065425435683573" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.7059624149871282830515737804844839694341", + "need_paired": 124, + "need_pin": 78, + "parts": [ + 2, + 2, + 1, + 1, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036317576894012784421694145035731238944819195649751420989201477646665590332870999", + "0.0036317576894012784421694145035731238944819215649751420989201477646665590332870999" + ], + "single_split_dk": "0.0000016995147129113562358377386762242218" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.6154943537772902632743712484114085868452", + "need_paired": 142, + "need_pin": 89, + "parts": [ + 2, + 2, + 2, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036315398096021798717533346873099069256519530168919951068399423348498725512469281", + "0.0036315398096021798717533346873099069256519550168919951068399423348498725512469281" + ], + "single_split_dk": "0.0000014816349138127858197579224130072530" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.6719739526897529052339779911927838053069", + "need_paired": 130, + "need_pin": 82, + "parts": [ + 3, + 1, + 1, + 1, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036316758299803296354088410458911690918407313072139933441919660414862206313526255", + "0.0036316758299803296354088410458911690918407333072139933441919660414862206313526255" + ], + "single_split_dk": "0.0000016176552919625494752642809942694192" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.5815058914799148854567754591197084227180", + "need_paired": 150, + "need_pin": 95, + "parts": [ + 3, + 2, + 1, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036314579600414873580388073148412932953323487636300446120817906318038454425980703", + "0.0036314579600414873580388073148412932953323507636300446120817906318038454425980703" + ], + "single_split_dk": "0.0000013997853531202721052305499443936227" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.4910378302700768656795729270466330401290", + "need_paired": 178, + "need_pin": 112, + "parts": [ + 3, + 2, + 2 + ], + "r": 7, + "root_bracket": [ + "0.0036312401164055186529551815019215993845435698271364852739291018902618855578933218", + "0.0036312401164055186529551815019215993845435718271364852739291018902618855578933218" + ], + "single_split_dk": "0.0000011819417171515670216047370246997119" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.4570493679727014878619771377549328760018", + "need_paired": 191, + "need_pin": 120, + "parts": [ + 3, + 3, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036311582803980276522237568006489046035856709203575788474301150359320459131156915", + "0.0036311582803980276522237568006489046035856729203575788474301150359320459131156915" + ], + "single_split_dk": "0.0000011001057096605662901800357520049309" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.5254809853507337434188730677108832332189", + "need_paired": 166, + "need_pin": 105, + "parts": [ + 4, + 1, + 1, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036313230513554090882854513928060643109468943205123217771707057300604557497788401", + "0.0036313230513554090882854513928060643109468963205123217771707057300604557497788401" + ], + "single_split_dk": "0.0000012648766670420023518746279091646383" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.4350129241408957236416705356378078506299", + "need_paired": 201, + "need_pin": 126, + "parts": [ + 4, + 2, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036311052239630239451936008408658509332629191302614870554050575849650827849622402", + "0.0036311052239630239451936008408658509332629211302614870554050575849650827849622402" + ], + "single_split_dk": "0.0000010470492746568592600240759689512606" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3105564006336823260468722142730323039138", + "need_paired": 281, + "need_pin": 177, + "parts": [ + 4, + 3 + ], + "r": 7, + "root_bracket": [ + "0.0036308056028009138803560748995912883302859956597865226466732788358532895492349272", + "0.0036308056028009138803560748995912883302859976597865226466732788358532895492349272" + ], + "single_split_dk": "7.474281125467944224981346943886576E-7" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3626197470631669174836751881247453232374", + "need_paired": 241, + "need_pin": 151, + "parts": [ + 5, + 1, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036309309361368284902422464947730606171717543769268102417906373227353157770879436", + "0.0036309309361368284902422464947730606171717563769268102417906373227353157770879436" + ], + "single_split_dk": "8.727614484614043086697298761609445E-7" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.2721516858533288977064726560516699406485", + "need_paired": 320, + "need_pin": 202, + "parts": [ + 5, + 2 + ], + "r": 7, + "root_bracket": [ + "0.0036307131560174798189146447995998015371795563366109869699148617039968237254760054", + "0.0036307131560174798189146447995998015371795583366109869699148617039968237254760054" + ], + "single_split_dk": "6.549813291127329810680347029018645E-7" + }, + { + "available": 18, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.1867253960368363854540034476073843373542", + "need_paired": 467, + "need_pin": 294, + "parts": [ + 6, + 1 + ], + "r": 7, + "root_bracket": [ + "0.0036305075370372442193601856989467205806091135419733043066055886832328328953148368", + "0.0036305075370372442193601856989467205806091155419733043066055886832328328953148368" + ], + "single_split_dk": "4.493623488771334266089340498209079E-7" + }, + { + "available": 67, + "available_paired": false, + "available_pin": true, + "gain_at_k0": "1.0828908631058422145933342221487898685025", + "need_paired": 81, + "need_pin": 51, + "parts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036326657513721994061064121370656569159555624910231694853811628192939433346029114", + "0.0036326657513721994061064121370656569159555644910231694853811628192939433346029114" + ], + "single_split_dk": "0.0000026075766838323201728353721687572433" + }, + { + "available": 67, + "available_paired": false, + "available_pin": true, + "gain_at_k0": "0.9924228018960041948161316900757144859135", + "need_paired": 88, + "need_pin": 56, + "parts": [ + 2, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036324477620274619117851051581868746279726941036830825386567518232423194326875122", + "0.0036324477620274619117851051581868746279726961036830825386567518232423194326875122" + ], + "single_split_dk": "0.0000023895873390948258515283932899749553" + }, + { + "available": 67, + "available_paired": false, + "available_pin": true, + "gain_at_k0": "0.9019547406861661750389291580026391033246", + "need_paired": 97, + "need_pin": 61, + "parts": [ + 2, + 2, + 1, + 1, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036322297990073352387975287360232846228270252021461539724244414236990045745122105", + "0.0036322297990073352387975287360232846228270272021461539724244414236990045745122105" + ], + "single_split_dk": "0.0000021716243189681528639519711263849501" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.8114866794763281552617266259295637207357", + "need_paired": 108, + "need_pin": 68, + "parts": [ + 2, + 2, + 2, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036320118623070216438802640748417817577903668719626175549854532584339205944874408", + "0.0036320118623070216438802640748417817577903688719626175549854532584339205944874408" + ], + "single_split_dk": "0.0000019536876186545579466873099448820851" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.7210186182664901354845240938564883381467", + "need_paired": 121, + "need_pin": 76, + "parts": [ + 2, + 2, + 2, + 2 + ], + "r": 8, + "root_bracket": [ + "0.0036317939519217245566736164307305754208881997213118775951301370602589348245182172", + "0.0036317939519217245566736164307305754208882017213118775951301370602589348245182172" + ], + "single_split_dk": "0.0000017357772333574707400396658336757482" + }, + { + "available": 67, + "available_paired": false, + "available_pin": true, + "gain_at_k0": "0.8679662783887907972213333687109389391974", + "need_paired": 101, + "need_pin": 64, + "parts": [ + 3, + 1, + 1, + 1, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036321479182571742078647639794115428821155715756952489829547615415636912889965308", + "0.0036321479182571742078647639794115428821155735756952489829547615415636912889965308" + ], + "single_split_dk": "0.0000020897435688071219311872145146432094" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.7774982171789527774441308366378635566085", + "need_paired": 113, + "need_pin": 71, + "parts": [ + 3, + 2, + 1, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036319299914209878979279593687640444006854171355445366467048209947919608384241826", + "0.0036319299914209878979279593687640444006854191355445366467048209947919608384241826" + ], + "single_split_dk": "0.0000018718167326208119943826038671447280" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.6870301559691147576669283045647881740195", + "need_paired": 127, + "need_pin": 80, + "parts": [ + 3, + 2, + 2, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036317120908980246256964788614436052998557496257701483878858468188885371120313454", + "0.0036317120908980246256964788614436052998557516257701483878858468188885371120313454" + ], + "single_split_dk": "0.0000016539162096575397629020965467056272" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.6530416936717393798493325152730880098923", + "need_paired": 134, + "need_pin": 84, + "parts": [ + 3, + 3, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036316302335705094462525989089402117584237641471879510460392973702797740403808265", + "0.0036316302335705094462525989089402117584237661471879510460392973702797740403808265" + ], + "single_split_dk": "0.0000015720588821423603190221440433120857" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.5625736324619013600721299832000126273034", + "need_paired": 155, + "need_pin": 98, + "parts": [ + 3, + 3, + 2 + ], + "r": 8, + "root_bracket": [ + "0.0036314123692158446153279906598326097944172687900857884363851472017235392197688904", + "0.0036314123692158446153279906598326097944172707900857884363851472017235392197688904" + ], + "single_split_dk": "0.0000013541945274775293944138949357101217" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.7214733110497716354062284452290383671094", + "need_paired": 121, + "need_pin": 76, + "parts": [ + 4, + 1, + 1, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036317950475976109537946436735016070631146431057842897730775231234080363758722057", + "0.0036317950475976109537946436735016070631146451057842897730775231234080363758722057" + ], + "single_split_dk": "0.0000017368729092438678610669086047073904" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.6310052498399336156290259131559629845204", + "need_paired": 139, + "need_pin": 87, + "parts": [ + 4, + 2, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036315771633246056385972323379403264655851743621988423530508897178372630774105225", + "0.0036315771633246056385972323379403264655851763621988423530508897178372630774105225" + ], + "single_split_dk": "0.0000015189886362385526636555730434267929" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.5405371886300955958518233810828876019315", + "need_paired": 162, + "need_pin": 102, + "parts": [ + 4, + 2, + 2 + ], + "r": 8, + "root_bracket": [ + "0.0036313593053570750761472074886413410453412780002587041807612004479349962106490185", + "0.0036313593053570750761472074886413410453412800002587041807612004479349962106490185" + ], + "single_split_dk": "0.0000013011306687079902136307237444413727" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.5065487263327202180342275917911874378043", + "need_paired": 172, + "need_pin": 109, + "parts": [ + 4, + 3, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036312774639784481591560938065168080992350059107600758875087064467238263365277500", + "0.0036312774639784481591560938065168080992350079107600758875087064467238263365277500" + ], + "single_split_dk": "0.0000012192892900810732225170416199084266" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3600557589937010562191226683092868657162", + "need_paired": 242, + "need_pin": 152, + "parts": [ + 4, + 4 + ], + "r": 8, + "root_bracket": [ + "0.0036309247632050472367716417352764902791406597881231055164795326372328596444817803", + "0.0036309247632050472367716417352764902791406617881231055164795326372328596444817803" + ], + "single_split_dk": "8.665885166801508380649703795906065E-7" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.5586120727622048094710305656429004571279", + "need_paired": 156, + "need_pin": 98, + "parts": [ + 5, + 1, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036314028301200605769230014836718686568282203220501272962688801399462473875489693", + "0.0036314028301200605769230014836718686568282223220501272962688801399462473875489693" + ], + "single_split_dk": "0.0000013446554316934909894247187749689841" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.4681440115523667896938280335698250745390", + "need_paired": 187, + "need_pin": 117, + "parts": [ + 5, + 2, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036311849931386666120997055903639326923574619331987204826932480663099210155775097", + "0.0036311849931386666120997055903639326923574639331987204826932480663099210155775097" + ], + "single_split_dk": "0.0000011268184502995261661288254670330197" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3436874880451533920990297122050495278228", + "need_paired": 254, + "need_pin": 160, + "parts": [ + 5, + 3 + ], + "r": 8, + "root_bracket": [ + "0.0036308853587962009854521239891902169192956381012505073349168579311475640889266268", + "0.0036308853587962009854521239891902169192956401012505073349168579311475640889266268" + ], + "single_split_dk": "8.271841078338995185472242933172466E-7" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.3827177217358742774413588251255394712447", + "need_paired": 228, + "need_pin": 143, + "parts": [ + 6, + 1, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036309793206385807932117794211280718174295573230995742028790258299645173332290471", + "0.0036309793206385807932117794211280718174295593230995742028790258299645173332290471" + ], + "single_split_dk": "9.211459502137072782026562311721448E-7" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.2922496605260362576641562930524640886557", + "need_paired": 298, + "need_pin": 188, + "parts": [ + 6, + 2 + ], + "r": 8, + "root_bracket": [ + "0.0036307615347053865980997976077131825382864556594812412867798672328974214442701759", + "0.0036307615347053865980997976077131825382864576594812412867798672328974214442701759" + ], + "single_split_dk": "7.033600170195121662208428162828656E-7" + }, + { + "available": 67, + "available_paired": false, + "available_pin": false, + "gain_at_k0": "0.1959923256990378919873553775181551338905", + "need_paired": 445, + "need_pin": 280, + "parts": [ + 7, + 1 + ], + "r": 8, + "root_bracket": [ + "0.0036305298411732837613678907420751125678489064182358878738330130407617302908208368", + "0.0036305298411732837613678907420751125678489084182358878738330130407617302908208368" + ], + "single_split_dk": "4.716664849166754343139771782128952E-7" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "1.2869812540180975591384085623770641575541", + "need_paired": 68, + "need_pin": 43, + "parts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036331576170332184219442971776466967733380289873700743409002066834882549231924656", + "0.0036331576170332184219442971776466967733380309873700743409002066834882549231924656" + ], + "single_split_dk": "0.0000030994423448513360107204127497971007" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "1.1965131928082595393612060303039887749651", + "need_paired": 73, + "need_pin": 46, + "parts": [ + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036329395683982883280496029346491063560391735589600754192000005046909454422690098", + "0.0036329395683982883280496029346491063560391755589600754192000005046909454422690098" + ], + "single_split_dk": "0.0000028813937099212421160261697522066834" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "1.1060451315984215195840034982309133923762", + "need_paired": 79, + "need_pin": 50, + "parts": [ + 2, + 2, + 1, + 1, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036327215460987554978429560509450748840629259600223476462825986348792528928679019", + "0.0036327215460987554978429560509450748840629279600223476462825986348792528928679019" + ], + "single_split_dk": "0.0000026633714103884119093792860481752114" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "1.0155770703885834998068009661578380097873", + "need_paired": 86, + "need_pin": 54, + "parts": [ + 2, + 2, + 2, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036325035501298195557372126408322978695687009246323052081865951706021046574309312", + "0.0036325035501298195557372126408322978695687029246323052081865951706021046574309312" + ], + "single_split_dk": "0.0000024453754414524698036358759353981969" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.9251090091787454800295984340847626271983", + "need_paired": 95, + "need_pin": 60, + "parts": [ + 2, + 2, + 2, + 2, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036322855804866812998567117283059141216930079790454388204560719444019093319885069", + "0.0036322855804866812998567117283059141216930099790454388204560719444019093319885069" + ], + "single_split_dk": "0.0000022274057983142139231349634090144490" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "1.0720566693010461417664077089392132282490", + "need_paired": 82, + "need_pin": 52, + "parts": [ + 3, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036326396431319952121884275931826853130236326240167670987390225415898576021165230", + "0.0036326396431319952121884275931826853130236346240167670987390225415898576021165230" + ], + "single_split_dk": "0.0000025814684436281262548508282857856403" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.9815886080912081219892051768661378456601", + "need_paired": 89, + "need_pin": 56, + "parts": [ + 3, + 2, + 1, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036324216570312186447031519545032783084316062301840134268284358379371633968173967", + "0.0036324216570312186447031519545032783084316082301840134268284358379371633968173967" + ], + "single_split_dk": "0.0000023634823428515587695751896063786358" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.8911205468813701022120026447930624630711", + "need_paired": 98, + "need_pin": 62, + "parts": [ + 3, + 2, + 2, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036322036972544453117726128007943312636852619801030262443725774378755950688825506", + "0.0036322036972544453117726128007943312636852639801030262443725774378755950688825506" + ], + "single_split_dk": "0.0000021455225660782258390360358974315910" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.8006524856715320824348001127199870804822", + "need_paired": 109, + "need_pin": 69, + "parts": [ + 3, + 2, + 2, + 2 + ], + "r": 9, + "root_bracket": [ + "0.0036319857637968776225895978913120760588725198236868020404378436874312500321548942", + "0.0036319857637968776225895978913120760588725218236868020404378436874312500321548942" + ], + "single_split_dk": "0.0000019275891085105366560211264151763862" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.8571320845839947243944068555013622989439", + "need_paired": 102, + "need_pin": 64, + "parts": [ + 3, + 3, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036321218177199012956830684912253657458378053972389931132812607231597965552096218", + "0.0036321218177199012956830684912253657458378073972389931132812607231597965552096218" + ], + "single_split_dk": "0.0000020636430315342097494917263284660732" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.7666640233741567046172043234282869163550", + "need_paired": 114, + "need_pin": 72, + "parts": [ + 3, + 3, + 2, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036319038941262337310300157288089838499401189908891627736851670807218409706876262", + "0.0036319038941262337310300157288089838499401209908891627736851670807218409706876262" + ], + "single_split_dk": "0.0000018457194378666450964389639120841773" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.6422074998669433070224060020635113696389", + "need_paired": 136, + "need_pin": 86, + "parts": [ + 3, + 3, + 3 + ], + "r": 9, + "root_bracket": [ + "0.0036316041407327446221416634717613669488348583423618067017022651048222321634501474", + "0.0036316041407327446221416634717613669488348603423618067017022651048222321634501474" + ], + "single_split_dk": "0.0000015459660443775362080867068644672762" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.9255637019620269799513027854573126561610", + "need_paired": 95, + "need_pin": 60, + "parts": [ + 4, + 1, + 1, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036322866766086863658229874192364664841977291672869892526917146435492639466025721", + "0.0036322866766086863658229874192364664841977311672869892526917146435492639466025721" + ], + "single_split_dk": "0.0000022285019203192798894106543395668115" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.8350956407521889601741002533842372735720", + "need_paired": 105, + "need_pin": 66, + "parts": [ + 4, + 2, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036320687330885106640768394715071149327980784061849967858933694293816468176086639", + "0.0036320687330885106640768394715071149327980804061849967858933694293816468176086639" + ], + "single_split_dk": "0.0000020105584001435781432627066102152601" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.7446275795423509403968977213111618909831", + "need_paired": 117, + "need_pin": 74, + "parts": [ + 4, + 2, + 2, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036318508158845856656553334611449371735011618885042681419078878492354058373119886", + "0.0036318508158845856656553334611449371735011638885042681419078878492354058373119886" + ], + "single_split_dk": "0.0000017926411962185797217566962480375008" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.7106391172449755625793019320194617268559", + "need_paired": 123, + "need_pin": 77, + "parts": [ + 4, + 3, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036317689523054416221139656971321573581963797626704578150462960415616366683446246", + "0.0036317689523054416221139656971321573581963817626704578150462960415616366683446246" + ], + "single_split_dk": "0.0000017107776170745361803889322352576855" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.6201710560351375428020993999463863442670", + "need_paired": 141, + "need_pin": 89, + "parts": [ + 4, + 3, + 2 + ], + "r": 9, + "root_bracket": [ + "0.0036315510712739737549334403456945659197460559223005482876959979276630935387475536", + "0.0036315510712739737549334403456945659197460579223005482876959979276630935387475536" + ], + "single_split_dk": "0.0000014928965856066689998635807976662471" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.5641461499059564007641970085375611547679", + "need_paired": 155, + "need_pin": 97, + "parts": [ + 4, + 4, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036314161557377749919906091190842876815209892817342266655899452002953453435004139", + "0.0036314161557377749919906091190842876815209912817342266655899452002953453435004139" + ], + "single_split_dk": "0.0000013579810494079060570323541873880088" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.7627024636744601540161049058711747461795", + "need_paired": 115, + "need_pin": 72, + "parts": [ + 5, + 1, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036318943526176952894757384826350938608176169793201955728002131488621017236964081", + "0.0036318943526176952894757384826350938608176189793201955728002131488621017236964081" + ], + "single_split_dk": "0.0000018361779293282035421617177381941881" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.6722344024646221342389023737980993635906", + "need_paired": 130, + "need_pin": 82, + "parts": [ + 5, + 2, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036316764564084788580482560869596494855045392710411624811575545629347218547652770", + "0.0036316764564084788580482560869596494855045412710411624811575545629347218547652770" + ], + "single_split_dk": "0.0000016182817201117721146793220627498128" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.5817663412547841144616998417250239810016", + "need_paired": 150, + "need_pin": 95, + "parts": [ + 5, + 2, + 2 + ], + "r": 9, + "root_bracket": [ + "0.0036314585865069025362908789034233882248177670550859682738009800543852137812070195", + "0.0036314585865069025362908789034233882248177690550859682738009800543852137812070195" + ], + "single_split_dk": "0.0000014004118185354503573021385264885521" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.5477778789574087366441040524333238168744", + "need_paired": 159, + "need_pin": 100, + "parts": [ + 5, + 3, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036313767406556773031288206660948068591296880800054227153980472390662773447696787", + "0.0036313767406556773031288206660948068591296900800054227153980472390662773447696787" + ], + "single_split_dk": "0.0000013185659673102171952439011979071865" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.4012849116183895748289991289514232447864", + "need_paired": 218, + "need_pin": 137, + "parts": [ + 5, + 4 + ], + "r": 9, + "root_bracket": [ + "0.0036310240205831393455701956841111494355852762281985609672786485933388971727030539", + "0.0036310240205831393455701956841111494355852782281985609672786485933388971727030539" + ], + "single_split_dk": "9.658458947722596366189192142497629E-7" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.5868081126481296219864331653538137602963", + "need_paired": 149, + "need_pin": 94, + "parts": [ + 6, + 1, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036314707281619087567855588254784536986655188745236776405250608001926557997191275", + "0.0036314707281619087567855588254784536986655208745236776405250608001926557997191275" + ], + "single_split_dk": "0.0000014125534735416708519820605815540260" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.4963400514382916022092306332807383777074", + "need_paired": 176, + "need_pin": 111, + "parts": [ + 6, + 2, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036312528830217702073870013421725852484199013974918486653262164513576645176359735", + "0.0036312528830217702073870013421725852484199033974918486653262164513576645176359735" + ], + "single_split_dk": "0.0000011947083334031214534245772756855757" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.3718835279310782046144323119159628309912", + "need_paired": 235, + "need_pin": 148, + "parts": [ + 6, + 3 + ], + "r": 9, + "root_bracket": [ + "0.0036309532374648883184187011772836030223461441261023710945388311652659480181262537", + "0.0036309532374648883184187011772836030223461461261023710945388311652659480181262537" + ], + "single_split_dk": "8.950627765212324851244123867033497E-7" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.4000827166112932365324297177464294229421", + "need_paired": 218, + "need_pin": 137, + "parts": [ + 7, + 1, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036310211267076037181422279116408036712564370585704140990891034966613866648611567", + "0.0036310211267076037181422279116408036712564390585704140990891034966613866648611567" + ], + "single_split_dk": "9.629520192366322086511467439039986E-7" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.3096146554014552167552271856733540403532", + "need_paired": 282, + "need_pin": 177, + "parts": [ + 7, + 2 + ], + "r": 9, + "root_bracket": [ + "0.0036308033357522986522655609803982810834533660458385124924288209739764798654359577", + "0.0036308033357522986522655609803982810834533680458385124924288209739764798654359577" + ], + "single_split_dk": "7.451610639315663319842155013814108E-7" + }, + { + "available": 595, + "available_paired": true, + "available_pin": true, + "gain_at_k0": "0.2040903909122553445450743402282742890516", + "need_paired": 427, + "need_pin": 269, + "parts": [ + 8, + 1 + ], + "r": 9, + "root_bracket": [ + "0.0036305493322469783261698386279845500505749687430294045776856152827331003032928530", + "0.0036305493322469783261698386279845500505749707430294045776856152827331003032928530" + ], + "single_split_dk": "4.911575586112402362618630876503779E-7" + } + ], + "fixed_rank9_fields": 416, + "full_split_margin_at_one": 24040, + "helpers": { + "1": 13, + "2": 18, + "3": 44, + "4": 215, + "5": 68, + "6": 42, + "7": 18, + "8": 67, + "9": 595 + }, + "inputs": { + "FULL-RESULT.json": "d9ba709fa5dcefffe3f3abdcf34600ce188224703cfd743e6db8b58ba4816cb7", + "bit-admission.json": "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b" + }, + "kappa0": "0.0036300581746883670859335767648968996727", + "kappa0_bracket": [ + "0.0036300581746883670859335767648968996726793123388562630916210937558007815791965409", + "0.0036300581746883670859335767648968996726793143388562630916210937558007815791965409" + ], + "ladder": [ + { + "gain": "0E-40", + "kappa": "0.0036300581746883670859335767648968996727", + "m": 1, + "root_bracket": [ + "0.0036300581746883670859335767648968996726793123388562630916210937558007815791965409", + "0.0036300581746883670859335767648968996726793143388562630916210937558007815791965409" + ] + }, + { + "gain": "0.0010592284189957468269954731112103544484", + "kappa": "0.0046892865936841139129290498761072541211", + "m": 2, + "root_bracket": [ + "0.0046892865936841139129290498761072541210785511668093202026988527903420364343564252", + "0.0046892865936841139129290498761072541210785531668093202026988527903420364343564252" + ] + }, + { + "gain": "0.0020236738120918657529360882208137478615", + "kappa": "0.0056537319867802328388696649857106475342", + "m": 3, + "root_bracket": [ + "0.0056537319867802328388696649857106475342242923594202293496884135587866816084152979", + "0.0056537319867802328388696649857106475342242943594202293496884135587866816084152979" + ] + }, + { + "gain": "0.0029578597200257392768192944701103727894", + "kappa": "0.0065879178947141063627528712350072724621", + "m": 4, + "root_bracket": [ + "0.0065879178947141063627528712350072724620518977436149215161536393661653633616722837", + "0.0065879178947141063627528712350072724620518997436149215161536393661653633616722837" + ] + }, + { + "gain": "0.0037837436910360527878108202437564062625", + "kappa": "0.0074138018657244198737443970086533059352", + "m": 5, + "root_bracket": [ + "0.0074138018657244198737443970086533059352163012262238964335530106501767625968364694", + "0.0074138018657244198737443970086533059352163032262238964335530106501767625968364694" + ] + }, + { + "gain": "0.0045146160341083424021623331672796974869", + "kappa": "0.0081446742087967094880959099321765971596", + "m": 6, + "root_bracket": [ + "0.0081446742087967094880959099321765971596274828337823857194052270026856092652229343", + "0.0081446742087967094880959099321765971596274848337823857194052270026856092652229343" + ] + }, + { + "gain": "0.0053523143504325374159175957901653647565", + "kappa": "0.0089823725251209045018511725550622644292", + "m": 7, + "root_bracket": [ + "0.0089823725251209045018511725550622644292014533974656585825913796502627803828560193", + "0.0089823725251209045018511725550622644292014553974656585825913796502627803828560193" + ] + }, + { + "gain": "0.0063582033694747755253538897502306101445", + "kappa": "0.0099882615441631426112874665151275098172", + "m": 8, + "root_bracket": [ + "0.0099882615441631426112874665151275098171914737838907518750478224969230227395738845", + "0.0099882615441631426112874665151275098171914757838907518750478224969230227395738845" + ] + }, + { + "gain": "0.0074852984734168317239908490046282095066", + "kappa": "0.0111153566481051988099244257695251091792", + "m": 9, + "root_bracket": [ + "0.011115356648105198809924425769525109179247986145785192105376298125264263714240760", + "0.011115356648105198809924425769525109179247988145785192105376298125264263714240760" + ] + } + ], + "lemma_partition_checks": 436, + "min_touched": { + "paired_any": { + "helpers": 68, + "plan": [ + [ + 9, + 68 + ] + ] + }, + "paired_binary": { + "helpers": 218, + "plan": [ + [ + 9, + 218 + ] + ] + }, + "pin_any": { + "helpers": 43, + "plan": [ + [ + 9, + 43 + ] + ] + }, + "pin_binary": { + "helpers": 137, + "plan": [ + [ + 9, + 137 + ] + ] + } + }, + "numeric_error_bound": "1e-39", + "verifier_sha256": { + "intervals.py": "3d876b3e0a8589cdb8eb16e749e531b9ece04d6c1387df6eb7f27730846ac1f4", + "verify.py": "e37cff87b70c52df45f59465f0607c59d6a94704c5a4f61b9699d3fbfbf2ff53" + }, + "wall_margin_F": { + "paired": "-92.3927683626391439562416693993238103048527", + "pin": "-56.7661715024831636841231888993000674098476" + }, + "walls": { + "paired": "0.0038524800000000000000000000000000000000", + "pin": "0.0037666900000000000000000000000000000000" + } +} diff --git a/research/helper-split-headroom-ladder/SOURCES.json b/research/helper-split-headroom-ladder/SOURCES.json new file mode 100644 index 0000000000..dac252d781 --- /dev/null +++ b/research/helper-split-headroom-ladder/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/shared-wire-split-composition/FULL-RESULT.json", + "usage": "input", + "git_blob": "ff3256f0d3ffbfc56b062f9ec0fdbbc7b30e76d5", + "sha256": "d9ba709fa5dcefffe3f3abdcf34600ce188224703cfd743e6db8b58ba4816cb7" + }, + { + "path": "research/shared-wire-split-composition/data/bit-admission.json", + "usage": "input", + "git_blob": "575f76487f9999ecc3e7b1b70f9f71bc582ef8a8", + "sha256": "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b" + } + ] +} diff --git a/research/helper-split-headroom-ladder/TASK.json b/research/helper-split-headroom-ladder/TASK.json new file mode 100644 index 0000000000..42987b469a --- /dev/null +++ b/research/helper-split-headroom-ladder/TASK.json @@ -0,0 +1,135 @@ +{ + "schema_version": 1, + "task_id": "selected-packing", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "selected-packing", + "question": "Is there meaningful uncovered packing headroom for an exact current word and boundary contract?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Check live overlap and exact model/source binding first. Distinguish a chronological construction from a pooled optimum. State the applicable fixed-inventory ceiling and remaining headroom; changed words or interfaces require a new fully charged model. Do not launch a residual search without an explicit scope and time cap.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Derive or authenticate a ceiling for the exact current paid/target inventory before searching. Old #1240/#4091 caps do not constrain #5599 automatically. Require an unclaimed domain, time cap and useful complete margin. Stop at the applicable ceiling; change the word or boundary instead of adding seeds.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing", + "4091", + "4088", + "staged-fourth-mixture-ceiling", + "staged544-mixed-fourth-entry" + ], + "existing_checks": [ + { + "scope": "PR #4091: pooled optimum at one-third staging for pinned fixed words; not a chronological fill.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Independent scope/source check; any residual optimization is explicitly bounded and optional.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4088: later 1090-call literal fill improves the earlier 1080-call witness.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Complete admission remains separate; old residual-bin instructions must not be copied blindly.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Exact first-crossing ceilings and helper-split exchange rates for the fixed paid and main-origin target profiles of selected #7000, on 0 <= kappa <= 0.02.", + "scope_change_reason": "The assigned packing card is narrowed to an optimistic accounting theorem. Legal split construction and complete supplier admission are outside this result.", + "bottleneck_link": "Quantify the rank-splitting credit available before searching for legal helper cuts; compare the exact selected wrapper price and the paired BIT ordinary price without treating either as an admitted complex improvement.", + "budget_minutes": 60, + "stop_rule": "Ship the fixed-profile ladder, all rank-2..9 single-helper partitions and the stock-constrained thresholds after exact interval verification. Do not extend to new words or paid-cost models.", + "outcome": "completed", + "evidence": "README.md written proof; RESULT.json hash-bound root brackets and finite exchange/minimum certificates; verify.py and intervals.py.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Which rank-nine helpers admit legal 5+4 splits with no added paid rank?", + "why_it_matters": "The relaxed threshold for the fixed complex wrapper price is 137 touched helpers.", + "first_step": "Give one exact prefix/suffix and boundary witness with a complete cost ledger.", + "blocked_by": "Literal pivot availability, restoration and any shared correction costs." + }, + { + "question": "What ceilings hold for an exact successor paid profile and caller?", + "why_it_matters": "The present theorem is source-specific and does not apply automatically to newer construction proposals.", + "first_step": "Extract a source-bound helper-origin decomposition from a successor invoice before reusing the optimization.", + "blocked_by": "A changed paid/target invoice and its precise split contract." + } + ], + "claim_type": "scoped written proof with exact finite certificates", + "claim_interval": [ + "0", + "0.02" + ], + "environment": { + "interpreter": "3.12.15 (main, Oct 14 2026, 00:55:37) [Clang 23.1.3 ]", + "reproduction_interpreter": "~/git/integer-mult-bounds/.venv/bin/python3.12", + "dependencies": "Python standard library" + }, + "upstream_checkpoint": { + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "priority_revision": 8, + "checked_at": "2026-11-11T08:03:18.681948+00:00" + }, + "overlap": { + "open_pr_snapshot_records": 468, + "discussion_snapshot_records": 7089, + "complete_remote_pagination": true, + "local_sparse_coverage": "Generic helper omitted 10001 HEAD note paths; additional git grep searched all main README blobs for distinctive formulas and terms. No matches is not proof of novelty.", + "related_general_theorems": [ + "#5554 fixed-local-bill path ceiling", + "#6651 classical balanced-partition optimum with a uniform fee" + ], + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19530156", + "own_recent_checked": [ + 7168, + 7167, + 7135, + 7134, + 7133, + 7132 + ] + }, + "progress_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19537529" +} diff --git a/research/helper-split-headroom-ladder/VERIFY.json b/research/helper-split-headroom-ladder/VERIFY.json new file mode 100644 index 0000000000..15778ccf23 --- /dev/null +++ b/research/helper-split-headroom-ladder/VERIFY.json @@ -0,0 +1,35 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/shared-wire-split-composition/FULL-RESULT.json", + "research/shared-wire-split-composition/data/bit-admission.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact outward root/slope certificates; all 87 nontrivial partitions; independent partition enumeration and integer-power oracle; minimal wall counts and six controls." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "The same scientific certificates and controls with assertions disabled." + } + ] +} diff --git a/research/helper-split-headroom-ladder/intervals.py b/research/helper-split-headroom-ladder/intervals.py new file mode 100644 index 0000000000..898ace38af --- /dev/null +++ b/research/helper-split-headroom-ladder/intervals.py @@ -0,0 +1,117 @@ +"""Outward integer intervals, scaled by 10**70, for ranks at most 145. + +No transcendental library call participates in a certificate. Decimal values +used by the caller only nominate rational points for these checks. +""" +from fractions import Fraction + +Q = 10**70 +LOG_TERMS = 100 +EXP_TERMS = 80 + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def ceiling(a, b): + return -(-a // b) + + +def rational(x): + value = Fraction(x) + return value.numerator * Q // value.denominator, ceiling(value.numerator * Q, value.denominator) + + +def add(a, b): + return a[0] + b[0], a[1] + b[1] + + +def scale(a, n): + return (a[0] * n, a[1] * n) if n >= 0 else (a[1] * n, a[0] * n) + + +def multiply(a, b): + require(0 <= a[0] <= a[1] and 0 <= b[0] <= b[1], "nonnegative factors required") + return a[0] * b[0] // Q, ceiling(a[1] * b[1], Q) + + +def log_unit(value): + """2 atanh z, z=(value-1)/(value+1), 1 <= value <= 2.""" + require(1 <= value <= 2, "log range reduction") + z = (value - 1) / (value + 1) + total, power = Fraction(0), z + for j in range(LOG_TERMS): + total += 2 * power / (2 * j + 1) + power *= z * z + tail = 2 * power / ((2 * LOG_TERMS + 1) * (1 - z * z)) + return rational(total)[0], rational(total + tail)[1] + + +def log_rank(rank): + require(isinstance(rank, int) and 1 <= rank <= 145, "rank outside 1..145") + shift = rank.bit_length() - 1 + return add(scale(log_unit(Fraction(2)), shift), log_unit(Fraction(rank, 2**shift))) + + +def exp_small(x): + """exp(x) for 0 <= x <= 1/8, with an explicit geometric tail.""" + require(0 <= x[0] <= x[1] <= Q // 8, "exponential argument outside 0..1/8") + term, total = (Q, Q), (Q, Q) + for j in range(1, EXP_TERMS + 1): + term = term[0] * x[0] // (Q * j), ceiling(term[1] * x[1], Q * j) + total = add(total, term) + next_upper = ceiling(term[1] * x[1], Q * (EXP_TERMS + 1)) + # All subsequent term ratios are <= 1/(8*82) < 1/2. + return total[0], total[1] + 2 * next_upper + + +def power(rank, log, k): + """rank**(1-k) = rank/exp(k*log(rank)).""" + denominator = exp_small(multiply(k, log)) + return rank * Q * Q // denominator[1], ceiling(rank * Q * Q, denominator[0]) + + +class Oracle: + def __init__(self, ranks): + require(len(ranks) <= 145, "too many ranks") + self.logs = {r: log_rank(r) for r in ranks} + + def powers(self, low, high=None): + lo, hi = rational(low), rational(low if high is None else high) + require(0 <= lo[0] <= hi[1] <= Q // 50, "k outside 0..0.02") + k = lo[0], hi[1] + return {r: power(r, log, k) for r, log in self.logs.items()} + + def moment(self, coefficients, low, high=None, derivative=False): + powers, total = self.powers(low, high), (0, 0) + for r, n in coefficients.items(): + value = multiply(powers[r], self.logs[r]) if derivative else powers[r] + total = add(total, scale(value, n)) + return total + + def certify(self, coefficients): + """Certify -F' > 0 by a Lipschitz grid on [0,1/50].""" + bound = sum(abs(n) * r * multiply(log, log)[1] + for r, n in coefficients.items() for log in [self.logs[r]]) + step = Fraction(1, 500) + error = ceiling(bound, 500) + for j in range(11): + require(self.moment(coefficients, j * step, derivative=True)[0] > error, + "slope interval does not prove monotonicity") + require(self.moment(coefficients, 0)[0] > 0, "initial margin not positive") + require(self.moment(coefficients, Fraction(1, 50))[1] < 0, "final margin not negative") + + def bracket(self, coefficients, low, high): + require(Fraction(low) < Fraction(high), "reversed root bracket") + require(self.moment(coefficients, low)[0] > 0, "lower root endpoint not positive") + require(self.moment(coefficients, high)[1] < 0, "upper root endpoint not negative") + + +def close(interval, approximation): + """The printed approximation has absolute error less than 10**-39.""" + middle = rational(approximation) + error = Q // 10**39 + require(middle[1] - error < interval[0] <= interval[1] < middle[0] + error, + "approximation outside certified error bound") diff --git a/research/helper-split-headroom-ladder/verify.py b/research/helper-split-headroom-ladder/verify.py new file mode 100644 index 0000000000..840467be64 --- /dev/null +++ b/research/helper-split-headroom-ladder/verify.py @@ -0,0 +1,377 @@ +"""Helper-split headroom ladder on the selected #7000 invoice (standard library only). + +Model. For productive-target counts T_r and paid-child counts P_r by rank r, +the raw margin is F(k) = sum_r (T_r - P_r) r^(1-k), and the raw crossing is +its first root in k. The pinned invoice stores that crossing, and this file +recomputes it from T and P (a calibration of the model, not a review of the +source construction). + +Helper structure read from the pinned data: every helper of rank r supplies +18 productive fields of rank r (T_r = 18 h_r for r <= 8 and T_9 = 18 h_9 + 416). +The 416 further rank-9 fields and every field of rank >= 16 are held fixed. +Splitting one helper into parts (a_i) changes F by 18 (sum a_i^p - r^p), p = 1 - k. + +Usage: verify.py check everything and compare with RESULT.json + verify.py --emit print the generated receipt (redirect to RESULT.json) +""" +import hashlib +import json +import pathlib +import sys +from decimal import Decimal, getcontext +from fractions import Fraction +from itertools import combinations_with_replacement +from intervals import Oracle, Q, close + +HERE = pathlib.Path(__file__).resolve().parent +SRC = HERE.parent / "shared-wire-split-composition" +FULL = SRC / "FULL-RESULT.json" +BIT = SRC / "data" / "bit-admission.json" +RESULT = HERE / "RESULT.json" +FULL_SHA = "d9ba709fa5dcefffe3f3abdcf34600ce188224703cfd743e6db8b58ba4816cb7" +BIT_SHA = "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b" + +getcontext().prec = 80 +FIELDS = 18 # productive fields per helper (checked against the data) +KMAX = Decimal("0.02") # all certificates live on [0, KMAX] +EPS = Decimal("1e-45") # half-width of every root bracket +NEWTON_CAP = 60 +RANK_CAP = 9 # helpers have ranks 1..9 +DIGITS = Decimal("1e-40") + + +def fail(msg): + raise SystemExit("FAIL: " + msg) + + +def check(cond, msg): + if not cond: + fail(msg) + + +# ---------------------------------------------------------------- inputs +def read_pinned(path, sha): + check(path.stat().st_size <= 1000000, "input exceeds the one-megabyte limit") + raw = path.read_bytes() + check(hashlib.sha256(raw).hexdigest() == sha, "pinned input hash: " + path.name) + return json.loads(raw) + + +def int_map(d): + return {int(k): int(v) for k, v in d.items()} + + +def load_invoice(full): + """T, P, helper counts, with the 18-field structure checked.""" + inv = full["invoice"] + T, P, H = int_map(inv["T"]), int_map(inv["P"]), int_map(full["native"]["helpers"]) + check(sorted(H) == list(range(1, RANK_CAP + 1)), "helper ranks are 1..9") + for r in range(1, RANK_CAP): + check(T[r] == FIELDS * H[r], "18 fields per helper at rank %d" % r) + extra = T[RANK_CAP] - FIELDS * H[RANK_CAP] + check(extra == 416, "416 rank-9 fields beyond the helpers") + check(all(r > RANK_CAP for r in T if r not in H), "fixed fields have rank > 9") + mass = sum(r * n for r, n in T.items()) - sum(r * n for r, n in P.items()) + check(mass == int(inv["S"]) == 1520, "surplus S = sum r (T_r - P_r)") + return T, P, H, extra + + +def frac(text): + num, _, den = text.partition("/") + return Fraction(int(num), int(den or 1)) + + +# ------------------------------------------------------- margin arithmetic +class Model: + """Logarithm table for a fixed rank set; everything else is a pure function.""" + + def __init__(self, ranks): + self.ln = {r: Decimal(r).ln() for r in ranks} + self.oracle = Oracle(ranks) + + def margin(self, c, k): + p = 1 - k + return sum(n * (p * self.ln[r]).exp() for r, n in c.items() if n) + + def slope(self, c, k): + """G(k) = -F'(k) = sum c_r r^(1-k) ln r.""" + p = 1 - k + return sum(n * (p * self.ln[r]).exp() * self.ln[r] for r, n in c.items() if n) + + def certify(self, c): + """F strictly decreasing on [0, KMAX], F(0) > 0 > F(KMAX): unique root.""" + self.oracle.certify(c) + + def root(self, c): + """Certified root of F on [0, KMAX] by Newton with a sign bracket.""" + self.certify(c) + k = Decimal("0.004") + for _ in range(NEWTON_CAP): + step = self.margin(c, k) / self.slope(c, k) + k += step + if abs(step) < Decimal("1e-60"): + break + check(0 < k < KMAX, "Newton left the interval") + self.oracle.bracket(c, k - EPS, k + EPS) + return k + + +def invoice_diff(T, P): + c = {r: T.get(r, 0) - P.get(r, 0) for r in set(T) | set(P)} + return {r: n for r, n in c.items() if n} + + +# ------------------------------------------------------------- partitions +def partitions_table(nmax): + """All integer partitions of n <= nmax (coin-change enumeration, no recursion).""" + table = [[()] if n == 0 else [] for n in range(nmax + 1)] + for s in range(1, nmax + 1): + for n in range(s, nmax + 1): + table[n] = table[n] + [q + (s,) for q in table[n - s]] + return [[tuple(sorted(q, reverse=True)) for q in row] for row in table] + + +def balanced(r, m): + """Balanced partition of r into min(m, r) parts.""" + parts = min(m, r) + q, rem = divmod(r, parts) + return tuple([q + 1] * rem + [q] * (parts - rem)) + + +def majorizes(lam, mu, width): + """Exact integer test: sorted lam majorizes sorted mu (zero padded).""" + a = list(lam) + [0] * (width - len(lam)) + b = list(mu) + [0] * (width - len(mu)) + sa = sb = 0 + for x, y in zip(a, b): + sa, sb = sa + x, sb + y + if sa < sb: + return False + return sa == sb + + +def check_balanced_lemma(table): + """Every partition with <= m parts majorizes the balanced m-part one.""" + count = 0 + for r in range(1, RANK_CAP + 1): + independent = {tuple(reversed(parts)) + for length in range(1, r + 1) + for parts in combinations_with_replacement(range(1, r + 1), length) + if sum(parts) == r} + check(len(table[r]) == len(set(table[r])) and set(table[r]) == independent, + "partition enumeration agrees with independent combinations") + for r in range(2, RANK_CAP + 1): + for m in range(1, r + 1): + bal = balanced(r, m) + for lam in table[r]: + if len(lam) <= m: + check(majorizes(lam, bal, m), "balanced partition is minimal") + count += 1 + return count + + +# ----------------------------------------------------------- scenarios +def apply_split(T, r, lam, times): + """Split `times` helpers of rank r into the parts lam (18 fields each).""" + out = dict(T) + out[r] -= FIELDS * times + for a in lam: + out[a] = out.get(a, 0) + FIELDS * times + return out + + +def split_all(T, H, m): + """Every helper of rank >= 2 into its balanced m-part partition.""" + out = dict(T) + for r in range(2, RANK_CAP + 1): + out = apply_split(out, r, balanced(r, m), H[r]) + return out + + +def gain(lam, r, p, model): + value = FIELDS * (sum((p * model.ln[a]).exp() for a in lam) - (p * model.ln[r]).exp()) + coefficients = {r: -FIELDS} + for a in lam: + coefficients[a] = coefficients.get(a, 0) + FIELDS + close(model.oracle.moment(coefficients, 1 - p - EPS, 1 - p + EPS), q(value)) + return value + + +def ceil_div(num, den): + q = num / den + n = int(q) + return n if n >= q else n + 1 + + +# ------------------------------------------------------------- receipt +def q(x): + return str(x.quantize(DIGITS)) + + +def build(full, bit): + T, P, H, extra = load_invoice(full) + ranks = sorted(set(T) | set(P) | set(range(1, RANK_CAP + 1))) + model = Model(ranks) + # Independent integer-power test of every rank's enclosure at k=1/100. + for r, (low, high) in model.oracle.powers(Fraction(1, 100)).items(): + exact = r**99 * Q**100 + check(low**100 <= exact <= high**100, "rational-exponent control") + c0 = invoice_diff(T, P) + k0 = model.root(c0) + stored = Decimal(full["invoice"]["raw_crossing"]) + check(abs(stored - k0) < Decimal("1e-60"), "stored raw crossing reproduced") + pin = frac(full["gate"]["BIT_pin"]) + paired = frac(bit["ordinary_admitted"]) + check(pin == Fraction(376669, 10 ** 8) and paired == Fraction(12039, 3125000), "wall values") + walls = {"pin": Decimal(pin.numerator) / Decimal(pin.denominator), + "paired": Decimal(paired.numerator) / Decimal(paired.denominator)} + for w in walls.values(): + close(model.oracle.moment(c0, w), q(model.margin(c0, w))) + check(k0 < walls["pin"] < walls["paired"], "walls above the selected crossing") + table = partitions_table(RANK_CAP) + lemma = check_balanced_lemma(table) + ladder = ladder_rows(T, P, H, model, k0) + exch = exchange_rows(T, P, H, model, c0, k0, walls, table) + mins = touched_rows(T, P, H, model, c0, walls) + at_one = sum(split_all(T, H, RANK_CAP).values()) - sum(P.values()) + check(at_one == 24040, "full-split endpoint explains the interval restriction") + return { + "verifier_sha256": {name: hashlib.sha256((HERE / name).read_bytes()).hexdigest() + for name in ("verify.py", "intervals.py")}, + "inputs": {"FULL-RESULT.json": FULL_SHA, "bit-admission.json": BIT_SHA}, + "helpers": {str(r): H[r] for r in sorted(H)}, + "fixed_rank9_fields": extra, + "kappa0": q(k0), + "kappa0_bracket": [str(k0 - EPS), str(k0 + EPS)], + "walls": {k: q(v) for k, v in walls.items()}, + "wall_margin_F": {k: q(model.margin(c0, v)) for k, v in walls.items()}, + "lemma_partition_checks": lemma, + "ladder": ladder, + "exchange": exch, + "min_touched": mins, + "claim_interval": ["0", "0.02"], + "numeric_error_bound": "1e-39", + "full_split_margin_at_one": at_one, + } + + +def ladder_rows(T, P, H, model, k0): + rows, prev = [], k0 - 1 + for m in range(1, RANK_CAP + 1): + km = model.root(invoice_diff(split_all(T, H, m), P)) + check(km > prev or m == 1, "ladder strictly increasing") + prev = km + rows.append({"m": m, "kappa": q(km), "gain": q(km - k0), + "root_bracket": [str(km - EPS), str(km + EPS)]}) + check(rows[0]["kappa"] == q(k0), "m = 1 is the selected invoice") + return rows + + +def exchange_rows(T, P, H, model, c0, k0, walls, table): + p0, rows = 1 - k0, [] + for r in range(2, RANK_CAP + 1): + for lam in table[r]: + if len(lam) < 2: + continue + one = model.root(invoice_diff(apply_split(T, r, lam, 1), P)) + row = {"r": r, "parts": list(lam), "gain_at_k0": q(gain(lam, r, p0, model)), + "single_split_dk": q(one - k0), "available": H[r], + "root_bracket": [str(one - EPS), str(one + EPS)]} + for name, w in walls.items(): + g = gain(lam, r, 1 - w, model) + count = ceil_div(-model.margin(c0, w), g) + # These are algebraic counts; stock may be insufficient. + for number, sign in ((count - 1, -1), (count, 1)): + c = invoice_diff(apply_split(T, r, lam, number), P) + interval = model.oracle.moment(c, w) + check(interval[1] < 0 if sign < 0 else interval[0] > 0, + "wall count is not minimal") + row["need_" + name] = count + row["available_" + name] = count <= H[r] + rows.append(row) + return rows + + +def touched_rows(T, P, H, model, c0, walls): + out = {} + for name, w in walls.items(): + for label, pieces in (("any", RANK_CAP), ("binary", 2)): + lam = balanced(9, pieces) + best = gain(lam, 9, 1 - w, model) + used = ceil_div(-model.margin(c0, w), best) + check(0 < used <= H[9], "rank-nine stock suffices") + for r in range(2, RANK_CAP): + other = gain(balanced(r, pieces), r, 1 - w, model) + check(Decimal(q(best)) - Decimal(q(other)) > Decimal("2e-39"), + "rank nine has the greatest certified gain") + # Exact interval proof: no used-1 helpers can suffice even if all + # receive the largest per-helper gain, while used rank-nine do. + model.certify(invoice_diff(apply_split(T, 9, lam, used), P)) + for number, positive in ((used - 1, False), (used, True)): + c = invoice_diff(apply_split(T, 9, lam, number), P) + interval = model.oracle.moment(c, w) + check(interval[0] > 0 if positive else interval[1] < 0, + "minimal touched-helper certificate") + out[name + "_" + label] = {"helpers": used, + "plan": [[9, used]]} + return out + + +# ------------------------------------------------------------ controls +def run_controls(full, receipt): + T, P, _, _ = load_invoice(full) + model = Model(sorted(set(T) | set(P))) + bad = json.loads(json.dumps(full)) + bad["native"]["helpers"]["4"] += 1 + expect_fail(lambda: load_invoice(bad), "helper count off by one") + expect_fail(lambda: model.oracle.powers(Fraction(9, 10)), "outside certified range") + c0 = invoice_diff(T, P) + k0 = Decimal(receipt["kappa0"]) + check(model.margin(c0, k0 - Decimal("1e-6")) > 0 > model.margin(c0, k0 + Decimal("1e-6")), + "wrong-root control brackets the real root") + expect_fail(lambda: check_not_balanced((3, 1), 2, 4), "unbalanced partition is not minimal") + expect_fail(lambda: model.oracle.bracket(c0, Decimal("0.004"), Decimal("0.005")), + "a bracket missing the root") + expect_fail(lambda: model.certify({r: -n for r, n in c0.items()}), "reversed monotonicity") + return 6 + + +def check_not_balanced(lam, m, r): + check(majorizes(balanced(r, m), lam, m), "unbalanced partition is not minimal") + + +def expect_fail(fn, label): + try: + fn() + except (SystemExit, ValueError): + return + fail("control did not reject: " + label) + + +def summary(receipt): + lad = {row["m"]: row["kappa"] for row in receipt["ladder"]} + return ("PASS_HELPER_SPLIT_HEADROOM_LADDER kappa0=%s m2=%s m9=%s " + "pin_any=%d pin_binary=%d paired_any=%d paired_binary=%d" + % (receipt["kappa0"][:14], lad[2][:12], lad[9][:12], + receipt["min_touched"]["pin_any"]["helpers"], + receipt["min_touched"]["pin_binary"]["helpers"], + receipt["min_touched"]["paired_any"]["helpers"], + receipt["min_touched"]["paired_binary"]["helpers"])) + + +def main(argv): + check(argv in ([], ["--emit"]), "usage: verify.py [--emit]") + full = read_pinned(FULL, FULL_SHA) + bit = read_pinned(BIT, BIT_SHA) + receipt = build(full, bit) + text = json.dumps(receipt, indent=1, sort_keys=True) + "\n" + if "--emit" in argv: + sys.stdout.write(text) + return + check(RESULT.read_text() == text, "RESULT.json differs from the recomputed receipt") + controls = run_controls(full, receipt) + print(summary(receipt), "controls=%d" % controls) + + +if __name__ == "__main__": + main(sys.argv[1:])