diff --git a/research/kappa010-complex-lever-floor/README.md b/research/kappa010-complex-lever-floor/README.md new file mode 100644 index 0000000000..2f95f32b2e --- /dev/null +++ b/research/kappa010-complex-lever-floor/README.md @@ -0,0 +1,102 @@ +# κ = 0.1 budget screens and conditional paired-plane sensitivity + +**Scoped budget screen; no κ improvement or supplier is claimed.** The selected conditional result remains κ = 0.001672660197076918. This checks what the already explored two-output anchor, centre removal, rank-16 repacking and a changed coverage law would need to accomplish at `κ=1/10`. + +## Result + +The retained transfer `κ = a/(1+a)` maps `κ=1/10` to the exact target `a=1/9`. We use the certified outward-rational interval engine in `complex-local-word-ceiling/ceiling.py` and the pinned selected profile and two-output-anchor receipt. + +The selected complex word still fails badly at the target after deleting its eight rank-8 centre children and all 64 units of centre charge. Its largest feasible unpaid count with that fixed local profile is `u=17`; the exact interval moment there is approximately **1.151904798395**, above one. Since increasing `u` only reduces the idle remainder and this is already the largest feasible `u`, no coverage change alone can rescue the fixed selected profile in this relaxed model. + +We next grant the strongest combination from the local two-output-anchor exploration: + +1. Seven hypothetical 112-port blocks replace 332 rank-one children with 112 children per block. +2. The 112 affine additions in each block are charged as 112 rank-one-equivalent units, giving rank-one profile count 1,656. +3. The complete centre path is deleted, including its 64-unit charge and eight rank-8 children. +4. All remaining paid local rank mass, exactly 4,766, is fractionally repacked into rank-16 children. +5. All source alignment, dirty-state handling, routing, frame, precision, restoration and physical costs are waived. + +Even this combined relaxation has target moment **1.077445412079** with four unpaid coordinates. Its exact unpaid-coordinate boundary is: + +| Model at `a=1/9` | Previous integer | Moment | First passing integer | Moment | +|---|---:|---:|---:|---:| +| Seven anchors, centre free, original local ranks | `u=23` | 1.007064932212 | `u=24` | 0.992809414512 | +| Seven anchors, centre free, all mass at rank 16 | `u=9` | 1.006167823580 | `u=10` | 0.991912305880 | +| Same rank-16 model, centre charge retained | `u=10` | 1.001076567258 | `u=11` | 0.986821049559 | + +The inequalities are decided by exact rational interval endpoints; decimals are for orientation. The positive control reproduces a passing moment at the repository's smaller planning target `a=1/99` with the same ideal rank-16 profile and only one unpaid coordinate. + +There is also a concrete five-plane P112 decoder in the local archive with a reported `u=5` endpoint. Its pinned profile is `{1:2412, 2:418, 3:432, 4:142, 5:82, 7:10, 8:6}`. Using the exact same selected replay archive as the present checkpoint, its moment at `a=1/9`, `u=5`, and centre charge 64 is **1.336180761792**. More strongly, its paid local terms alone contribute at least **1.165241830803**, before any idle remainder is added. Therefore no change to `u`, centre charge or idle packing can make this *fixed local profile* reach the 0.1 target. This is scoped to its profile, not to the P112 endpoint family or other decoders. + +Even replacing that whole profile with fractional rank-16 children and deleting the centre leaves moment **1.080393847328** at `u=5`; the first passing counts are `u=11` centre-free and `u=12` with the centre charge. With `u=5` held fixed, every 5,640 units would instead need a uniform local rank of at least 37 centre-free or 41 with the centre. The existing decoder's paid terms have ranks 7 and 8. The exact threshold checker reuses its pinned profile and source manifest; it does not replay that decoder's algebra. + +There is a clear exchange rate between the two remaining structural levers. Keep the same 4,766 units of local mass, place it fractionally at one uniform rank `r`, and leave only the idle remainder at rank 51. The first passing `u` is: + +| Assumed local rank `r` for all 4,766 units | First passing `u`, centre free | First passing `u`, centre retained | +|---:|---:|---:| +| 16 | 10 | 11 | +| 32 | 6 | 7 | +| 48 | 4 | 4 | +| 51 | 3 | 4 | + +Conversely, with only four unpaid coordinates, the local consumer must place all this mass at rank at least 42 if the centre is removed, or rank at least 47 if it remains. These are exact boundaries in the relaxed profile model. They suggest the concrete alternatives for further construction work: prove substantially more unpaid coverage, or build a consumer close to the maximum admitted idle rank. Neither exists at the selected provider boundary today. + +The target also leaves little room for a complete anchor invoice. With all 4,766 units placed at rank 16, the largest integer per-block rank-one-equivalent fee is `e=170` at `u=10` with the centre removed; `e=171` fails. The known 112 affine additions use 112 of that allowance, leaving at most 58 units per block for every other interface cost under the same tariff. If the centre charge remains and coverage rises to `u=11`, the boundary is `e=207` passing versus `e=208` failing, leaving 95 units beyond the 112 affine additions. These are exact moment boundaries, not realized physical prices. + +This gives a concrete target-scale requirement for this bundle: even after granting all its local and consumer costs for free, it needs **ten unpaid coordinates per live family** if the centre is actually removed, or eleven if the centre charge remains. The existing selected contract has one. The local anchor result does not realize any replacement coverage identity, and fractional rank-16 repacking is not a decoder. + +## Tensorized paired-plane endpoint: separate scalar work from child rank + +The exact scalar fitting matrix in the [49-support certificate](../paired-plane-minrank-bracket-audit/README.md) partitions the 112 ports into supports of sizes `{1: 2, 2: 31, 3: 16}`. Its ordinary scalar rank is 49. Separately, charging each support by its full port-space Gram rank `2s` gives the profile `{2: 2, 4: 31, 6: 16}` and mass **224** per copy. The moment table below conditionally inserts those port-space charges as recursive child ranks; neither the scalar rank-49 theorem nor the all-size block-rank theorem establishes that native/profile mapping. Tensor multiplicity `d` gives modeled profile mass `224d`; `u=2d` is the proposed two-plane coverage rule, not a source-bound hosted identity. + +The previous screen treated the minimum `q−2=110` dirty-target `ADD`s per block as rank-one-equivalent fees inside the exponent moment. That was only a hypothetical tariff. The arbitrary-dirty anchor's source package explicitly charges its 224 scalar additions per block in the scalar compiler envelope separately. The corrected screen therefore keeps scalar `ADD`s out of the recursive child-rank profile and reports rank-one-equivalent fees only as sensitivity cases. + +Seven hypothetical q=112 dirty-output anchors replace 332 rank-one children by 112 per block. After deleting the centre path, the remaining mass is 3,982. I grant an optimistic consumer by fractionally repacking it at the maximum idle rank 51. The exact moment intervals at `a=1/9` then give: + +| Tensor copies `d` | Proposed unpaid `u=2d` | Centre-free moment* | Moment with centre* | +|---:|---:|---:|---:| +| 1 | 2 | 1.021884 | 1.033143 | +| 2 | 4 | 1.003115 | 1.014374 | +| 3 | 6 | **0.984346** | **0.995605** | +| 4 | 8 | 0.965578 | 0.976836 | +| 5 | 10 | 0.946809 | 0.958068 | +| 6 | 12 | 0.928040 | 0.939299 | +| 7 | 14 | 0.909271 | 0.920530 | + +The intervals are outward-rational and the decimals are for orientation. In this relaxation, `d=3` is the first moment pass even with the centre retained. The zero-fee mass capacity is feasible through `d=7`; `d=8` exceeds it by exactly `298/3`. This corrects the earlier fee-based rejection. It does **not** establish that the tensorized endpoint can be placed in the selected provider, or that the proposed `u=2d` coverage identity holds for a complete hosted call. + +`*` These are exact moments of the **assumed** child-rank profile `{2:2d, 4:31d, 6:16d}` plus a fractional rank-51 repacking. They are not moments of an admitted native decoder. + +The exact arbitrary-dirty anchor receipt also checks its known scalar invoice: seven blocks use 1,568 unit-addition macros, giving a conservative local primitive bound of **10,688,681,187,742**, below the strict `2^48` guard **281,474,976,710,656**. This covers the anchor schedule only. The paired-plane factorization's native payloads, query preparation, child wrappers, frame paths, precision/tape effects, restoration, and complete source placement remain unpriced. As a sensitivity, if other interface charges were translated to rank-one-equivalent units, the modeled `d=3` row has room for at most 28 per block without the centre or 8 with it; no such conversion is claimed for scalar `ADD`s. + +The unchanged bit-side primitive endpoint is `a=0.001733427039589844234749`, which converts to a complete `κ` cap of about `0.001730427469823603`. Even if this complex-side relaxation were made real, the complete selected construction would still be capped far below `κ>0.1`. No new κ or supplier is claimed. + +## Scope and next step + +This is a corrected, optimistic moment screen for a fixed support fit, seven dirty-output anchor replacements, and a proposed two-unpaid-coordinate-per-copy law. The algebraic fitting matrix has exact source-bound premises, but the work here does not compose its 49-support channels with the selected supplier's chronological operand and frame trace. The rank-51 repacking also grants every remaining local mass unit its best permitted idle rank. Unknown costs remain unknown; they are not zero in a supplier claim. + +The next useful test is one complete source-bound block: bind its 112 input and dirty output coordinates to a selected-provider trace, state how the 49 support queries are produced and decoded, prove how their port-space cost maps to recursive child ranks, and account for every child payload, scalar operation, frame, inverse, precision effect, and caller transfer. A pass there would make the d=3 model a meaningful construction target. Separately, the bit-side mechanism needs a distinct path capable of moving its endpoint from about `0.00173343` to above `0.1`; this complex-side screen cannot do that work. + +## Reproduction + +From the repository root: + +```sh +python3 -B research/kappa010-complex-lever-floor/verify.py +python3 scripts/research_package.py --package research/kappa010-complex-lever-floor --check-only +python3.12 scripts/research_package.py --package research/kappa010-complex-lever-floor +``` + +The verifier binds the selected record, current local ceiling model, two-output and arbitrary-dirty anchor receipts, and paired-plane fit receipts in [SOURCES.json](SOURCES.json). It checks the exact `a=1/9` interval boundaries, the rank/unpaid and fee frontiers, the 49-support full port-space profile, all feasible tensor multiplicities `d=1..7` with scalar additions separate, the `d=8` mass excess, the arbitrary-dirty anchor's scalar guard invoice, and the lower `a=1/99` positive control. + +## Predecessors and credit + +This is a target refinement of the `coverage-law-change` question, motivated by the donor-set target κ > 0.1. The local two-output and arbitrary-dirty temporary-sum maps retain Cinna / commdata2338's [anchor](../complex-two-output-sum-anchor-seed65ce19/README.md) and the dirty-output extension's predecessor attribution in [its package](../complex-dirty-output-temporary-sum-anchor/README.md). The paired-plane construction retains the credits in its own README, including thakrarsagar's 49-support fit, ywz65's block-rank extension, Adam Gall's strict mask, and the PR1825 matching and PR2203 native payload accounting. The interval ceiling and selected profile are credited in [complex-local-word-ceiling](../complex-local-word-ceiling/README.md). This package adds only target-specific combined-lever budgets and a correction to scalar-versus-rank charging. Prepared by Codex with substantial OpenAI assistance; no independent human review is claimed. New work is Apache-2.0. + +A fresh overlap refresh on 2026-10-17 covered 259 open PRs and 1,866 discussions (complete pagination). Open PR #3093 checks two fixed local profiles (#2979 and #3042) at the same target. This package instead screens the selected profile, pinned five-plane profile, and seven-anchor/tensorized paired-plane relaxation, including exact unpaid-coordinate, scalar-guard and rank-one-equivalent fee-sensitivity boundaries; scopes are complementary. Local matches include the earlier `kappa01-complex-target-screen`, the P112 five-plane decoder and prior coverage-law packages, so novelty is not claimed. Relevant PRs #3064 and #3097 and Discussions #1163, #1166, #1167 and #2838 were also checked. Canonical main was refreshed at `18aacb215fc3717b06be8ceb9fca62aeca0d3e99` (priority revision 6); the selected record and quantitative predecessor receipts are unchanged. + +## Open next questions + +1. **Can one d=3 paired-plane block be composed with a selected-provider trace?** It matters because this is the first exact moment pass at `a=1/9`. First step: bind all 112 source and arbitrary-dirty target coordinates, the 49 support queries, child payloads, and their inverse to one chronological subword. Blocker: no such product grouping or frame path is source-bound. +2. **What is the complete scalar and native invoice for that block?** The known seven-anchor ADD schedule fits its local scalar guard, but this does not price query preparation, child wrappers, frame conversions, precision, tape or outer cleanup for the paired-plane factorization. First step: list the literal operations for one block and apply the exact guard adapters. Blocker: the algebraic fitting certificate has no native schedule. +3. **How could the bit-side endpoint rise above 0.1?** Even a complete complex-side win leaves the selected bit endpoint near `0.00173343`. First step: identify a separate bit-side mechanism and a fully charged target profile; no such candidate is part of this package. diff --git a/research/kappa010-complex-lever-floor/RESULT.json b/research/kappa010-complex-lever-floor/RESULT.json new file mode 100644 index 0000000000..7d7f5a5882 --- /dev/null +++ b/research/kappa010-complex-lever-floor/RESULT.json @@ -0,0 +1,896 @@ +{ + "status": "PASS_KAPPA010_COMPLEX_LEVER_FLOOR; scoped budget screen only", + "selected_kappa": "0.001672660197076918", + "target_kappa": "1/10", + "target_primitive_saving_a": "1/9", + "model": { + "m": 73, + "families_per_call": "896/9", + "stages": 9, + "rank_cap": 51, + "selected_centre_charge": 64, + "target_moment_engine": "exact outward rational intervals from complex-local-word-ceiling/ceiling.py" + }, + "baseline_local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "baseline_centre_free_max_feasible_unpaid": 17, + "baseline_at_max_unpaid": { + "unpaid_coordinates": 17, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "66690731604344331039752104849954847426884613715885339496903505127299770326121/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "66690731604344331039752104849954847426884613715885339496903505127299770326145/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "1.151904798395", + "below_one": false + }, + "seven_anchor_hypothesis": { + "blocks": 7, + "rank_one_additions_per_block": 112, + "affine_charge_assumption": "112 additions are charged as 112 rank-one-equivalent units per block", + "profile_before_centre_deletion": { + "1": 1656, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "centre_free_profile": { + "1": 1656, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "centre_free_rank_mass": 4766, + "rank16_fractional_profile": { + "16": "2383/8" + }, + "anchor_only_boundary": { + "u23": { + "unpaid_coordinates": 23, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "116610152498408438255972745901166513358910899457071242142953273320242648420905/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "58305076249204219127986372950583256679455449728535621071476636660121324210473/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "1.007064932212", + "below_one": false + }, + "u24": { + "unpaid_coordinates": 24, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "57479738160397110507114565860239247071594945635514834124223345730281712410195/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "114959476320794221014229131720478494143189891271029668248446691460563424820431/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.992809414512", + "below_one": true + } + }, + "rank16_boundary_centre_free": { + "u9": { + "unpaid_coordinates": 9, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "116506274415663977165733013224677668660628491352510048968729552213514987971391/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "29126568603915994291433253306169417165157122838127512242182388053378746992855/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.006167823580", + "below_one": false + }, + "u10": { + "unpaid_coordinates": 10, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "28713899559512439980997349760997412361226870791617118768555742588458941092719/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "114855598238049759923989399043989649444907483166468475074222970353835764370905/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.991912305880", + "below_one": true + } + }, + "rank16_boundary_centre_retained": { + "u10": { + "unpaid_coordinates": 10, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "115916747209373185293681722445860518940728131286066629720691487263629550971207/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "28979186802343296323420430611465129735182032821516657430172871815907387742809/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.001076567258", + "below_one": false + }, + "u11": { + "unpaid_coordinates": 11, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "28566517757939742012984527066293124931251780775006263956546226350987581842673/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "114266071031758968051938108265172499725007123100025055826184905403950327370721/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.986821049559", + "below_one": true + } + }, + "first_passing_unpaid_centre_free": 10, + "first_passing_unpaid_centre_retained": 11, + "uniform_rank_frontier_at_target": [ + { + "uniform_local_rank": 16, + "centre_mass_per_call": 0, + "previous_unpaid": { + "unpaid_coordinates": 9, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "116506274415663977165733013224677668660628491352510048968729552213514987971391/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "29126568603915994291433253306169417165157122838127512242182388053378746992855/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.006167823580", + "below_one": false + }, + "first_passing_unpaid": { + "unpaid_coordinates": 10, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "28713899559512439980997349760997412361226870791617118768555742588458941092719/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "114855598238049759923989399043989649444907483166468475074222970353835764370905/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.991912305880", + "below_one": true + } + }, + { + "uniform_local_rank": 16, + "centre_mass_per_call": 64, + "previous_unpaid": { + "unpaid_coordinates": 10, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "115916747209373185293681722445860518940728131286066629720691487263629550971207/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "28979186802343296323420430611465129735182032821516657430172871815907387742809/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.001076567258", + "below_one": false + }, + "first_passing_unpaid": { + "unpaid_coordinates": 11, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "28566517757939742012984527066293124931251780775006263956546226350987581842673/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "114266071031758968051938108265172499725007123100025055826184905403950327370721/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.986821049559", + "below_one": true + } + }, + { + "uniform_local_rank": 32, + "centre_mass_per_call": 0, + "previous_unpaid": { + "unpaid_coordinates": 5, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "29111548820971743336327901392425087481660304832752262328997547540549715701895/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "116446195283886973345311605569700349926641219331009049315990190162198862807609/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.005648970071", + "below_one": false + }, + "first_passing_unpaid": { + "unpaid_coordinates": 6, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "114795519106272756103567991389012330710920211144967475421483608302519639207065/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "57397759553136378051783995694506165355460105572483737710741804151259819603547/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "0.991393452371", + "below_one": true + } + }, + { + "uniform_local_rank": 32, + "centre_mass_per_call": 64, + "previous_unpaid": { + "unpaid_coordinates": 6, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "28964167019399045368315078697720800051685214816141407516988031303078356451849/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "115856668077596181473260314790883200206740859264565630067952125212313425807425/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.000557713750", + "below_one": false + }, + "first_passing_unpaid": { + "unpaid_coordinates": 7, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "114205991899981964231516700610195180991019851078524056173445543352634202206881/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "57102995949990982115758350305097590495509925539262028086722771676317101103455/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "0.986302196050", + "below_one": true + } + }, + { + "uniform_local_rank": 48, + "centre_mass_per_call": 0, + "previous_unpaid": { + "unpaid_coordinates": 3, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "58040714935256486624555830609830792410207556404668451004441175173328546157429/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "14510178733814121656138957652457698102551889101167112751110293793332136539361/14474011154664524427946373126085988481658748083205070504932198000989141204992" + ], + "moment_approx": "1.002498794478", + "below_one": false + }, + "first_passing_unpaid": { + "unpaid_coordinates": 4, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "114430753692898756007368047038973565604694104623295328114375768486977868714343/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "114430753692898756007368047038973565604694104623295328114375768486977868714373/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.988243276778", + "below_one": true + } + }, + { + "uniform_local_rank": 48, + "centre_mass_per_call": 64, + "previous_unpaid": { + "unpaid_coordinates": 3, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "117142578841836398618803984621532454316235760928935056655350867256450878915189/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "29285644710459099654700996155383113579058940232233764163837716814112719728805/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.011663055857", + "below_one": false + }, + "first_passing_unpaid": { + "unpaid_coordinates": 4, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "57745951332111090688530185220422217550257376371446741380422142698385827657337/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "115491902664222181377060370440844435100514752742893482760844285396771655314705/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.997407538157", + "below_one": true + } + }, + { + "uniform_local_rank": 51, + "centre_mass_per_call": 0, + "previous_unpaid": { + "unpaid_coordinates": 2, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "117198008610609424163796606828849364316191581208951746509967312037224875636541/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "29299502152652356040949151707212341079047895302237936627491828009306218909143/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.012141756683", + "below_one": false + }, + "first_passing_unpaid": { + "unpaid_coordinates": 3, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "57773666216497603461026496324080672550235286511455086307730365088772826018013/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "115547332432995206922052992648161345100470573022910172615460730177545652036057/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.997886238983", + "below_one": true + } + }, + { + "uniform_local_rank": 51, + "centre_mass_per_call": 64, + "previous_unpaid": { + "unpaid_coordinates": 3, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "116608481404318632291745316050032214596291221142508327261929247087339438636357/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "29152120351079658072936329012508053649072805285627081815482311771834859659097/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.007050500361", + "below_one": false + }, + "first_passing_unpaid": { + "unpaid_coordinates": 4, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "57478902613352207525000850934672097690285106478233376683711332613830107517921/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "114957805226704415050001701869344195380570212956466753367422665227660215035873/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.992794982662", + "below_one": true + } + } + ], + "minimum_uniform_local_rank_at_fixed_unpaid": { + "u4_centre_free": 42, + "u4_centre_retained": 47, + "u10_centre_free": 15, + "u10_centre_retained": 17 + }, + "fee_boundaries_with_fractional_rank16_consumer": { + "u10_centre_free": { + "passing": { + "rank_one_equivalent_fee_per_block": 170, + "total_local_mass": 5172, + "unpaid_coordinates": 10, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "57890490853564510041707407505442332294308597938984848511350383116152265219493/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "115780981707129020083414815010884664588617195877969697022700766232304530439015/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.999904073497", + "below_one": true + }, + "first_failing": { + "rank_one_equivalent_fee_per_block": 171, + "total_local_mass": 5179, + "unpaid_coordinates": 10, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "57898468297263469181012799022398323804168164427877100424699329632345961478701/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "57898468297263469181012799022398323804168164427877100424699329632345961478715/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "1.000041862594", + "below_one": false + }, + "extra_allowance_after_112_affine_units": 58 + }, + "u11_centre_retained": { + "passing": { + "rank_one_equivalent_fee_per_block": 207, + "total_local_mass": 5431, + "unpaid_coordinates": 11, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "115781785334561204519962496486810886598324755989552919362484743480752616620183/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "115781785334561204519962496486810886598324755989552919362484743480752616620211/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.999911013759", + "below_one": true + }, + "first_failing": { + "rank_one_equivalent_fee_per_block": 208, + "total_local_mass": 5438, + "unpaid_coordinates": 11, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "57898870110979561399286639760361434809021944483668711594591318256570004569299/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "115797740221959122798573279520722869618043888967337423189182636513140009138627/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.000048802856", + "below_one": false + }, + "extra_allowance_after_112_affine_units": 95 + } + } + }, + "five_plane_p112_predecessor_screen": { + "source_result": "research/five-plane-port-p112-seed1f7fdfe4/RESULT.json", + "source_replay_archive_sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6", + "local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "7": 10, + "8": 6 + }, + "reported_local_unpaid_count": 5, + "actual_profile_at_a_1_over_9": { + "unpaid_coordinates": 5, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "154719162006582639668482298675254282084467850867043503381613089328017525167681/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "154719162006582639668482298675254282084467850867043503381613089328017525167735/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.336180761792", + "below_one": false + }, + "local_children_only_lower_bound_interval": [ + "67462893027684651282180105388234240119406630818102851064367529317806988943255/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "67462893027684651282180105388234240119406630818102851064367529317806988943279/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "local_children_only_moment_approx": "1.165241830803", + "passes_for_any_integer_unpaid_with_original_local_profile": false, + "fractional_rank16_all_mass_u5_centre_free": { + "unpaid_coordinates": 5, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "31275265195308089229813452188252906353539638973585384155758916709721579918195/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "62550530390616178459626904376505812707079277947170768311517833419443159836405/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "1.080393847328", + "below_one": false + }, + "fractional_rank16_all_mass_u5_centre_retained": { + "unpaid_coordinates": 5, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "126162209752555782288946132154882494909979204013939691269504183748680106273111/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "63081104876277891144473066077441247454989602006969845634752091874340053136571/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "1.089558108706", + "below_one": false + }, + "first_passing_unpaid_at_rank16": { + "centre_free": 11, + "centre_retained": 12 + }, + "minimum_uniform_local_rank_at_u5": { + "centre_free": 37, + "centre_retained": 41 + }, + "scope": "The predecessor RESULT is screened as a pinned profile; its algebraic decoder is not replayed by this package." + }, + "planning_target_positive_control": { + "a": "1/99", + "rank16_profile_unpaid": 1, + "centre_mass": 0, + "moment_interval": [ + "115518000078972201059389155432675411532593741577497017377967754991854395522263/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "115518000078972201059389155432675411532593741577497017377967754991854395522269/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "below_one": true + }, + "tensorized_paired_plane_anchor_screen": { + "predecessor_support_fit": { + "scalar_factor_count": 49, + "support_size_histogram": { + "1": 2, + "2": 31, + "3": 16 + }, + "port_space_copy_profile": { + "2": 2, + "4": 31, + "6": 16 + }, + "port_space_mass_per_payload_copy": 224, + "scope": "Pinned disjoint-support fit, priced by full port-space Gram ranks. These ranks are not established as recursive child ranks or native COPY costs; this conversion is conditional and not a lower bound on every decoder." + }, + "payload_copy_to_unpaid_rule": "u=2d", + "base_mass_repacked_at_rank": 51, + "base_mass_before_endpoint_and_dirty_updates": 3982, + "anchor_blocks": 7, + "dirty_output_anchor_source_result": "research/complex-dirty-output-temporary-sum-anchor/RESULT.json", + "dirty_output_anchor_scalar_invoice": { + "adapter_growth_per_macro": 414949376, + "added_unit_addition_macros_per_call": 1568, + "guard": "281474976710656", + "macro_allowance_upper_bound_per_call": 654144, + "new_local_primitive_bound_upper": 10688681187742, + "old_local_primitive_bound": 10038040553630, + "own_primitive_upper_per_macro": 8, + "remaining_guard_slack": 270786295522914, + "scope": "Conservative scalar-envelope screen only; selected product-map placement and full supplier replay are not established." + }, + "unchanged_bit_side_primitive_endpoint_a": "1733427039589844234749/1000000000000000000000000", + "unchanged_bit_side_kappa_cap": "1733427039589844234749/1001733427039589844234749", + "unchanged_bit_side_kappa_cap_decimal": "0.001730427469824", + "one_target_dirty_update_floor_per_block_scalar_additions": 110, + "actual_dirty_anchor_additions_per_block": 224, + "separate_scalar_cost_model": { + "rank_one_equivalent_fee_in_exponent_profile": 0, + "known_seven_block_anchor_additions_are_within_selected_scalar_guard": true, + "decoder_linear_setup_cleanup_cost": "unknown; not in the anchor scalar invoice", + "interpretation": "ADDs are screened in the scalar compiler envelope; they are not automatically rank-one-equivalent child costs." + }, + "recursive_rank_mapping_assumption": "For this conditional moment screen only, the 2s port-space Gram rank of a support of size s is inserted as a recursive child rank. The paired-plane fitting-rank theorem does not establish this native/profile mapping.", + "d_1_through_7_zero_fee_target_moments": [ + { + "payload_copies": 1, + "unpaid_coordinates": 2, + "scalar_dirty_update_floor_per_block": 110, + "zero_rank_one_equivalent_fee_moments": { + "0": { + "unpaid_coordinates": 2, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "118326085871804829284010135056468978453173141228425577274515585865128470917047/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "118326085871804829284010135056468978453173141228425577274515585865128470917079/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.021884022053", + "below_one": false + }, + "64": { + "unpaid_coordinates": 2, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "59814870991855646029680112280851269400886017353720484097172160786526962265341/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "59814870991855646029680112280851269400886017353720484097172160786526962265357/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "1.033142615974", + "below_one": false + } + }, + "rank_one_equivalent_fee_frontier_per_block": { + "0": null, + "64": null + } + }, + { + "payload_copies": 2, + "unpaid_coordinates": 4, + "scalar_dirty_update_floor_per_block": 110, + "zero_rank_one_equivalent_fee_moments": { + "0": { + "unpaid_coordinates": 4, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "29038202694442949980184108730678138539678171218954065062512673993418404749131/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "29038202694442949980184108730678138539678171218954065062512673993418404749139/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.003115252025", + "below_one": false + }, + "64": { + "unpaid_coordinates": 4, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "117456466889678262696086524427946114507311578354831651169879431681599072610159/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "117456466889678262696086524427946114507311578354831651169879431681599072610191/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.014373845945", + "below_one": false + } + }, + "rank_one_equivalent_fee_frontier_per_block": { + "0": null, + "64": null + } + }, + { + "payload_copies": 3, + "unpaid_coordinates": 6, + "scalar_dirty_update_floor_per_block": 110, + "zero_rank_one_equivalent_fee_moments": { + "0": { + "unpaid_coordinates": 6, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "56989767841869385278731367394478064932126114261603471612792903041109383538001/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "1780930245058418289960355231077439529128941070675108487899778220034668235563/1809251394333065553493296640760748560207343510400633813116524750123642650624" + ], + "moment_approx": "0.984346481996", + "below_one": true + }, + "64": { + "unpaid_coordinates": 6, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "115283191795645233332812824294189690212851122002222334145414541790144220689637/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "115283191795645233332812824294189690212851122002222334145414541790144220689667/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.995605075916", + "below_one": true + } + }, + "rank_one_equivalent_fee_frontier_per_block": { + "0": [ + 28, + 29 + ], + "64": [ + 8, + 9 + ] + } + }, + { + "payload_copies": 4, + "unpaid_coordinates": 8, + "scalar_dirty_update_floor_per_block": 110, + "zero_rank_one_equivalent_fee_moments": { + "0": { + "unpaid_coordinates": 8, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "111806260589705741194189034655199705569791772170597626201120916190763915155479/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "27951565147426435298547258663799926392447943042649406550280229047690978788877/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "0.965577711968", + "below_one": true + }, + "64": { + "unpaid_coordinates": 8, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "56554958350806101984769562080216632959195332824806508560474825949344684384557/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "14138739587701525496192390520054158239798833206201627140118706487336171096143/14474011154664524427946373126085988481658748083205070504932198000989141204992" + ], + "moment_approx": "0.976836305888", + "below_one": true + } + }, + "rank_one_equivalent_fee_frontier_per_block": { + "0": [ + 62, + 63 + ], + "64": [ + 42, + 43 + ] + } + }, + { + "payload_copies": 5, + "unpaid_coordinates": 10, + "scalar_dirty_update_floor_per_block": 110, + "zero_rank_one_equivalent_fee_moments": { + "0": { + "unpaid_coordinates": 10, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "27408246373918177957728833630360820318832828954497077294164006574827265808739/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "109632985495672711830915334521443281275331315817988309176656026299309063234985/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.946808941939", + "below_one": true + }, + "64": { + "unpaid_coordinates": 10, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "110936641607579174606265424026676841623930209297003700096484762007234516848591/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "27734160401894793651566356006669210405982552324250925024121190501808629212155/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "0.958067535859", + "below_one": true + } + }, + "rank_one_equivalent_fee_frontier_per_block": { + "0": [ + 96, + 97 + ], + "64": [ + 76, + 77 + ] + } + }, + { + "payload_copies": 6, + "unpaid_coordinates": 12, + "scalar_dirty_update_floor_per_block": 110, + "zero_rank_one_equivalent_fee_moments": { + "0": { + "unpaid_coordinates": 12, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "107459710401639682467641634387686856980870859465378992152191136407854211314433/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "107459710401639682467641634387686856980870859465378992152191136407854211314461/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.928040171910", + "below_one": true + }, + "64": { + "unpaid_coordinates": 12, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "27190841628386536310747930973230104332367438236098595768004968028944916232017/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "108763366513546145242991723892920417329469752944394383072019872115779664928097/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.939298765830", + "below_one": true + } + }, + "rank_one_equivalent_fee_frontier_per_block": { + "0": [ + 106, + 107 + ], + "64": [ + 106, + 107 + ] + } + }, + { + "payload_copies": 7, + "unpaid_coordinates": 14, + "scalar_dirty_update_floor_per_block": 110, + "zero_rank_one_equivalent_fee_moments": { + "0": { + "unpaid_coordinates": 14, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "52643217653803326552183967126965216343205201556384837563863123258199679696955/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "52643217653803326552183967126965216343205201556384837563863123258199679696969/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "0.909271401882", + "below_one": true + }, + "64": { + "unpaid_coordinates": 14, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "106590091419513115879718023759163993035009296591785066047554982224324813007545/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "106590091419513115879718023759163993035009296591785066047554982224324813007573/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "0.920529995802", + "below_one": true + } + }, + "rank_one_equivalent_fee_frontier_per_block": { + "0": [ + 46, + 47 + ], + "64": [ + 46, + 47 + ] + } + } + ], + "first_passing_d_centre_free": 3, + "first_passing_d_centre_retained": 3, + "d_1_through_5_if_charged_110_rank_one_equivalent_units_per_block": [ + { + "payload_copies": 1, + "unpaid_coordinates": 2, + "scalar_dirty_update_floor_per_block": 110, + "if_mispriced_as_rank_one_equivalent_fee_110_per_block": { + "0": { + "unpaid_coordinates": 2, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "62660255440094272239401714095862532199079860773608618652163195874189099204391/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "125320510880188544478803428191725064398159721547217237304326391748378198408819/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.082289055372", + "below_one": false + }, + "64": { + "unpaid_coordinates": 2, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "126624166992095007254153517696958624746758615026232628224155127456303652022417/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "63312083496047503627076758848479312373379307513116314112077563728151826011227/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "1.093547649292", + "below_one": false + } + } + }, + { + "payload_copies": 2, + "unpaid_coordinates": 4, + "scalar_dirty_update_floor_per_block": 110, + "if_mispriced_as_rank_one_equivalent_fee_110_per_block": { + "0": { + "unpaid_coordinates": 4, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "30786808946538878778882432014492160025924816298651980069965375464230836622065/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "123147235786155515115529728057968640103699265194607920279861501856923346488295/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.063520285343", + "below_one": false + }, + "64": { + "unpaid_coordinates": 4, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "124450891898061977890879817563202200452298158673623311199690237564848800101895/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "62225445949030988945439908781601100226149079336811655599845118782424400050965/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "moment_approx": "1.074778879264", + "below_one": false + } + } + }, + { + "payload_copies": 3, + "unpaid_coordinates": 6, + "scalar_dirty_update_floor_per_block": 110, + "if_mispriced_as_rank_one_equivalent_fee_110_per_block": { + "0": { + "unpaid_coordinates": 6, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "120973960692122485752256027924212215809238808841998603255396611965468494567737/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "30243490173030621438064006981053053952309702210499650813849152991367123641943/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.044751515315", + "below_one": false + }, + "64": { + "unpaid_coordinates": 6, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "30569404201007237131901529357361444039459425580253498543806336918348487045343/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "122277616804028948527606117429445776157837702321013994175225347673393948181407/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.056010109235", + "below_one": false + } + } + }, + { + "payload_copies": 4, + "unpaid_coordinates": 8, + "scalar_dirty_update_floor_per_block": 110, + "if_mispriced_as_rank_one_equivalent_fee_110_per_block": { + "0": { + "unpaid_coordinates": 8, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "59400342799044728194491163895227895757389176244694643115465861037006821323607/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "7425042849880591024311395486903486969673647030586830389433232629625852665453/7237005577332262213973186563042994240829374041602535252466099000494570602496" + ], + "moment_approx": "1.025982745286", + "below_one": false + }, + "64": { + "unpaid_coordinates": 8, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "120104341709995919164332417295689351863377245968404677150760457781939096260849/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "120104341709995919164332417295689351863377245968404677150760457781939096260883/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "moment_approx": "1.037241339206", + "below_one": false + } + } + }, + { + "payload_copies": 5, + "unpaid_coordinates": 10, + "scalar_dirty_update_floor_per_block": 110, + "if_mispriced_as_rank_one_equivalent_fee_110_per_block": { + "0": { + "unpaid_coordinates": 10, + "centre_mass_per_call": 0, + "moment_interval_at_a_1_over_9": [ + "116627410504056427025708627656699367220317896136779969206466832182558790726691/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "29156852626014106756427156914174841805079474034194992301616708045639697681681/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "moment_approx": "1.007213975257", + "below_one": false + }, + "64": { + "unpaid_coordinates": 10, + "centre_mass_per_call": 64, + "moment_interval_at_a_1_over_9": [ + "58965533307981444900529358580966463784458394807897680063147783945242122170163/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "14741383326995361225132339645241615946114598701974420015786945986310530542545/14474011154664524427946373126085988481658748083205070504932198000989141204992" + ], + "moment_approx": "1.018472569178", + "below_one": false + } + } + } + ], + "d8_zero_fee_mass_excess": "298/3", + "mass_excess_growth_per_extra_copy": "3808/9", + "conclusion": "With scalar ADDs separate and the 2s support port-space charge conditionally treated as recursive child rank, the relaxed a=1/9 moment first passes at d=3 (0.984346 centre-free, 0.995605 with centre); d=1,2 fail and d=8 is mass-infeasible. The 49d fitting-rank theorem does not establish this native/profile mapping. The earlier d=1..5 failure used a hypothetical rank-one-equivalent ADD tariff and is retained only as sensitivity.", + "scope": "The exact paired-plane fitting matrix and dirty-output anchor are not composed into a selected-provider source block. Port-space support charges are not proven recursive child ranks or native COPY costs; query preparation, payloads, wrappers, frames, precision, tape, restoration and whole-supplier transfer remain unpriced. No new kappa is established." + }, + "scope": [ + "A failure rejects only the stated selected-profile or seven-anchor budget models; it is not a barrier for other algorithms.", + "The passing u=10 case places all 4,766 units of paid local rank mass into fractional rank-16 children and grants centre removal and a changed coverage law for free.", + "No source alignment, full dirty endpoint, rank-16 decoder, restoration schedule, physical invoice, supplier transfer, or new kappa is constructed.", + "The hypothetical 112-unit block fee prices affine additions only; all other interface charges are waived.", + "The d-fold screen separates scalar ADD guard costs from the exponent rank profile; the rank-one-equivalent fee rows are tariff sensitivities only.", + "The conditional d=3 moment pass uses a fractional rank-51 repacking of remaining mass and assumes the port-space support charge is a recursive child rank; it waives decoder payload implementation and source placement and is not an implementation or kappa improvement.", + "The existing bit-side endpoint remains unchanged and still caps the selected complete construction far below 0.1." + ] +} diff --git a/research/kappa010-complex-lever-floor/SOURCES.json b/research/kappa010-complex-lever-floor/SOURCES.json new file mode 100644 index 0000000000..1dcd1c163a --- /dev/null +++ b/research/kappa010-complex-lever-floor/SOURCES.json @@ -0,0 +1,108 @@ +{ + "schema_version": 1, + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "docs/research/paired-plane-contract-map.md", + "usage": "provenance", + "git_blob": "0f772c8f8618ef837f684e76960175d9bdc656ce", + "sha256": "defab882dd6f6ec10c5329059c6ed45d3afcc92d1a7ad6b753036d3d7411a229" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/complex-dirty-output-temporary-sum-anchor/README.md", + "usage": "provenance", + "git_blob": "52ef08a8c96d732197570a68aa00612c918fb035", + "sha256": "4af08a371282e14e6e486a899539af1c268771124f27db66e258a9e217e2b85a" + }, + { + "path": "research/complex-dirty-output-temporary-sum-anchor/RESULT.json", + "usage": "input", + "git_blob": "4781c94d37c2db673a4ddf2b9b14f64e3995ec96", + "sha256": "40c4b7a0fca5137bff0342efb378a81d366514ca19cf10e09fcb42cc19cd13af" + }, + { + "path": "research/complex-dirty-output-temporary-sum-anchor/verify.py", + "usage": "provenance", + "git_blob": "d1ef748532f678d8e0be81f02b7a2fa0d0cd347a", + "sha256": "afc9f2938f4c66876fed73e4e5a8df0efce37806f6838d6846bad985b24190a8" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-two-output-sum-anchor-seed65ce19/RESULT.json", + "usage": "input", + "git_blob": "e5f17b7f8c1d7a6541981599e9d55e8ec935febf", + "sha256": "0922fe6ae4e8af947cee2b79c7b64aa622dc6f721cf6d2a114fdb8e873ed146f" + }, + { + "path": "research/five-plane-port-p112-seed1f7fdfe4/RESULT.json", + "usage": "input", + "git_blob": "19fa619d61488c8e4e6ed93543834735a54520b2", + "sha256": "836e5fc9ce3d9eabe4cff7b99d1d2bee8fd5e88e2bb0b0fbf6bee934c278ff29" + }, + { + "path": "research/five-plane-port-p112-seed1f7fdfe4/SOURCES.json", + "usage": "input", + "git_blob": "d46d83b4be3860da66d06b333aaf2937c03a2848", + "sha256": "68475b19da4a6f3af799425a12072391b481ede51c8b269684f238befdb04bbf" + }, + { + "path": "research/paired-plane-block-rank/README.md", + "usage": "provenance", + "git_blob": "d0d06862952ba99c25a732ce9f43cee7f0f039cb", + "sha256": "0d9e5849dc7440738526c3020a669cc239254a8e16413e7df69108f9572fcf1e" + }, + { + "path": "research/paired-plane-block-rank/RESULT.json", + "usage": "input", + "git_blob": "2b137330e7edbbbe7bc07843a2708791b731add7", + "sha256": "8b78968378d7ed824ac2418fe40b36db04d9522c117349778655191b4ee10d6d" + }, + { + "path": "research/paired-plane-minrank-bracket-audit/CERTIFICATE.json", + "usage": "input", + "git_blob": "393db5def16d76b3a0ebddc983c9bab6c3cc25fc", + "sha256": "6f5d3478290156c4fe703104572cc3aa593ad50079476ae08c942833714e3179" + }, + { + "path": "research/paired-plane-minrank-bracket-audit/README.md", + "usage": "provenance", + "git_blob": "a3bdd766b456c63c8291421e859bede8a9d045c6", + "sha256": "72cde76019024794f1e1126d3961cb88655336deb9c901edb35817287df50fe0" + }, + { + "path": "research/paired-plane-scalar-mask-obstruction/PR1825-CERTIFICATE.json", + "usage": "input", + "git_blob": "7ca668d7d50c7276e89b0f6f9575e1b9f1ad9ef6", + "sha256": "4fd648f7b5178bff5441bf364d58234b7bc1a43b924bc6da03013c948f1473b1" + } + ] +} diff --git a/research/kappa010-complex-lever-floor/TASK.json b/research/kappa010-complex-lever-floor/TASK.json new file mode 100644 index 0000000000..e9a02d9b0f --- /dev/null +++ b/research/kappa010-complex-lever-floor/TASK.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "task_id": "coverage-law-change", + "priority_revision": 6, + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "original_card": { + "id": "coverage-law-change", + "question": "Can a template or call contract leave two or more unpaid coordinates per live family?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/idle-axis-hosting/PROOF.md", + "certificates/selected-result.json" + ], + "methods": [ + "State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.", + "Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template." + ], + "acceptance_gate": "An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).", + "bottleneck_link": "The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.", + "allowed_variations": [ + "One template change or one endpoint-contract change.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "coverage identity", + "unpaid coordinate", + "deficit law", + "W - 64N" + ] + }, + "scope_status": "refined", + "actual_scope": "At the donor target \u03ba > 0.1, correct the scalar-versus-recursive-rank accounting for the tensorized paired-plane fitting endpoint combined with seven arbitrary-dirty anchors; screen all multiplicities under an explicitly conditional mapping from port-space Gram charge to recursive child rank, and separately report the known scalar guard invoice.", + "scope_change_reason": "The previous negative screen charged the q\u22122 dirty-target ADD floor as rank-one-equivalent child mass. The pinned arbitrary-dirty anchor receipt charges its 224 ADDs per block separately in the scalar compiler envelope. Correcting this changes d=3 from failure to a conditional exact moment pass. The algebraic fitting-rank theorem does not establish that its port-space charge is a native recursive child rank; source placement and the full decoder cost remain open.", + "bottleneck_link": "The complex supplier binds the selected \u03ba. At \u03ba=0.1 the primitive moment must be below one at a=1/9; the exact interval screen computes how much unpaid coverage is needed even after optimistic local repacking and centre deletion.", + "budget_minutes": 60, + "stop_rule": "The corrected exact screen is complete for d=1..7, with d=8 mass-infeasible. Do not expand to more supports or anchor schedules until one complete d=3 block is bound to a selected-provider trace with its query/decoder operations, dirty inverse, frames, scalar guard and recursive-child bill. Treat a passing relaxed moment as an exploration lead only.", + "outcome": "partial", + "evidence": "At a=1/9, exact outward-rational moments with scalar ADDs separate are d=1: 1.021884/1.033143, d=2: 1.003115/1.014374, d=3: 0.984346/0.995605, through d=7: 0.909271/0.920530 (centre-free/retained). d=8 exceeds mass capacity by 298/3. The arbitrary-dirty seven-anchor receipt separately budgets 1,568 unit ADD macros at 10,688,681,187,742 < 2^48. Decoder-native query preparation, placement and full supplier transfer are unknown. The unchanged bit primitive endpoint a=0.001733427039589844234749 converts to a complete \u03ba cap near 0.001730427469823603, still far below 0.1. The 2s support port-space charges are inserted as recursive child ranks only as a conditional modelling step; the scalar/block fitting-rank theorem does not certify that transfer. The {2,4,6} profile is the full port-space support Gram charge, not an admitted recursive child profile; using it in the moment is conditional.", + "author": "Codex with OpenAI assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for scope refinement, exact interval calculation, verifier implementation and report writing.", + "open_questions": [ + { + "question": "Can one d=3 paired-plane block be composed with a selected-provider trace?", + "why_it_matters": "d=3 is the first exact target-moment pass, including with the centre retained.", + "first_step": "Bind the 112 source and arbitrary-dirty target coordinates, all 49 support queries, child payloads and inverse to one chronological subword.", + "blocked_by": "No such product grouping, frame chronology or source locations are established." + }, + { + "question": "What is the complete scalar and native invoice for that block?", + "why_it_matters": "The known anchor ADD schedule fits the scalar guard, but the paired-plane support charge is not yet an admitted recursive-child profile and omitted query setup, payloads, wrappers and cleanup may invalidate the relaxed pass.", + "first_step": "Give an explicit native realization for one support, prove how its full port-space charge maps to recursive child ranks, and list the literal operations including dirty-state restoration.", + "blocked_by": "The algebraic fitting certificate supplies query dimension and a support partition, not a native schedule or child-profile mapping." + }, + { + "question": "What distinct bit-side mechanism could raise its endpoint above 0.1?", + "why_it_matters": "The selected bit endpoint near 0.00173343 would cap the complete result even if the complex-side target were met.", + "first_step": "Name a bit-side mechanism with an exact target profile and fully charged supplier transfer.", + "blocked_by": "No bit-side candidate is part of this investigation." + } + ], + "upstream_checkpoint": { + "commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "priority_revision": 6, + "checked_utc": "2026-10-17T01:56:48Z", + "comparison": "Immediately before PR update, fetched canonical origin/main; it remains exactly 18aacb215fc3717b06be8ceb9fca62aeca0d3e99. Priority revision 6, task catalogue, family status, selected record, bottleneck guidance, and paired-plane contract map are unchanged from the prior checkpoint." + } +} diff --git a/research/kappa010-complex-lever-floor/VERIFY.json b/research/kappa010-complex-lever-floor/VERIFY.json new file mode 100644 index 0000000000..57e69111f7 --- /dev/null +++ b/research/kappa010-complex-lever-floor/VERIFY.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/complex-dirty-output-temporary-sum-anchor/RESULT.json", + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-two-output-sum-anchor-seed65ce19/RESULT.json", + "research/five-plane-port-p112-seed1f7fdfe4/RESULT.json", + "research/five-plane-port-p112-seed1f7fdfe4/SOURCES.json", + "research/paired-plane-block-rank/RESULT.json", + "research/paired-plane-minrank-bracket-audit/CERTIFICATE.json", + "research/paired-plane-scalar-mask-obstruction/PR1825-CERTIFICATE.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Binds the selected \u03ba, ceiling model, two-output and arbitrary-dirty anchor receipts, and the five-plane profile's identical selected replay archive; reconstructs the seven-block hypothetical profile; checks exact outward-rational moments at a=1/9 for the stated conditional {2,4,6} recursive-rank tariff; certifies unpaid-count, rank and fee-sensitivity boundaries; recomputes the pinned paired-plane support fit's full port-space Gram charges; screens d=1..7 with scalar ADDs separate and d=8 mass infeasibility; checks the anchor scalar guard receipt and a=1/99 positive control. The algebraic fitting results do not establish the tariff as native child ranks; this is not a supplier or \u03ba claim." + } + ] +} diff --git a/research/kappa010-complex-lever-floor/verify.py b/research/kappa010-complex-lever-floor/verify.py new file mode 100644 index 0000000000..8da3232eb8 --- /dev/null +++ b/research/kappa010-complex-lever-floor/verify.py @@ -0,0 +1,631 @@ +#!/usr/bin/env python3 +"""Exact target screen for a joint complex-side lever bundle. + +At kappa=1/10 the retained transfer needs primitive saving a=1/9. We +evaluate the existing certified interval moment engine on the selected local +profile and on one explicitly hypothetical bundle: seven two-output anchors, +zero centre charge, and fractional repacking of all remaining local rank mass +into rank-16 children. We vary only the unpaid-coordinate count u. + +This is a budget screen, not a supplier construction. All source alignment, +the changed coverage identity, centre deletion, and the rank-16 consumer are +granted for free or represented by an optimistic tariff. +""" +from __future__ import annotations + +import importlib.util +import hashlib +import io +import json +import sys +import tarfile +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +CEILING_PATH = ROOT / "research/complex-local-word-ceiling/ceiling.py" +SPEC = importlib.util.spec_from_file_location("complex_ceiling", CEILING_PATH) +assert SPEC and SPEC.loader +C = importlib.util.module_from_spec(SPEC) +sys.modules[SPEC.name] = C +SPEC.loader.exec_module(C) + + +def read_json(path: str) -> dict: + return json.loads((ROOT / path).read_text()) + + +def moment(local: dict[int, Q | int], centre: int, unpaid: int) -> tuple[Q, Q]: + return C.relax(local, 73, 896, 9, centre, Q(1, 9), unpaid=unpaid) + + +def local_only_moment(local: dict[int, Q | int]) -> tuple[Q, Q]: + """Lower bound from paid local children alone; idle mass is nonnegative.""" + lo = hi = Q(0) + for r, n in local.items(): + child_lo, child_hi = C.child_cost(r, 73, Q(1, 9)) + lo += Q(n) * child_lo + hi += Q(n) * child_hi + return C.down(lo / Q(896, 9)), C.up(hi / Q(896, 9)) + + +def max_feasible_unpaid(local: dict[int, Q | int], centre: int) -> int: + valid = [] + for u in range(1, 73): + try: + C.model(local, 73, 896, 9, centre, unpaid=u) + except ValueError: + continue + valid.append(u) + assert valid + return max(valid) + + +def result_case(local: dict[int, Q | int], centre: int, unpaid: int) -> dict: + lo, hi = moment(local, centre, unpaid) + return { + "unpaid_coordinates": unpaid, + "centre_mass_per_call": centre, + "moment_interval_at_a_1_over_9": [str(lo), str(hi)], + "moment_approx": format(float((lo + hi) / 2), ".12f"), + "below_one": hi < 1, + } + + +def first_passing_unpaid(local: dict[int, Q | int], centre: int) -> int | None: + for u in range(1, 73): + try: + lo, hi = moment(local, centre, u) + except ValueError: + continue + if hi < 1: + return u + return None + + +def first_passing_local_rank(local_mass: int, unpaid: int, centre: int) -> int | None: + """Smallest uniform local child rank that passes; idle children keep R=51.""" + for r in range(1, 52): + try: + lo, hi = C.relax({r: Q(local_mass, r)}, 73, 896, 9, centre, + Q(1, 9), R=51, unpaid=unpaid) + except ValueError: + continue + if hi < 1: + return r + return None + + +def unpaid_frontier(local_mass: int, local_rank: int, centre: int) -> dict: + local = {local_rank: Q(local_mass, local_rank)} + u = first_passing_unpaid(local, centre) + assert u is not None and u > 1 + return { + "uniform_local_rank": local_rank, + "centre_mass_per_call": centre, + "previous_unpaid": result_case(local, centre, u - 1), + "first_passing_unpaid": result_case(local, centre, u), + } + + +def fee_case(base_mass: int, blocks: int, fee_per_block: int, + unpaid: int, centre: int) -> dict: + local_mass = base_mass + blocks * fee_per_block + lo, hi = C.relax({16: Q(local_mass, 16)}, 73, 896, 9, centre, + Q(1, 9), R=51, unpaid=unpaid) + return { + "rank_one_equivalent_fee_per_block": fee_per_block, + "total_local_mass": local_mass, + "unpaid_coordinates": unpaid, + "centre_mass_per_call": centre, + "moment_interval_at_a_1_over_9": [str(lo), str(hi)], + "moment_approx": format(float((lo + hi) / 2), ".12f"), + "below_one": hi < 1, + } + + +def maximum_passing_fee(base_mass: int, blocks: int, + unpaid: int, centre: int) -> tuple[int, int]: + """Largest integer fee e passing, followed by the first failing e.""" + def passes(e: int) -> bool: + try: + return fee_case(base_mass, blocks, e, unpaid, centre)["below_one"] + except ValueError: + return False + + lo, hi = 0, 1000 + assert passes(lo) and not passes(hi) + while lo + 1 < hi: + mid = (lo + hi) // 2 + if passes(mid): + lo = mid + else: + hi = mid + return lo, hi + + +def rank_mod2(matrix: list[list[int]]) -> int: + rows = [sum((value & 1) << j for j, value in enumerate(row)) for row in matrix] + width = len(matrix[0]) if matrix else 0 + pivot = 0 + for col in range(width): + row = next((r for r in range(pivot, len(rows)) if (rows[r] >> col) & 1), None) + if row is None: + continue + rows[pivot], rows[row] = rows[row], rows[pivot] + for r in range(len(rows)): + if r != pivot and ((rows[r] >> col) & 1): + rows[r] ^= rows[pivot] + pivot += 1 + if pivot == len(rows): + break + return pivot + + +def paired_plane_port_charge() -> dict: + """Reprice the pinned 49-support fit under full port-space pairing ranks.""" + cert_path = "research/paired-plane-minrank-bracket-audit/CERTIFICATE.json" + matching_path = "research/paired-plane-scalar-mask-obstruction/PR1825-CERTIFICATE.json" + block_result_path = "research/paired-plane-block-rank/RESULT.json" + archive_path = "research/community-frontier1094-audit/selected-replay.tar.gz" + cert_raw = (ROOT / cert_path).read_bytes() + matching_raw = (ROOT / matching_path).read_bytes() + block_result_raw = (ROOT / block_result_path).read_bytes() + assert hashlib.sha256(cert_raw).hexdigest() == "6f5d3478290156c4fe703104572cc3aa593ad50079476ae08c942833714e3179" + assert hashlib.sha256(matching_raw).hexdigest() == "4fd648f7b5178bff5441bf364d58234b7bc1a43b924bc6da03013c948f1473b1" + assert hashlib.sha256(block_result_raw).hexdigest() == "8b78968378d7ed824ac2418fe40b36db04d9522c117349778655191b4ee10d6d" + cert = json.loads(cert_raw) + matching = json.loads(matching_raw) + block_result = json.loads(block_result_raw) + assert cert["result"]["min_scalar_fitting_rank"] == 49 + assert block_result["status"] == "PASS_PAIRED_PLANE_BLOCK_RANK" + assert block_result["theorem"].startswith("minimum rank is 49*d") + archive = (ROOT / archive_path).read_bytes() + member_name = "candidate/strict/global/base/work/complex-nine-native/DATA-PHASES.json" + with tarfile.open(fileobj=io.BytesIO(archive), mode="r:gz") as tar: + member = tar.extractfile(member_name) + assert member is not None + payload = member.read() + assert hashlib.sha256(payload).hexdigest() == "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + labels_by_port = {row["port"]: row["q"] for row in json.loads(payload)["recipes"]} + assert sorted(labels_by_port) == list(range(112)) + labels = [labels_by_port[i] for i in range(112)] + pairs = matching["matching"] + assert len(pairs) == 56 and sorted(i for pair in pairs for i in pair) == list(range(112)) + owner = [-1] * 112 + planes = [] + for plane_id, (left, right) in enumerate(pairs): + a, b = labels[left], labels[right] + dot = lambda x, y: (x & y).bit_count() & 1 + assert dot(a, a) == dot(b, b) == 1 and dot(a, b) == 0 + owner[left] = owner[right] = plane_id + planes.append((a, b)) + supports = cert["rank49_supports"] + assert len(supports) == 49 and sorted(i for support in supports for i in support) == list(range(112)) + profile: Counter[int] = Counter() + for support in supports: + plane_ids = [owner[port] for port in support] + assert len(set(plane_ids)) == len(plane_ids) + for i, plane_i in enumerate(plane_ids): + for plane_j in plane_ids[i + 1:]: + assert all(dot(x, y) == 0 + for x in planes[plane_i] for y in planes[plane_j]) + vectors = [v for plane_id in plane_ids for v in planes[plane_id]] + gram = [[dot(x, y) for y in vectors] for x in vectors] + # A permitted support consists of mutually orthogonal nondegenerate + # planes, so its complete port-space charge is the rank of this Gram + # matrix, exactly twice the support size. + assert rank_mod2(gram) == 2 * len(support) + profile[2 * len(support)] += 1 + assert dict(sorted(profile.items())) == {2: 2, 4: 31, 6: 16} + assert sum(rank * count for rank, count in profile.items()) == 224 + return { + "scalar_factor_count": 49, + "support_size_histogram": {str(k // 2): n for k, n in sorted(profile.items())}, + "port_space_copy_profile": {str(k): n for k, n in sorted(profile.items())}, + "port_space_mass_per_payload_copy": 224, + "scope": "Pinned disjoint-support fit, priced by full port-space Gram ranks. These ranks are not established as recursive child ranks or native COPY costs; this conversion is conditional and not a lower bound on every decoder.", + } + + +def block_anchor_case(base_mass: int, blocks: int, fee_per_block: int, + copies: int, centre: int) -> dict: + """Target moment under an explicit rank-one-equivalent fee sensitivity. + + Scalar ADDs are not part of the exponent profile. This fee parameter is + retained only to show how a separately established interface cost would + affect the moment if it were translated to rank-one-equivalent units. + """ + unpaid = 2 * copies + local: dict[int, Q | int] = {51: Q(base_mass, 51)} + if fee_per_block: + local[1] = blocks * fee_per_block + if centre: + # Retaining the centre also retains its eight rank-8 children. + local[8] = 8 + for rank, count in ((2, 2 * copies), (4, 31 * copies), (6, 16 * copies)): + local[rank] = count + return result_case(local, centre, unpaid) + + +def block_mass_excess(base_mass: int, copies: int) -> Q: + """Paid rank mass minus coverage capacity, with scalar ADDs separate.""" + unpaid = 2 * copies + local_mass = Q(base_mass + 224 * copies) + coverage = Q(73 - unpaid) * Q(896, 9) + return local_mass - coverage + + +def maximum_block_anchor_fee(base_mass: int, blocks: int, + copies: int, centre: int) -> tuple[int, int] | None: + """Largest integer per-block ADD fee after the d-fold plane decoder.""" + def passes(fee: int) -> bool: + try: + return block_anchor_case(base_mass, blocks, fee, copies, centre)["below_one"] + except ValueError: + return False + + if not passes(0): + return None + lo, hi = 0, 1000 + while lo + 1 < hi: + mid = (lo + hi) // 2 + if passes(mid): + lo = mid + else: + hi = mid + return lo, hi + + +def main() -> None: + selected = read_json("certificates/selected-result.json") + ceiling = read_json("research/complex-local-word-ceiling/RESULT.json") + anchor = read_json("research/complex-two-output-sum-anchor-seed65ce19/RESULT.json") + dirty_anchor = read_json("research/complex-dirty-output-temporary-sum-anchor/RESULT.json") + five_plane = read_json("research/five-plane-port-p112-seed1f7fdfe4/RESULT.json") + five_plane_sources = read_json("research/five-plane-port-p112-seed1f7fdfe4/SOURCES.json") + assert selected["decimal"] == "0.001672660197076918" + assert ceiling["status"] == "PASS_COMPLEX_LOCAL_WORD_CEILING" + assert anchor["status"] == "PASS_TWO_OUTPUT_TEMPORARY_SUM_ANCHOR" + assert dirty_anchor["status"] == "PASS_DIRTY_OUTPUT_TEMPORARY_SUM_ANCHOR" + assert five_plane["status"] == "completed_local_algebraic_construction" + + m = ceiling["model"]["m"] + families = Q(ceiling["model"]["live_families_per_call"]) + stages = ceiling["model"]["stages"] + centre = ceiling["model"]["centre_per_call"] + assert (m, families, stages, centre) == (73, Q(896, 9), 9, 64) + assert anchor["cost_screen"]["block_width_q"] == 112 + assert anchor["cost_screen"]["direct_rank_one_children_per_block"] == 332 + assert anchor["cost_screen"]["anchored_rank_one_children_per_block"] == 112 + assert anchor["cost_screen"]["max_direct_blocks_in_rank_one_profile"] == 7 + archive_path = ROOT / "research/community-frontier1094-audit/selected-replay.tar.gz" + archive_sha = hashlib.sha256(archive_path.read_bytes()).hexdigest() + archive_source = next( + x for x in five_plane_sources["files"] + if x["path"] == "research/community-frontier1094-audit/selected-replay.tar.gz" + ) + assert archive_sha == archive_source["sha256"] == "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + + # The predecessor's selected profile is source-bound in its result. Seven + # q=112 blocks replace 332 rank-one children by 112 each. Keep e=112 only + # as a rank-one-equivalent tariff sensitivity; scalar ADDs are screened + # separately below. + selected_profile = {int(r): int(n) for r, n in anchor["cost_screen"]["selected_profile"].items()} + blocks = anchor["cost_screen"]["max_direct_blocks_in_rank_one_profile"] + affine_fee = anchor["cost_screen"]["affine_additions_per_block"] + direct = anchor["cost_screen"]["direct_rank_one_children_per_block"] + replacement = anchor["cost_screen"]["anchored_rank_one_children_per_block"] + anchored = dict(selected_profile) + anchored[1] = anchored[1] - blocks * direct + blocks * (replacement + affine_fee) + assert anchored == {1: 1656, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} + + # Grant complete centre deletion: remove the eight rank-8 centre copies + # and its separate 64-unit call charge. Then grant a still more favorable + # consumer by fractionally moving every remaining unit of rank mass to 16. + anchor_centre_free = {r: n for r, n in anchored.items() if r != 8} + anchor_mass = sum(r * n for r, n in anchor_centre_free.items()) + assert anchor_mass == 4766 + rank16 = {16: Q(anchor_mass, 16)} + base_rank1 = anchored[1] - blocks * affine_fee + base_mass = sum(r * n for r, n in {**anchored, 1: base_rank1}.items() if r != 8) + assert base_mass == 3982 + dirty_budget = dirty_anchor["budget"] + dirty_profile = {int(r): int(n) for r, n in + dirty_budget["hypothetical_profile_after_seven_blocks"].items()} + assert dirty_profile == {1: 872, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} + assert sum(r * n for r, n in dirty_profile.items() if r != 8) == base_mass + scalar_invoice = dirty_budget["separate_scalar_invoice"] + assert scalar_invoice["added_unit_addition_macros_per_call"] == 1568 + assert int(scalar_invoice["new_local_primitive_bound_upper"]) < int(scalar_invoice["guard"]) + unchanged_bit_a = Q(dirty_budget["local_complex_ceiling"]["unchanged_bit_endpoint"]) + unchanged_bit_kappa = unchanged_bit_a / (1 + unchanged_bit_a) + assert str(unchanged_bit_a) == "1733427039589844234749/1000000000000000000000000" + + # Compare the existing five-plane P112 algebraic port decoder, whose + # RESULT/SOURCES bind it to the exact same selected replay archive. This + # screen imports its recorded profile; the old decoder verifier is not + # represented as independently replayed here. + p112 = five_plane["decoder"] + p112_profile = {int(r): int(n) for r, n in p112["local_profile"].items()} + assert p112["local_mass"] == 5640 + assert sum(r * n for r, n in p112_profile.items()) == 5640 + assert five_plane["local_screen"]["law"] == "unpaid=5" + assert five_plane["local_screen"]["max_total_rank1_equivalent_charge"] == 275 + p112_actual = result_case(p112_profile, 64, 5) + p112_local_only = local_only_moment(p112_profile) + p112_any_unpaid = first_passing_unpaid(p112_profile, 0) + p112_rank16 = {16: Q(5640, 16)} + p112_rank16_u5_free = result_case(p112_rank16, 0, 5) + p112_rank16_u5_centre = result_case(p112_rank16, 64, 5) + p112_rank16_first_free = first_passing_unpaid(p112_rank16, 0) + p112_rank16_first_centre = first_passing_unpaid(p112_rank16, 64) + p112_rank_u5_free = first_passing_local_rank(5640, 5, 0) + p112_rank_u5_centre = first_passing_local_rank(5640, 5, 64) + assert not p112_actual["below_one"] and not p112_rank16_u5_free["below_one"] + assert p112_local_only[0] > 1 and p112_any_unpaid is None + assert not p112_rank16_u5_centre["below_one"] + assert (p112_rank16_first_free, p112_rank16_first_centre) == (11, 12) + assert (p112_rank_u5_free, p112_rank_u5_centre) == (37, 41) + + # Baseline has no passing unpaid count even after deleting its centre while + # keeping the local word fixed; check the most permissive valid u. + baseline_centre_free = {r: n for r, n in selected_profile.items() if r != 8} + baseline_max_u = max_feasible_unpaid(baseline_centre_free, 0) + baseline_at_max = result_case(baseline_centre_free, 0, baseline_max_u) + assert baseline_max_u == 17 + assert not baseline_at_max["below_one"] + + # Boundary checks for the anchor-only and anchor+rank16 models. + anchor_u23 = result_case(anchor_centre_free, 0, 23) + anchor_u24 = result_case(anchor_centre_free, 0, 24) + assert not anchor_u23["below_one"] and anchor_u24["below_one"] + rank16_u9 = result_case(rank16, 0, 9) + rank16_u10 = result_case(rank16, 0, 10) + rank16_u10_centre = result_case(rank16, 64, 10) + rank16_u11_centre = result_case(rank16, 64, 11) + assert not rank16_u9["below_one"] and rank16_u10["below_one"] + assert not rank16_u10_centre["below_one"] and rank16_u11_centre["below_one"] + + # A small discrete frontier shows the tradeoff between how much the + # unpaid coverage law changes and how high the local consumer can raise + # all 4,766 units of mass. Idle remainder remains at the legal cap 51. + frontier = [ + unpaid_frontier(anchor_mass, rank, c) + for rank in (16, 32, 48, 51) + for c in (0, 64) + ] + assert [x["first_passing_unpaid"]["unpaid_coordinates"] for x in frontier] == [ + 10, 11, 6, 7, 4, 4, 3, 4 + ] + rank_thresholds = { + "u4_centre_free": first_passing_local_rank(anchor_mass, 4, 0), + "u4_centre_retained": first_passing_local_rank(anchor_mass, 4, 64), + "u10_centre_free": first_passing_local_rank(anchor_mass, 10, 0), + "u10_centre_retained": first_passing_local_rank(anchor_mass, 10, 64), + } + assert rank_thresholds == { + "u4_centre_free": 42, + "u4_centre_retained": 47, + "u10_centre_free": 15, + "u10_centre_retained": 17, + } + e10_free = maximum_passing_fee(base_mass, blocks, 10, 0) + e11_centre = maximum_passing_fee(base_mass, blocks, 11, 64) + fee_boundaries = { + "u10_centre_free": { + "passing": fee_case(base_mass, blocks, e10_free[0], 10, 0), + "first_failing": fee_case(base_mass, blocks, e10_free[1], 10, 0), + "extra_allowance_after_112_affine_units": e10_free[0] - affine_fee, + }, + "u11_centre_retained": { + "passing": fee_case(base_mass, blocks, e11_centre[0], 11, 64), + "first_failing": fee_case(base_mass, blocks, e11_centre[1], 11, 64), + "extra_allowance_after_112_affine_units": e11_centre[0] - affine_fee, + }, + } + assert e10_free == (170, 171) + assert e11_centre == (207, 208) + assert fee_boundaries["u10_centre_free"]["extra_allowance_after_112_affine_units"] == 58 + assert fee_boundaries["u11_centre_retained"]["extra_allowance_after_112_affine_units"] == 95 + + # Try the explicit block-valued endpoint: tensor d copies of the pinned + # 49-support paired-plane fit. The 110-update dirty-target floor and the + # anchor's 224-add schedule are scalar operations, not rank-one-equivalent + # exponent costs. The known anchor scalar invoice is screened separately; + # the decoder's own linear setup/cleanup remains unpriced. + plane_decoder = paired_plane_port_charge() + assert plane_decoder["port_space_copy_profile"] == {"2": 2, "4": 31, "6": 16} + assert plane_decoder["port_space_mass_per_payload_copy"] == 224 + min_dirty_updates = anchor["cost_screen"]["block_width_q"] - 2 + assert min_dirty_updates == 110 + assert dirty_anchor["q112"]["affine_additions"] == 224 + assert scalar_invoice["added_unit_addition_macros_per_call"] == blocks * 224 + + zero_fee_endpoint = [] + for copies in range(1, 8): + centre_rows = { + str(centre): block_anchor_case(base_mass, blocks, 0, copies, centre) + for centre in (0, 64) + } + zero_fee_endpoint.append({ + "payload_copies": copies, + "unpaid_coordinates": 2 * copies, + "scalar_dirty_update_floor_per_block": min_dirty_updates, + "zero_rank_one_equivalent_fee_moments": centre_rows, + "rank_one_equivalent_fee_frontier_per_block": { + str(centre): maximum_block_anchor_fee(base_mass, blocks, + copies, centre) + for centre in (0, 64) + }, + }) + assert [x["zero_rank_one_equivalent_fee_moments"]["0"]["below_one"] + for x in zero_fee_endpoint] == [False, False, True, True, True, True, True] + assert [x["zero_rank_one_equivalent_fee_moments"]["64"]["below_one"] + for x in zero_fee_endpoint] == [False, False, True, True, True, True, True] + assert [x["rank_one_equivalent_fee_frontier_per_block"] for x in zero_fee_endpoint[:5]] == [ + {"0": None, "64": None}, + {"0": None, "64": None}, + {"0": (28, 29), "64": (8, 9)}, + {"0": (62, 63), "64": (42, 43)}, + {"0": (96, 97), "64": (76, 77)}, + ] + d3_centre_free = zero_fee_endpoint[2]["zero_rank_one_equivalent_fee_moments"]["0"] + d3_centre_retained = zero_fee_endpoint[2]["zero_rank_one_equivalent_fee_moments"]["64"] + assert Q(d3_centre_free["moment_interval_at_a_1_over_9"][1]) < 1 + assert Q(d3_centre_retained["moment_interval_at_a_1_over_9"][1]) < 1 + + # Preserve the old e=110 result only as an intentionally pessimistic + # rank-one-equivalent tariff sensitivity; it is not the project's scalar + # operation cost model. + stacked_endpoint = [] + for copies in range(1, 6): + centre_rows = { + str(centre): block_anchor_case(base_mass, blocks, min_dirty_updates, + copies, centre) + for centre in (0, 64) + } + assert all(Q(row["moment_interval_at_a_1_over_9"][0]) > 1 + for row in centre_rows.values()) + stacked_endpoint.append({ + "payload_copies": copies, + "unpaid_coordinates": 2 * copies, + "scalar_dirty_update_floor_per_block": min_dirty_updates, + "if_mispriced_as_rank_one_equivalent_fee_110_per_block": centre_rows, + }) + assert [x["rank_one_equivalent_fee_frontier_per_block"] for x in zero_fee_endpoint[:5]] == [ + {"0": None, "64": None}, + {"0": None, "64": None}, + {"0": (28, 29), "64": (8, 9)}, + {"0": (62, 63), "64": (42, 43)}, + {"0": (96, 97), "64": (76, 77)}, + ] + # With scalar ADDs separate, the exponent profile remains mass-feasible + # through d=7; at d=8 even its zero-tariff profile exceeds capacity. + d8_excess = block_mass_excess(base_mass, 8) + per_copy_excess = Q(224) + 2 * families + assert d8_excess == Q(298, 3) and per_copy_excess == Q(3808, 9) > 0 + + # Positive control: the same highly optimistic rank-16 profile does pass + # the repository's much smaller planning target a=1/99 with only one + # unpaid coordinate when the centre is free. + planning = C.relax(rank16, 73, 896, 9, 0, Q(1, 99), unpaid=1) + assert planning[1] < 1 + + result = { + "status": "PASS_KAPPA010_COMPLEX_LEVER_FLOOR; scoped budget screen only", + "selected_kappa": selected["decimal"], + "target_kappa": "1/10", + "target_primitive_saving_a": "1/9", + "model": { + "m": 73, + "families_per_call": str(families), + "stages": stages, + "rank_cap": 51, + "selected_centre_charge": centre, + "target_moment_engine": "exact outward rational intervals from complex-local-word-ceiling/ceiling.py", + }, + "baseline_local_profile": {str(r): n for r, n in sorted(selected_profile.items())}, + "baseline_centre_free_max_feasible_unpaid": baseline_max_u, + "baseline_at_max_unpaid": baseline_at_max, + "seven_anchor_hypothesis": { + "blocks": blocks, + "rank_one_additions_per_block": affine_fee, + "affine_charge_assumption": "112 additions are charged as 112 rank-one-equivalent units per block", + "profile_before_centre_deletion": {str(r): n for r, n in sorted(anchored.items())}, + "centre_free_profile": {str(r): n for r, n in sorted(anchor_centre_free.items())}, + "centre_free_rank_mass": anchor_mass, + "rank16_fractional_profile": {"16": str(rank16[16])}, + "anchor_only_boundary": {"u23": anchor_u23, "u24": anchor_u24}, + "rank16_boundary_centre_free": {"u9": rank16_u9, "u10": rank16_u10}, + "rank16_boundary_centre_retained": {"u10": rank16_u10_centre, "u11": rank16_u11_centre}, + "first_passing_unpaid_centre_free": first_passing_unpaid(rank16, 0), + "first_passing_unpaid_centre_retained": first_passing_unpaid(rank16, 64), + "uniform_rank_frontier_at_target": frontier, + "minimum_uniform_local_rank_at_fixed_unpaid": rank_thresholds, + "fee_boundaries_with_fractional_rank16_consumer": fee_boundaries, + }, + "five_plane_p112_predecessor_screen": { + "source_result": "research/five-plane-port-p112-seed1f7fdfe4/RESULT.json", + "source_replay_archive_sha256": archive_sha, + "local_profile": {str(r): n for r, n in sorted(p112_profile.items())}, + "reported_local_unpaid_count": 5, + "actual_profile_at_a_1_over_9": p112_actual, + "local_children_only_lower_bound_interval": [str(p112_local_only[0]), str(p112_local_only[1])], + "local_children_only_moment_approx": format(float((p112_local_only[0] + p112_local_only[1]) / 2), ".12f"), + "passes_for_any_integer_unpaid_with_original_local_profile": p112_any_unpaid is not None, + "fractional_rank16_all_mass_u5_centre_free": p112_rank16_u5_free, + "fractional_rank16_all_mass_u5_centre_retained": p112_rank16_u5_centre, + "first_passing_unpaid_at_rank16": { + "centre_free": p112_rank16_first_free, + "centre_retained": p112_rank16_first_centre, + }, + "minimum_uniform_local_rank_at_u5": { + "centre_free": p112_rank_u5_free, + "centre_retained": p112_rank_u5_centre, + }, + "scope": "The predecessor RESULT is screened as a pinned profile; its algebraic decoder is not replayed by this package.", + }, + "planning_target_positive_control": { + "a": "1/99", + "rank16_profile_unpaid": 1, + "centre_mass": 0, + "moment_interval": [str(planning[0]), str(planning[1])], + "below_one": planning[1] < 1, + }, + "tensorized_paired_plane_anchor_screen": { + "predecessor_support_fit": plane_decoder, + "payload_copy_to_unpaid_rule": "u=2d", + "base_mass_repacked_at_rank": 51, + "base_mass_before_endpoint_and_dirty_updates": base_mass, + "anchor_blocks": blocks, + "dirty_output_anchor_source_result": "research/complex-dirty-output-temporary-sum-anchor/RESULT.json", + "dirty_output_anchor_scalar_invoice": scalar_invoice, + "unchanged_bit_side_primitive_endpoint_a": str(unchanged_bit_a), + "unchanged_bit_side_kappa_cap": str(unchanged_bit_kappa), + "unchanged_bit_side_kappa_cap_decimal": format(float(unchanged_bit_kappa), ".15f"), + "one_target_dirty_update_floor_per_block_scalar_additions": min_dirty_updates, + "actual_dirty_anchor_additions_per_block": 224, + "separate_scalar_cost_model": { + "rank_one_equivalent_fee_in_exponent_profile": 0, + "known_seven_block_anchor_additions_are_within_selected_scalar_guard": True, + "decoder_linear_setup_cleanup_cost": "unknown; not in the anchor scalar invoice", + "interpretation": "ADDs are screened in the scalar compiler envelope; they are not automatically rank-one-equivalent child costs.", + }, + "recursive_rank_mapping_assumption": "For this conditional moment screen only, the 2s port-space Gram rank of a support of size s is inserted as a recursive child rank. The paired-plane fitting-rank theorem does not establish this native/profile mapping.", + "d_1_through_7_zero_fee_target_moments": zero_fee_endpoint, + "first_passing_d_centre_free": 3, + "first_passing_d_centre_retained": 3, + "d_1_through_5_if_charged_110_rank_one_equivalent_units_per_block": stacked_endpoint, + "d8_zero_fee_mass_excess": str(d8_excess), + "mass_excess_growth_per_extra_copy": str(per_copy_excess), + "conclusion": "With scalar ADDs separate and the 2s support port-space charge conditionally treated as recursive child rank, the relaxed a=1/9 moment first passes at d=3 (0.984346 centre-free, 0.995605 with centre); d=1,2 fail and d=8 is mass-infeasible. The 49d fitting-rank theorem does not establish this native/profile mapping. The earlier d=1..5 failure used a hypothetical rank-one-equivalent ADD tariff and is retained only as sensitivity.", + "scope": "The exact paired-plane fitting matrix and dirty-output anchor are not composed into a selected-provider source block. Port-space support charges are not proven recursive child ranks or native COPY costs; query preparation, payloads, wrappers, frames, precision, tape, restoration and whole-supplier transfer remain unpriced. No new kappa is established.", + }, + "scope": [ + "A failure rejects only the stated selected-profile or seven-anchor budget models; it is not a barrier for other algorithms.", + "The passing u=10 case places all 4,766 units of paid local rank mass into fractional rank-16 children and grants centre removal and a changed coverage law for free.", + "No source alignment, full dirty endpoint, rank-16 decoder, restoration schedule, physical invoice, supplier transfer, or new kappa is constructed.", + "The hypothetical 112-unit block fee prices affine additions only; all other interface charges are waived.", + "The d-fold screen separates scalar ADD guard costs from the exponent rank profile; the rank-one-equivalent fee rows are tariff sensitivities only.", + "The conditional d=3 moment pass uses a fractional rank-51 repacking of remaining mass and assumes the port-space support charge is a recursive child rank; it waives decoder payload implementation and source placement and is not an implementation or kappa improvement.", + "The existing bit-side endpoint remains unchanged and still caps the selected complete construction far below 0.1.", + ], + } + (HERE / "RESULT.json").write_text(json.dumps(result, indent=2) + "\n") + print(result["status"]) + print(" selected word, centre-free at its largest feasible u:", baseline_at_max["moment_approx"]) + print(" anchor-only boundary: u=23 fails at", anchor_u23["moment_approx"], "; u=24 passes at", anchor_u24["moment_approx"]) + print(" rank-16 centre-free boundary: u=9 fails at", rank16_u9["moment_approx"], "; u=10 passes at", rank16_u10["moment_approx"]) + print(" retaining centre shifts rank-16 boundary to u=", first_passing_unpaid(rank16, 64)) + print(" with u=4, minimum uniform local rank:", rank_thresholds["u4_centre_free"], "centre-free,", rank_thresholds["u4_centre_retained"], "with centre") + print(" max rank-one-equivalent fee per block: e=", e10_free[0], "at u=10/centre-free; e=", e11_centre[0], "at u=11/centre-retained") + print(" five-plane u=5 decoder profile at a=1/9:", p112_actual["moment_approx"], "; rank-16 requires u=", p112_rank16_first_free, "centre-free or", p112_rank16_first_centre, "with centre") + print(" five-plane paid local terms alone:", format(float((p112_local_only[0] + p112_local_only[1]) / 2), ".12f"), ">1") + print(" paired-plane d=3 with separate scalar ADD invoice:", d3_centre_free["moment_approx"], "centre-free;", d3_centre_retained["moment_approx"], "with centre") + + +if __name__ == "__main__": + main() diff --git a/research/kappa010-rank-cap-floor/README.md b/research/kappa010-rank-cap-floor/README.md new file mode 100644 index 0000000000..31422dfff3 --- /dev/null +++ b/research/kappa010-rank-cap-floor/README.md @@ -0,0 +1,73 @@ +# Exact rank-cap floor for a κ = 0.1 target + +**Scoped negative budget result. No supplier or κ improvement is claimed.** The selected conditional result remains κ = 0.001672660197076918. + +## Result + +The retained transfer is `κ = a/(1+a)`, so κ = 1/10 corresponds to the primitive target `a = 1/9`. For any charged child of rank `r < m`, its moment contribution per unit rank mass at that target is + +\[ +\frac{(r/m)^{8/9}}{r}=m^{-8/9}r^{-1/9}, +\] + +which decreases with `r`. If all child ranks are at most `R`, total paid rank mass is `P`, and `w` families are served per call, every histogram therefore has moment at least + +\[ +F=\frac{P}{Rw}\left(\frac Rm\right)^{8/9}. +\] + +Under the current coverage law `P = (m-u)w + c`, write `S=P/w=m-u+c/w`. Then `F^9 = S^9/(R m^8)`, so the strict comparison with one reduces to exact rational arithmetic. We also check the more favorable case `c=0`, which deletes the positive centre/copy mass entirely. + +At the largest rank admitted by the current depth envelopes, even the centre-free, one-unpaid-coordinate lower bound exceeds one on both suppliers: + +| Supplier | `m` | Current maximum `R` | Exact lower-bound comparison at `a=1/9` | Approx. `F` | +|---|---:|---:|---|---:| +| Bit | 64 | 53 (depth 4) | `63^9 > 53·64^8` | 1.005219793354 | +| Complex | 73 | 51 (depth 2) | `72^9 > 51·73^8` | 1.026397274382 | + +Because this is already the cheapest histogram allowed by the aggregate law and cap, every actual histogram in that model costs at least this much. The moment increases with `a`, so neither supplier can support `a ≥ 1/9`, and hence neither can support κ > 0.1, while retaining one unpaid coordinate and these maximum child ranks. Keeping the existing centre charge only raises the floors to approximately 1.015407831801 (bit) and 1.035561535761 (complex). + +The closest finite two-unpaid complex candidate in the local archive is the paired-plane identity fit: it reports `u=2`, centre charge `c=112`, `m=73`, `w=896/9`, and idle cap 51. At the 0.1 target its exact lower-bound parameter is `S=577/8`, with `(S^9)/(51·73^8)>1` and `F≈1.028179214095`. Thus even granting that local endpoint and then moving *all* mass to rank 51 cannot reach κ>0.1; the aggregate floor with `c=112` needs at least four unpaid coordinates. The paired-plane package itself reports only a favorable local ceiling `a≈0.00408`, and leaves routing, restoration, precision and the bit side open. + +The exact threshold screens identify what could reopen the budget: + +| Supplier | Current cap; centre kept | Minimum unpaid coordinates for the *ideal floor* to drop below 1 | With one unpaid coordinate, minimum rank after deleting centre | Halving-guard depth first allowing that rank | +|---|---|---:|---:|---:| +| Bit | `R=53`, `c=63` | 2 | 56 | 6 | +| Complex | `R=51`, `c=64` | 4 | 65 | 6 | + +If the centre/copy charge is also removed, the minimum unpaid counts become 2 (bit) and 3 (complex). If it stays, the one-unpaid rank requirements rise to 61 and 70, requiring halving depths 15 and 17, respectively. Every rank and depth boundary is checked with exact integer or rational comparisons in [verify.py](verify.py). + +These passing threshold rows are **necessary budget openings only**. They place all paid rank mass at the maximum rank, which is an intentionally generous relaxation and not a decodable local word. The deeper guard depths have not been shown to fit their row-coefficient invoices. No second unpaid coordinate, high-rank local consumer, physical endpoint, dirty-state restoration, bit/complex composition, or complete supplier has been constructed here. The result is scoped to the two current coverage identities and their rank/depth envelopes; a different outer algorithm remains open. + +## Fixed bit word with two unpaid coordinates + +The all-mass-at-cap row can hide a large local-profile gap. I also evaluated the source-bound selected bit histogram `{1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19}` (rank mass 5,129) under the hypothetical `u=2` coverage law, with the best admitted idle cap `R=53`. At `a=1/9` its exact outward-rational moment is **1.365696** with the existing centre charge `c=63`, or **1.355508** after deleting that charge. So changing coverage alone does not rescue the selected bit word. + +For comparison, the necessary all-mass-at-cap floor with `u=2` and `c=63` is only **0.999452**. Holding the selected local rank mass at 5,129 and fractionally repacking it at one uniform local rank, the first passing rank is **53** with the centre retained; rank 52 gives 1.001209. If the centre is deleted, rank 48 first passes (0.998447), while rank 47 gives 1.000411. This quantifies the missing mechanism: a bit-side endpoint must both leave a second coordinate unpaid and replace the selected low-rank local profile with children near the maximum admitted rank. It is a scoped profile screen, not a universal obstruction or a constructed supplier. + +## Reproduction + +```sh +python3.12 -I -B research/kappa010-rank-cap-floor/verify.py +python3.12 scripts/research_package.py --package research/kappa010-rank-cap-floor --check-only +python3.12 scripts/research_package.py --package research/kappa010-rank-cap-floor +``` + +The verifier uses only the standard library. It binds the selected record and the bit/complex budget receipts listed in [SOURCES.json](SOURCES.json). Its exact acceptance decision is the sign of `S^9/(R m^8)-1`; displayed decimal moments are orientation only. + +## Open next questions + +1. **Can two unpaid coordinates be carried through one complete dirty-input endpoint on the bit side?** This is the least aggregate change that opens the bit floor at `R=53`, but the actual word must preserve both coordinates and pay the consumer, frame, and restoration costs. First step: trace a named two-coordinate candidate through one full selected call. Blocker: the current endpoint contract and cost invoice have not been changed. +2. **Can the complex supplier leave four coordinates unpaid while retaining the current centre charge?** Four is the exact optimistic threshold at `R=51`; it does not follow from a local two-output anchor. First step: derive the replacement coverage identity for one full outer family, including delivery and restoration. Blocker: the anchor source columns are dirty and the centre consumer is still paid. +3. **Can the outer row invoice admit depth six, or a different construction with equivalent high-rank children?** Depth six is only the guard threshold with the centre removed and one unpaid coordinate. First step: evaluate the exact row coefficient and all non-rank charges at that depth. Blocker: no such invoice is currently available, and passing the guard alone does not construct a supplier. + +## Scope, overlap and credit + +This refines the `coverage-law-change` card for the user-set target κ > 0.1. It tests the cheapest possible aggregate moment under the pinned coverage laws before searching for a mechanism. It does not prove that changing coverage or depth is impossible, and it does not replace the card's complete-instance acceptance gate. Local overlap surfaced the earlier `kappa01-complex-target-screen`, several paired-plane coverage-law packages, and the concrete paired-plane identity fit; this result contributes the exact shared rank-cap floor and strict threshold table for the new 0.1 target. + +The bit-side predecessor is Sagar Thakrar's `bit-revision3-levers-seed03`, building on DreamingOfClouds' PR589 / `format-limits`, eumemic's PR555, and the PR510 / PR442 template lineage. The complex predecessor is Douglas Colkitt's `complex-local-word-ceiling`, building on PR1012, the selected #1094 construction, and the credited frame/ownership chain. No predecessor artifacts were modified. The task began on `d8e0f83f00191df62174b641e9fff055c357f641`; canonical main was refreshed at `18aacb215fc3717b06be8ceb9fca62aeca0d3e99` (priority revision 6) on 2026-10-17. The only relevant guidance change adds a P104 precision-map pointer; the selected record and quantitative predecessor receipts are unchanged; the used κ conversion is unchanged. + +The overlap helper refreshed open PRs on 2026-10-17 at 02:00:46 UTC: 262 records with complete pagination, including PR #3093's fixed-profile screens and the present target work. Its complete 1,866-discussion snapshot was last fetched at 01:23:03 UTC and is stale for a new expansion. Earlier checks surfaced PRs #3064 and #3097 and Discussions #1163, #1166 and #1167. The fixed-bit-profile result extends this package's own aggregate screen; no novelty is claimed. Recheck active discussions before opening another research round. + +Prepared by Codex with OpenAI assistance. New work is Apache-2.0. diff --git a/research/kappa010-rank-cap-floor/RESULT.json b/research/kappa010-rank-cap-floor/RESULT.json new file mode 100644 index 0000000000..8015a60919 --- /dev/null +++ b/research/kappa010-rank-cap-floor/RESULT.json @@ -0,0 +1,277 @@ +{ + "status": "PASS_KAPPA010_RANK_CAP_FLOOR; scoped aggregate-budget obstruction only", + "selected_kappa": "0.001672660197076918", + "target_kappa": "1/10", + "target_primitive_saving_a": "1/9", + "comparison": "For a=1/9 the ninth power of the optimistic moment floor is S^9/(R*m^8), checked exactly.", + "bit": { + "supplier": "bit", + "m": 64, + "families_per_call": "296/3", + "centre_mass_per_call": "63", + "current_depth_envelope": 4, + "maximum_rank_at_envelope": 53, + "one_unpaid_centre_free": { + "m": 64, + "rank_cap": 53, + "unpaid_coordinates": 1, + "centre_mass_per_call": "0", + "families_per_call": "296/3", + "mass_per_family_S": "63", + "moment_lower_bound_approx": "1.005219793354", + "moment_lower_bound_ninth_power": "15633814156853823/14918173765664768", + "passes_necessary_budget": false + }, + "one_unpaid_centre_charged": { + "m": 64, + "rank_cap": 53, + "unpaid_coordinates": 1, + "centre_mass_per_call": "63", + "families_per_call": "296/3", + "mass_per_family_S": "18837/296", + "moment_lower_bound_approx": "1.015407831801", + "moment_lower_bound_ninth_power": "298610888692089971280432427059725948277/260220232763007858035455258403440427008", + "passes_necessary_budget": false + }, + "centre_free_minimum_unpaid_at_cap": 2, + "charged_minimum_unpaid_at_cap": 2, + "one_unpaid_minimum_rank_centre_free": 56, + "one_unpaid_minimum_depth_centre_free": 6, + "one_unpaid_minimum_rank_centre_charged": 61, + "one_unpaid_minimum_depth_centre_charged": 15, + "centre_free_boundary": { + "previous_unpaid_count_fails": { + "m": 64, + "rank_cap": 53, + "unpaid_coordinates": 1, + "centre_mass_per_call": "0", + "families_per_call": "296/3", + "mass_per_family_S": "63", + "moment_lower_bound_approx": "1.005219793354", + "moment_lower_bound_ninth_power": "15633814156853823/14918173765664768", + "passes_necessary_budget": false + }, + "minimum_unpaid_count_passes": { + "m": 64, + "rank_cap": 53, + "unpaid_coordinates": 2, + "centre_mass_per_call": "0", + "families_per_call": "296/3", + "mass_per_family_S": "62", + "moment_lower_bound_approx": "0.989263923619", + "moment_lower_bound_ninth_power": "26439622160671/29137058136064", + "passes_necessary_budget": true + } + }, + "charged_boundary": { + "previous_unpaid_count_fails": { + "m": 64, + "rank_cap": 53, + "unpaid_coordinates": 1, + "centre_mass_per_call": "63", + "families_per_call": "296/3", + "mass_per_family_S": "18837/296", + "moment_lower_bound_approx": "1.015407831801", + "moment_lower_bound_ninth_power": "298610888692089971280432427059725948277/260220232763007858035455258403440427008", + "passes_necessary_budget": false + }, + "minimum_unpaid_count_passes": { + "m": 64, + "rank_cap": 53, + "unpaid_coordinates": 2, + "centre_mass_per_call": "63", + "families_per_call": "296/3", + "mass_per_family_S": "18541/296", + "moment_lower_bound_approx": "0.999451962065", + "moment_lower_bound_ninth_power": "258939547752501435258355259711884040461/260220232763007858035455258403440427008", + "passes_necessary_budget": true + } + } + }, + "bit_fixed_profile_two_unpaid": { + "source_result": "research/bit-revision3-levers-seed03/RESULT.json", + "selected_local_profile": { + "1": "1323", + "2": "1342", + "3": "79", + "4": "44", + "5": "102", + "6": "11", + "7": "19" + }, + "local_rank_mass": "5129", + "actual_profile_at_u2_R53": { + "0": { + "unpaid_coordinates": 2, + "centre_mass_per_call": 0, + "idle_rank_cap": 53, + "moment_interval_at_a_1_over_9": [ + "2178217091209413888461791983209385925423752286421371401491191/1606938044258990275541962092341162602522202993782792835301376", + "2178217091209413888461791983209385925423752286421371401491229/1606938044258990275541962092341162602522202993782792835301376" + ], + "moment_approx": "1.355507823709", + "below_one": false + }, + "63": { + "unpaid_coordinates": 2, + "centre_mass_per_call": 63, + "idle_rank_cap": 53, + "moment_interval_at_a_1_over_9": [ + "2194588637784922173900896975151484615641785153939584901221287/1606938044258990275541962092341162602522202993782792835301376", + "1097294318892461086950448487575742307820892576969792450610663/803469022129495137770981046170581301261101496891396417650688" + ], + "moment_approx": "1.365695862156", + "below_one": false + } + }, + "first_uniform_local_rank_at_u2_R53": { + "centre_free": 48, + "centre_retained": 53 + }, + "adjacent_uniform_rank_checks": { + "centre_free": { + "47": { + "moment_interval_at_a_1_over_9": [ + "401899463669306277635790285000279308590752584341107339952201/401734511064747568885490523085290650630550748445698208825344", + "1607597854677225110543161140001117234363010337364429359808831/1606938044258990275541962092341162602522202993782792835301376" + ], + "moment_approx": "1.000410601031", + "below_one": false + }, + "48": { + "moment_interval_at_a_1_over_9": [ + "100277609342652603629079925118080177140388090513264307783561/100433627766186892221372630771322662657637687111424552206336", + "1604441749482441658065278801889282834246209448212228924537005/1606938044258990275541962092341162602522202993782792835301376" + ], + "moment_approx": "0.998446551947", + "below_one": true + } + }, + "centre_retained": { + "52": { + "moment_interval_at_a_1_over_9": [ + "1608881304193207988842487470824157394167522284973568908875713/1606938044258990275541962092341162602522202993782792835301376", + "804440652096603994421243735412078697083761142486784454437871/803469022129495137770981046170581301261101496891396417650688" + ], + "moment_approx": "1.001209293626", + "below_one": false + }, + "53": { + "moment_interval_at_a_1_over_9": [ + "803028690625659048482660464546168823631077768929091265861685/803469022129495137770981046170581301261101496891396417650688", + "1606057381251318096965320929092337647262155537858182531723399/1606938044258990275541962092341162602522202993782792835301376" + ], + "moment_approx": "0.999451962065", + "below_one": true + } + } + }, + "scope": "Fixed selected bit local profile under a hypothetical u=2 law, with or without its centre; separate from the all-mass-at-cap necessary floor. No new bit endpoint or supplier is constructed." + }, + "complex": { + "supplier": "complex", + "m": 73, + "families_per_call": "896/9", + "centre_mass_per_call": "64", + "current_depth_envelope": 2, + "maximum_rank_at_envelope": 51, + "one_unpaid_centre_free": { + "m": 73, + "rank_cap": 51, + "unpaid_coordinates": 1, + "centre_mass_per_call": "0", + "families_per_call": "896/9", + "mass_per_family_S": "72", + "moment_lower_bound_approx": "1.026397274382", + "moment_lower_bound_ninth_power": "17332899271409664/13709821562199377", + "passes_necessary_budget": false + }, + "one_unpaid_centre_charged": { + "m": 73, + "rank_cap": 51, + "unpaid_coordinates": 1, + "centre_mass_per_call": "64", + "families_per_call": "896/9", + "mass_per_family_S": "1017/14", + "moment_lower_bound_approx": "1.035561535761", + "moment_lower_bound_ninth_power": "387942465530124296210948499/283259264696893294132653568", + "passes_necessary_budget": false + }, + "centre_free_minimum_unpaid_at_cap": 3, + "charged_minimum_unpaid_at_cap": 4, + "one_unpaid_minimum_rank_centre_free": 65, + "one_unpaid_minimum_depth_centre_free": 6, + "one_unpaid_minimum_rank_centre_charged": 70, + "one_unpaid_minimum_depth_centre_charged": 17, + "centre_free_boundary": { + "previous_unpaid_count_fails": { + "m": 73, + "rank_cap": 51, + "unpaid_coordinates": 2, + "centre_mass_per_call": "0", + "families_per_call": "896/9", + "mass_per_family_S": "71", + "moment_lower_bound_approx": "1.012141756683", + "moment_lower_bound_ninth_power": "45848500718449031/41129464686598131", + "passes_necessary_budget": false + }, + "minimum_unpaid_count_passes": { + "m": 73, + "rank_cap": 51, + "unpaid_coordinates": 3, + "centre_mass_per_call": "0", + "families_per_call": "896/9", + "mass_per_family_S": "70", + "moment_lower_bound_approx": "0.997886238983", + "moment_lower_bound_ninth_power": "40353607000000000/41129464686598131", + "passes_necessary_budget": true + } + }, + "charged_boundary": { + "previous_unpaid_count_fails": { + "m": 73, + "rank_cap": 51, + "unpaid_coordinates": 3, + "centre_mass_per_call": "64", + "families_per_call": "896/9", + "mass_per_family_S": "989/14", + "moment_lower_bound_approx": "1.007050500361", + "moment_lower_bound_ninth_power": "905246020621685512715981309/849777794090679882397960704", + "passes_necessary_budget": false + }, + "minimum_unpaid_count_passes": { + "m": 73, + "rank_cap": 51, + "unpaid_coordinates": 4, + "centre_mass_per_call": "64", + "families_per_call": "896/9", + "mass_per_family_S": "975/14", + "moment_lower_bound_approx": "0.992794982662", + "moment_lower_bound_ninth_power": "265411836190235137939453125/283259264696893294132653568", + "passes_necessary_budget": true + } + } + }, + "paired_plane_identity_fit_candidate": { + "source_task": "research/paired-plane-identity-fit-seed21ef98/TASK.json", + "aggregate_floor": { + "m": 73, + "rank_cap": 51, + "unpaid_coordinates": 2, + "centre_mass_per_call": "112", + "families_per_call": "896/9", + "mass_per_family_S": "577/8", + "moment_lower_bound_approx": "1.028179214095", + "moment_lower_bound_ninth_power": "7088956614339217590735937/5520303304091433191866368", + "passes_necessary_budget": false + }, + "minimum_unpaid_at_cap_with_112_centre_mass": 4, + "scope": "Target-level budget check on the predecessor's reported u=2,c=112 candidate parameters; no local identity is replayed here." + }, + "limits": [ + "The floor assumes every charged unit may be reblocked at the maximum child rank; this is only a necessary-budget relaxation.", + "The depth thresholds follow the halving guard alone; no row-coefficient invoice for the deeper depths is established here.", + "Passing a floor does not provide a local decoder, physical interface, dirty-state restoration, or complete supplier.", + "The result excludes only the stated one-unpaid coverage law with the stated child-rank envelopes; changed laws and algorithms remain open." + ] +} diff --git a/research/kappa010-rank-cap-floor/SOURCES.json b/research/kappa010-rank-cap-floor/SOURCES.json new file mode 100644 index 0000000000..93f7a9370d --- /dev/null +++ b/research/kappa010-rank-cap-floor/SOURCES.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/bottleneck-brief.md", + "usage": "input", + "git_blob": "e88f305711eaf1e79092886e336f9dbf1762572c", + "sha256": "6c68411cf6faa4b2fd103e4fefc33a4e07d596f616435b5fc8936c45b084bc37" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "docs/research/current-priorities.md", + "usage": "input", + "git_blob": "542fca571796374954da2439dc7d16b6c834af1f", + "sha256": "e8ca7eb37ccb491c2cfe7d309a3af18b98003b84e3b248570f29299ced7932a9" + }, + { + "path": "research/bit-revision3-levers-seed03/README.md", + "usage": "input", + "git_blob": "ac65c531ffae358584e49fc9149c313eb5e437c8", + "sha256": "630911d0652f28d38dbce939bbacdb8ceac23d5fc3a20b02ec8180e4193020c2" + }, + { + "path": "research/bit-revision3-levers-seed03/RESULT.json", + "usage": "input", + "git_blob": "5d66784e72095bbcc7926c61cbc4546ddddf754c", + "sha256": "5cabbf737ed857061ed02b6a49243e656fbe850e5a614a5f94763f32fb16896b" + }, + { + "path": "research/bit-revision3-levers-seed03/levers.py", + "usage": "input", + "git_blob": "f2c4c00fc89ab561469df99dc4a20365e989c40e", + "sha256": "287a1c1201548665087b9b2034210fac92e805f36ea9d4ab41c2471a92d69d7f" + }, + { + "path": "research/complex-local-word-ceiling/README.md", + "usage": "input", + "git_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "sha256": "b60be039cb0e03e064a27407d0bce9e58908d793da5ee405c876de5aebfa5f81" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/paired-plane-identity-fit-seed21ef98/README.md", + "usage": "input", + "git_blob": "cc94f24c074beeb7d3dec4157a34ffd2b0d7ef8a", + "sha256": "334c9828d0e7f057df6620e4c409bdf9cc64f22425867fff3ab7adb3df5ec91f" + }, + { + "path": "research/paired-plane-identity-fit-seed21ef98/TASK.json", + "usage": "input", + "git_blob": "6fcc64c570bbf7f382b3ca25c61279f4fd818393", + "sha256": "79abd39d0a7a0cb6dae1e12b6b9715f9e4790035ac31b3cb72c95fbbcfa3d690" + } + ] +} diff --git a/research/kappa010-rank-cap-floor/TASK.json b/research/kappa010-rank-cap-floor/TASK.json new file mode 100644 index 0000000000..136d87124a --- /dev/null +++ b/research/kappa010-rank-cap-floor/TASK.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "task_id": "coverage-law-change", + "priority_revision": 6, + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "original_card": { + "id": "coverage-law-change", + "question": "Can a template or call contract leave two or more unpaid coordinates per live family?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/idle-axis-hosting/PROOF.md", + "certificates/selected-result.json" + ], + "methods": [ + "State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.", + "Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template." + ], + "acceptance_gate": "An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).", + "bottleneck_link": "The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.", + "allowed_variations": [ + "One template change or one endpoint-contract change.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "coverage identity", + "unpaid coordinate", + "deficit law", + "W - 64N" + ] + }, + "scope_status": "refined", + "actual_scope": "For the donor-set target \u03ba > 0.1, certify aggregate moment floors under current bit and complex coverage/rank caps, exact unpaid/depth thresholds, and the fixed selected bit profile under a hypothetical two-unpaid-coordinate law.", + "scope_change_reason": "The user raised the target from the repository planning target \u03ba > 0.01 to \u03ba > 0.1. The initial exact target-level screen found that u=2 just opens the ideal bit floor. A bounded follow-up applies the pinned selected bit histogram to that changed law to measure how far the actual profile remains from the aggregate floor before pursuing any new endpoint.", + "bottleneck_link": "A fixed rank-mass budget and child-rank cap impose a lower bound on the recursive moment. This proves whether either supplier can reach a=1/9 even after granting perfect high-rank repacking and deleting centre cost.", + "budget_minutes": 480, + "stop_rule": "Stop this aggregate screen once the strict a=1/9 obstruction and exact unpaid/rank boundaries are certified. Do not expand to another search unless one complete dirty endpoint or row-coefficient invoice can realize a passing boundary with margin.", + "outcome": "partial", + "evidence": "Exact rational ninth-power comparisons prove that with one unpaid coordinate the centre-free minimum moment is >1 at bit R=53 and complex R=51. At the current caps, the ideal aggregate floor first drops below one at bit u=2 and complex u=3 centre-free / u=4 with centre retained. The pinned paired-plane identity-fit candidate (u=2,c=112) has floor approximately 1.02818 at a=1/9 and also needs u=4 to pass this aggregate budget. With one unpaid coordinate, deleting centre requires R=56 (bit) and R=65 (complex), first allowed by the halving guard at depths 6 and 6. This is a necessary-budget screen only; no supplier, replacement coverage identity, or higher-depth row invoice is constructed. For the pinned selected bit histogram, u=2 and R=53 still give moment 1.365696 with the centre and 1.355508 without it. If all 5,129 local rank mass is fractionally repacked at a uniform rank, first passing ranks are 53 with the centre (rank52 gives 1.001209) and 48 centre-free (rank47 gives 1.000411). This is a fixed-profile screen only.", + "author": "Codex with OpenAI assistance", + "ai_assistance": "Substantial OpenAI Codex assistance; exact arithmetic, verifier, and report prepared with AI assistance.", + "open_questions": [ + { + "question": "Can one complete bit endpoint leave two coordinates unpaid and replace the selected local profile by high-rank children?", + "why_it_matters": "The aggregate floor passes at u=2 only narrowly with the centre (0.999452); the fixed selected bit histogram still costs 1.365696 at R=53.", + "first_step": "Trace one named two-coordinate candidate through a complete selected bit call, then price its local child-rank profile, source delivery, frame, consumer and restoration.", + "blocked_by": "No changed complete call or local high-rank consumer is source-bound." + }, + { + "question": "Can the complex supplier leave four coordinates unpaid while retaining the current centre charge?", + "why_it_matters": "Four is the exact optimistic threshold at R=51; the current two-clean-output anchor does not establish this global coverage identity.", + "first_step": "Derive and test the replacement coverage identity on one complete outer family, including coefficient delivery and restoration.", + "blocked_by": "The local anchor has dirty source columns and the centre consumer remains paid." + }, + { + "question": "Can a depth-six outer invoice admit child ranks 56 and 65, or can another construction provide an equivalent aggregate budget?", + "why_it_matters": "Those ranks are the minimum centre-free caps that make the one-unpaid aggregate floor pass at a=1/9.", + "first_step": "Compute the exact row coefficient and non-rank charges at depth six for the pinned bit and complex interfaces.", + "blocked_by": "The current admissible envelopes are bit depth four and complex depth two; the guard alone does not establish a lawful row invoice or supplier." + } + ], + "upstream_checkpoint": { + "commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "priority_revision": 6, + "checked_utc": "2026-10-17T02:01:40Z", + "comparison": "Canonical origin/main was refreshed before this submission checkpoint and remains 18aacb215fc3717b06be8ceb9fca62aeca0d3e99. No changes appeared in the current-priorities, task-catalogue, family-status, selected-result, bottleneck-brief, or paired-plane contract-map files since the prior checkpoint. The P104 precision-contract pointer remains present; selected κ and quantitative predecessor receipts are unchanged." + } +} diff --git a/research/kappa010-rank-cap-floor/VERIFY.json b/research/kappa010-rank-cap-floor/VERIFY.json new file mode 100644 index 0000000000..9d69dc91b7 --- /dev/null +++ b/research/kappa010-rank-cap-floor/VERIFY.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/bottleneck-brief.md", + "docs/research/current-priorities.md", + "research/bit-revision3-levers-seed03/README.md", + "research/bit-revision3-levers-seed03/RESULT.json", + "research/bit-revision3-levers-seed03/levers.py", + "research/complex-local-word-ceiling/README.md", + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-local-word-ceiling/ceiling.py", + "research/paired-plane-identity-fit-seed21ef98/README.md", + "research/paired-plane-identity-fit-seed21ef98/TASK.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Binds the selected record and bit/complex predecessor receipts; checks the exact a=1/9 aggregate rank-cap floors, unpaid and required-depth boundaries, and the paired-plane identity-fit aggregate candidate. It additionally prices the pinned selected bit histogram under hypothetical u=2 for centre-free/retained cases and certifies adjacent uniform local-rank boundaries using the pinned outward-rational moment engine. Passing floors and fixed-profile failures are scoped budget results only, not supplier constructions." + } + ] +} diff --git a/research/kappa010-rank-cap-floor/verify.py b/research/kappa010-rank-cap-floor/verify.py new file mode 100644 index 0000000000..2b90028816 --- /dev/null +++ b/research/kappa010-rank-cap-floor/verify.py @@ -0,0 +1,305 @@ +#!/usr/bin/env python3 +"""Exact necessary budget screen for kappa > 1/10 under current supplier laws. + +At kappa = 1/10, the retained conversion kappa = a/(1+a) gives a = 1/9. +For child rank r in (0,m), the a=1/9 cost is (r/m)^(8/9). If all child +ranks are at most R and their total rank mass is P, then + + sum n_r (r/m)^(8/9) / w >= (P/(Rw)) (R/m)^(8/9). + +Writing S=P/w, the ninth power of this lower bound is exactly +S^9/(R*m^8). Its comparison with 1 is therefore a rational comparison; no +floating-point approximation or transcendental interval is needed. + +The screen is deliberately optimistic: it permits every charged unit to be +repacked at the maximum child rank and, in the centre-free rows, deletes the +positive centre/copy charge. A failure rules out every histogram in that +coverage-law/rank-cap model. A pass is only an aggregate budget possibility, +not a realizable supplier. +""" +from __future__ import annotations + +import hashlib +from importlib.util import module_from_spec, spec_from_file_location +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SELECTED = "certificates/selected-result.json" +BIT_RESULT = "research/bit-revision3-levers-seed03/RESULT.json" +COMPLEX_RESULT = "research/complex-local-word-ceiling/RESULT.json" +PAIRED_PLANE_TASK = "research/paired-plane-identity-fit-seed21ef98/TASK.json" +BOTTLENECK_BRIEF = "docs/research/bottleneck-brief.md" +BIT_LEVERS = "research/bit-revision3-levers-seed03/levers.py" + + +def read_json(path: str): + return json.loads((ROOT / path).read_text()) + + +def load_bit_levers(): + """Load the pinned outward-rational bit moment engine for a profile screen.""" + spec = spec_from_file_location("pinned_bit_revision3_levers", ROOT / BIT_LEVERS) + need(spec is not None and spec.loader is not None, "bit moment engine unavailable") + module = module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def need(ok: bool, message: str) -> None: + if not ok: + raise ValueError(message) + + +def frac(x) -> Q: + return Q(str(x)) + + +def cap(m: int, depth: int) -> int: + """Largest integer R with m**depth > 2*R**depth.""" + return max(r for r in range(1, m) if m**depth > 2 * r**depth) + + +def floor_ninth_power_ratio(m: int, R: int, S: Q) -> Q: + """The exact ninth power of the optimistic moment lower bound.""" + need(0 < R < m and S > 0, "positive mass and a proper child rank are required") + return S**9 / (R * m**8) + + +def floor_lower_bound(m: int, R: int, S: Q) -> float: + """Display-only approximation; proof decisions use the exact ratio above.""" + return float(floor_ninth_power_ratio(m, R, S)) ** (1 / 9) + + +def first_rank_below_one(m: int, S: Q) -> int: + """Smallest integer R for which the ideal floor is strictly below one.""" + x = S**9 / (m**8) + return x.numerator // x.denominator + 1 + + +def minimum_unpaid(m: int, w: Q, centre: Q, R: int) -> int: + for unpaid in range(1, m): + S = m - unpaid + centre / w + if floor_ninth_power_ratio(m, R, S) < 1: + return unpaid + raise ValueError("no unpaid count makes this aggregate floor pass") + + +def first_depth_for_rank(m: int, required_rank: int, maximum_depth: int = 64) -> int: + for depth in range(1, maximum_depth + 1): + if cap(m, depth) >= required_rank: + return depth + raise ValueError("no halving depth reached the required rank") + + +def case(m: int, R: int, w: Q, centre: Q, unpaid: int) -> dict[str, object]: + S = Q(m - unpaid) + centre / w + ratio = floor_ninth_power_ratio(m, R, S) + return { + "m": m, + "rank_cap": R, + "unpaid_coordinates": unpaid, + "centre_mass_per_call": str(centre), + "families_per_call": str(w), + "mass_per_family_S": str(S), + "moment_lower_bound_approx": format(floor_lower_bound(m, R, S), ".12f"), + "moment_lower_bound_ninth_power": str(ratio), + "passes_necessary_budget": ratio < 1, + } + + +def supplier_screen(label: str, m: int, w: Q, centre: Q, depth: int) -> dict[str, object]: + R = cap(m, depth) + centre_free_min_u = minimum_unpaid(m, w, Q(0), R) + charged_min_u = minimum_unpaid(m, w, centre, R) + centre_free_rank = first_rank_below_one(m, Q(m - 1)) + charged_rank = first_rank_below_one(m, Q(m - 1) + centre / w) + return { + "supplier": label, + "m": m, + "families_per_call": str(w), + "centre_mass_per_call": str(centre), + "current_depth_envelope": depth, + "maximum_rank_at_envelope": R, + "one_unpaid_centre_free": case(m, R, w, Q(0), 1), + "one_unpaid_centre_charged": case(m, R, w, centre, 1), + "centre_free_minimum_unpaid_at_cap": centre_free_min_u, + "charged_minimum_unpaid_at_cap": charged_min_u, + "one_unpaid_minimum_rank_centre_free": centre_free_rank, + "one_unpaid_minimum_depth_centre_free": first_depth_for_rank(m, centre_free_rank), + "one_unpaid_minimum_rank_centre_charged": charged_rank, + "one_unpaid_minimum_depth_centre_charged": first_depth_for_rank(m, charged_rank), + "centre_free_boundary": { + "previous_unpaid_count_fails": case(m, R, w, Q(0), centre_free_min_u - 1), + "minimum_unpaid_count_passes": case(m, R, w, Q(0), centre_free_min_u), + }, + "charged_boundary": { + "previous_unpaid_count_fails": case(m, R, w, centre, charged_min_u - 1), + "minimum_unpaid_count_passes": case(m, R, w, centre, charged_min_u), + }, + } + + +def main() -> None: + selected = read_json(SELECTED) + bit = read_json(BIT_RESULT) + complex_result = read_json(COMPLEX_RESULT) + paired_plane = read_json(PAIRED_PLANE_TASK) + brief = (ROOT / BOTTLENECK_BRIEF).read_text() + + need(selected["decimal"] == "0.001672660197076918", "selected-result pin/value changed") + need("κ = a/(1+a)" in brief, "retained kappa conversion not found in the bottleneck brief") + target_kappa = Q(1, 10) + target_a = target_kappa / (1 - target_kappa) + need(target_a == Q(1, 9), "kappa 1/10 must correspond to primitive saving 1/9") + bit_replay = bit["replay"] + need(bit["status"] == "PASS_BIT_REVISION3_LEVERS", "bit positive-control receipt is not passing") + need(bit_replay["w"] == "296/3" and bit_replay["copy_charge_per_call"] == 63, + "bit width-family/copy-charge binding changed") + bit_depths = {d["halving_depth"]: d for d in bit_replay["halving_depths"]} + need(bit_depths[4]["elementary_cover_admissible"] and bit_depths[4]["idle_cap"] == 53, + "bit depth-four rank cap is not source-bound") + need(not bit_depths[5]["elementary_cover_admissible"], "bit depth-five envelope changed") + + cm = complex_result["model"] + need(complex_result["status"] == "PASS_COMPLEX_LOCAL_WORD_CEILING", "complex positive-control receipt is not passing") + need(cm["m"] == 73 and cm["live_families_per_call"] == "896/9" + and cm["centre_per_call"] == 64 and cm["idle_rank_cap"] == 51, + "complex coverage/rank-cap binding changed") + + bit_screen = supplier_screen("bit", 64, Q(296, 3), Q(63), 4) + complex_screen = supplier_screen("complex", 73, Q(896, 9), Q(64), 2) + bit_levers = load_bit_levers() + bit_local = {int(r): Q(n) for r, n in bit_replay["local_histogram"].items()} + bit_local_mass = Q(bit_replay["local_mass"]) + bit_two_unpaid = {} + for centre in (0, 63): + H = bit_levers.relaxed(bit_local, 64, Q(296, 3), centre, 53, unpaid=2) + lo, hi = bit_levers.bill(H, 64, Q(296, 3), Q(1, 9)) + bit_two_unpaid[str(centre)] = { + "unpaid_coordinates": 2, + "centre_mass_per_call": centre, + "idle_rank_cap": 53, + "moment_interval_at_a_1_over_9": [str(lo), str(hi)], + "moment_approx": format(float((lo + hi) / 2), ".12f"), + "below_one": hi < 1, + } + + def first_uniform_bit_rank(centre: int) -> int: + for rank in range(1, 54): + H = bit_levers.relaxed({rank: bit_local_mass / rank}, 64, + Q(296, 3), centre, 53, unpaid=2) + _, hi = bit_levers.bill(H, 64, Q(296, 3), Q(1, 9)) + if hi < 1: + return rank + raise ValueError("no uniform local bit rank passes at cap 53") + + bit_uniform_rank_boundary = { + "centre_free": first_uniform_bit_rank(0), + "centre_retained": first_uniform_bit_rank(63), + } + bit_uniform_rank_adjacent = {} + for label, centre in (("centre_free", 0), ("centre_retained", 63)): + passing_rank = bit_uniform_rank_boundary[label] + rows = {} + for rank in (passing_rank - 1, passing_rank): + H = bit_levers.relaxed({rank: bit_local_mass / rank}, 64, + Q(296, 3), centre, 53, unpaid=2) + lo, hi = bit_levers.bill(H, 64, Q(296, 3), Q(1, 9)) + rows[str(rank)] = { + "moment_interval_at_a_1_over_9": [str(lo), str(hi)], + "moment_approx": format(float((lo + hi) / 2), ".12f"), + "below_one": hi < 1, + } + bit_uniform_rank_adjacent[label] = rows + need(not bit_two_unpaid["0"]["below_one"] and not bit_two_unpaid["63"]["below_one"], + "fixed selected bit profile with two unpaid coordinates unexpectedly passes") + need(bit_uniform_rank_boundary == {"centre_free": 48, "centre_retained": 53}, + "bit uniform local-rank target changed") + need(not bit_uniform_rank_adjacent["centre_free"]["47"]["below_one"] + and bit_uniform_rank_adjacent["centre_free"]["48"]["below_one"] + and not bit_uniform_rank_adjacent["centre_retained"]["52"]["below_one"] + and bit_uniform_rank_adjacent["centre_retained"]["53"]["below_one"], + "bit uniform local-rank adjacent boundary") + plane_cost = paired_plane["cost_accounting"] + need(plane_cost["unpaid_coordinates"] == 2 and plane_cost["centre_charge"] == 112 + and plane_cost["local_mass"] == 5634, + "paired-plane candidate parameters changed") + plane_candidate = case(73, 51, Q(896, 9), Q(112), 2) + plane_minimum_unpaid = minimum_unpaid(73, Q(896, 9), Q(112), 51) + need(Q(plane_candidate["moment_lower_bound_ninth_power"]) > 1, + "paired-plane two-unpaid target obstruction") + need(plane_minimum_unpaid == 4, "paired-plane unpaid boundary at its copy charge") + + # The main target-level negative controls: even deleting the centre charge + # and assigning all mass to the maximum admitted rank leaves a moment > 1. + need(Q(bit_screen["one_unpaid_centre_free"]["moment_lower_bound_ninth_power"]) > 1, + "bit one-unpaid target obstruction") + need(Q(complex_screen["one_unpaid_centre_free"]["moment_lower_bound_ninth_power"]) > 1, + "complex one-unpaid target obstruction") + need(Q(bit_screen["one_unpaid_centre_charged"]["moment_lower_bound_ninth_power"]) > 1, + "bit charged target obstruction") + need(Q(complex_screen["one_unpaid_centre_charged"]["moment_lower_bound_ninth_power"]) > 1, + "complex charged target obstruction") + + # Boundary controls ensure the exact strict thresholds are not rounded. + need(bit_screen["centre_free_minimum_unpaid_at_cap"] == 2 + and bit_screen["charged_minimum_unpaid_at_cap"] == 2, + "bit unpaid-coordinate boundary") + need(complex_screen["centre_free_minimum_unpaid_at_cap"] == 3 + and complex_screen["charged_minimum_unpaid_at_cap"] == 4, + "complex unpaid-coordinate boundary") + need(bit_screen["one_unpaid_minimum_rank_centre_free"] == 56 + and bit_screen["one_unpaid_minimum_depth_centre_free"] == 6 + and bit_screen["one_unpaid_minimum_rank_centre_charged"] == 61 + and bit_screen["one_unpaid_minimum_depth_centre_charged"] == 15, + "bit one-unpaid rank/depth thresholds") + need(complex_screen["one_unpaid_minimum_rank_centre_free"] == 65 + and complex_screen["one_unpaid_minimum_depth_centre_free"] == 6 + and complex_screen["one_unpaid_minimum_rank_centre_charged"] == 70 + and complex_screen["one_unpaid_minimum_depth_centre_charged"] == 17, + "complex one-unpaid rank/depth thresholds") + + result = { + "status": "PASS_KAPPA010_RANK_CAP_FLOOR; scoped aggregate-budget obstruction only", + "selected_kappa": selected["decimal"], + "target_kappa": "1/10", + "target_primitive_saving_a": "1/9", + "comparison": "For a=1/9 the ninth power of the optimistic moment floor is S^9/(R*m^8), checked exactly.", + "bit": bit_screen, + "bit_fixed_profile_two_unpaid": { + "source_result": BIT_RESULT, + "selected_local_profile": {str(r): str(n) for r, n in sorted(bit_local.items())}, + "local_rank_mass": str(bit_local_mass), + "actual_profile_at_u2_R53": bit_two_unpaid, + "first_uniform_local_rank_at_u2_R53": bit_uniform_rank_boundary, + "adjacent_uniform_rank_checks": bit_uniform_rank_adjacent, + "scope": "Fixed selected bit local profile under a hypothetical u=2 law, with or without its centre; separate from the all-mass-at-cap necessary floor. No new bit endpoint or supplier is constructed.", + }, + "complex": complex_screen, + "paired_plane_identity_fit_candidate": { + "source_task": PAIRED_PLANE_TASK, + "aggregate_floor": plane_candidate, + "minimum_unpaid_at_cap_with_112_centre_mass": plane_minimum_unpaid, + "scope": "Target-level budget check on the predecessor's reported u=2,c=112 candidate parameters; no local identity is replayed here.", + }, + "limits": [ + "The floor assumes every charged unit may be reblocked at the maximum child rank; this is only a necessary-budget relaxation.", + "The depth thresholds follow the halving guard alone; no row-coefficient invoice for the deeper depths is established here.", + "Passing a floor does not provide a local decoder, physical interface, dirty-state restoration, or complete supplier.", + "The result excludes only the stated one-unpaid coverage law with the stated child-rank envelopes; changed laws and algorithms remain open.", + ], + } + (HERE / "RESULT.json").write_text(json.dumps(result, indent=2) + "\n") + print(result["status"]) + print(" bit one-unpaid, centre-free floor:", bit_screen["one_unpaid_centre_free"]["moment_lower_bound_approx"]) + print(" complex one-unpaid, centre-free floor:", complex_screen["one_unpaid_centre_free"]["moment_lower_bound_approx"]) + print(" required unpaid counts at current caps: bit=2, complex=4 with centre charges") + + +if __name__ == "__main__": + main()