From 0ec4f1318bd4ab01fa03ac18a7b1e1b4f8d846f6 Mon Sep 17 00:00:00 2001 From: Gonzalo-Mier Date: Sat, 17 Oct 2026 03:21:31 +0200 Subject: [PATCH 1/6] Research exact budget floors for kappa 0.1 --- .../kappa010-complex-lever-floor/README.md | 76 +++ .../kappa010-complex-lever-floor/RESULT.json | 456 ++++++++++++++++++ .../kappa010-complex-lever-floor/SOURCES.json | 54 +++ .../kappa010-complex-lever-floor/TASK.json | 83 ++++ .../kappa010-complex-lever-floor/VERIFY.json | 26 + .../kappa010-complex-lever-floor/verify.py | 372 ++++++++++++++ research/kappa010-rank-cap-floor/README.md | 67 +++ research/kappa010-rank-cap-floor/RESULT.json | 197 ++++++++ research/kappa010-rank-cap-floor/SOURCES.json | 78 +++ research/kappa010-rank-cap-floor/TASK.json | 83 ++++ research/kappa010-rank-cap-floor/VERIFY.json | 30 ++ research/kappa010-rank-cap-floor/verify.py | 231 +++++++++ 12 files changed, 1753 insertions(+) create mode 100644 research/kappa010-complex-lever-floor/README.md create mode 100644 research/kappa010-complex-lever-floor/RESULT.json create mode 100644 research/kappa010-complex-lever-floor/SOURCES.json create mode 100644 research/kappa010-complex-lever-floor/TASK.json create mode 100644 research/kappa010-complex-lever-floor/VERIFY.json create mode 100644 research/kappa010-complex-lever-floor/verify.py create mode 100644 research/kappa010-rank-cap-floor/README.md create mode 100644 research/kappa010-rank-cap-floor/RESULT.json create mode 100644 research/kappa010-rank-cap-floor/SOURCES.json create mode 100644 research/kappa010-rank-cap-floor/TASK.json create mode 100644 research/kappa010-rank-cap-floor/VERIFY.json create mode 100644 research/kappa010-rank-cap-floor/verify.py diff --git a/research/kappa010-complex-lever-floor/README.md b/research/kappa010-complex-lever-floor/README.md new file mode 100644 index 0000000000..fc692b984b --- /dev/null +++ b/research/kappa010-complex-lever-floor/README.md @@ -0,0 +1,76 @@ +# Joint-lever floor for a κ = 0.1 target + +**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. + +## Scope and next step + +The result rejects only the fixed selected profile and the stated seven-anchor/centre-free/rank-16 relaxation. It is not a theorem about other local words, suppliers, recursion widths or multiplication algorithms. It also does not independently reprove the predecessor anchor's local bilinear map. + +The next decisive experiment is a complete dirty-input endpoint with enough named live families to establish at least ten unpaid coordinates after source delivery and restoration. If that endpoint exists, its exact rank-16 consumer and all source, frame, routing, precision and cleanup charges must fit while preserving the budget slack. The most relevant blockers are the absence of a source-bound set of seven anchor locations and of a rank-16 consumer at the selected provider boundary. Until one complete endpoint clears those obligations, further lowering or anchor searches are not justified by this screen. + +## 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, and two-output-anchor result in [SOURCES.json](SOURCES.json). It checks the exact `a=1/9` interval boundaries `u=23/24`, `u=9/10` and `u=10/11`, the rank/unpaid and fee frontiers, plus 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 temporary-sum map and its seven-block hypothesis are Cinna / commdata2338's [two-output anchor](../complex-two-output-sum-anchor-seed65ce19/README.md); retain its predecessor attributions. The interval ceiling and selected profile are credited in [complex-local-word-ceiling](../complex-local-word-ceiling/README.md). This package adds only the target-0.1 combined-lever evaluation. Prepared by Codex with substantial OpenAI assistance; no independent human review is claimed. New work is Apache-2.0. + +The overlap helper returned `POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE`. Its refresh was attempted on 2026-10-17 but could not reach `api.github.com`; it fell back to a complete cached snapshot from 2026-10-16 23:54 UTC (246 open PRs and 1,856 discussion records). Local matches include the earlier `kappa01-complex-target-screen`, the P112 five-plane decoder and prior coverage-law packages. This package extends those specific profiles to `a=1/9` and certifies their anchor/rank/coverage tradeoffs; novelty is not claimed. Live Discussions #1163, #1166 and #1167, theory Discussion #2838, and relevant PRs #3064 and #3097 were opened on 2026-10-17. Canonical main was refreshed at `18aacb215fc3717b06be8ceb9fca62aeca0d3e99` (priority revision 6); the selected record and quantitative predecessor receipts are unchanged. + +## Open next questions + +1. **Can a complete dirty-input endpoint leave ten coordinates unpaid?** It matters because ten is the first passing boundary even after granting a rank-16 consumer and centre removal. First step: bind one named block to a selected-provider trace and prove its entry/exit map, coefficient delivery and restoration. Blocker: no source locations or changed coverage identity are supplied. +2. **Can the selected provider realize a rank-16 consumer for the remaining 4,766 units?** The fractional profile passes at `u=10`, but it does not give a physical decoder. First step: exhibit an exact local decoder and its frames, then run the full cost through the selected word. Blocker: the anchor package has no selected-provider rank-16 consumer. +3. **Can seven two-output anchors be placed within the target budget of `e≤170` per block?** The 112 affine additions leave at most 58 rank-one-equivalent units for every other interface cost. First step: find one source-bound occurrence with the two clean required outputs and price its acquisition, routing, frame and cleanup. Blocker: no selected trace alignment has been established. diff --git a/research/kappa010-complex-lever-floor/RESULT.json b/research/kappa010-complex-lever-floor/RESULT.json new file mode 100644 index 0000000000..2e79c594bb --- /dev/null +++ b/research/kappa010-complex-lever-floor/RESULT.json @@ -0,0 +1,456 @@ +{ + "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 + }, + "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." + ] +} diff --git a/research/kappa010-complex-lever-floor/SOURCES.json b/research/kappa010-complex-lever-floor/SOURCES.json new file mode 100644 index 0000000000..2e27e0c18e --- /dev/null +++ b/research/kappa010-complex-lever-floor/SOURCES.json @@ -0,0 +1,54 @@ +{ + "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": "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/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + } + ] +} diff --git a/research/kappa010-complex-lever-floor/TASK.json b/research/kappa010-complex-lever-floor/TASK.json new file mode 100644 index 0000000000..4849991670 --- /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-set target κ > 0.1, determine the exact unpaid-coordinate boundary for the strongest already explored complex-side lever bundle: seven two-output anchors, centre removal, and rank-16 repacking.", + "scope_change_reason": "The user raised the target to κ > 0.1. The exact rank-cap screen showed that the current one-unpaid coverage law cannot reach it under the selected envelopes. This follow-up evaluates the concrete anchor/centre/rank-16 combination at a=1/9 and identifies the additional coverage change it would require.", + "bottleneck_link": "The complex supplier binds the selected κ. At κ=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": "Stop after certifying the exact a=1/9 boundary for the fixed selected profile and the seven-anchor/centre-free/rank-16 bundle. Do not expand into another anchor or decoder search until one complete dirty endpoint can realize the required ten unpaid coordinates with a priced consumer and source chronology.", + "outcome": "partial", + "evidence": "The certified outward-rational moment engine gives 1.151904798395 for the selected profile at its largest feasible centre-free unpaid count u=17, so the unchanged local word cannot be rescued by coverage changes alone. For seven hypothetical q=112 anchors, charging 112 rank-one-equivalent units per block, deleting the centre and repacking all 4,766 remaining rank mass into fractional rank-16 children, the exact target boundary is u=9 failing (moment 1.006167823580) and u=10 passing (0.991912305880). Retaining the 64-unit centre charge shifts the boundary to u=11. At u=4, the local uniform child rank must be at least 42 centre-free or 47 with the centre charge retained, while idle remainder stays at the rank-51 cap. At u=10 centre-free, total block fee e=170 passes and e=171 fails, leaving 58 units beyond the 112 affine additions. The pinned five-plane u=5 profile has local-terms-only moment 1.165241830803 at a=1/9, so coverage changes alone cannot rescue that fixed profile; rank-16 repacking still needs u=11 centre-free or u=12 with centre. No complete endpoint, high-rank decoder, source alignment, physical cost or supplier is constructed.", + "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 a complete dirty-input endpoint leave ten coordinates unpaid per live family?", + "why_it_matters": "Ten is the first passing boundary even after granting centre removal and fractional rank-16 repacking.", + "first_step": "Bind one named candidate block to a selected-provider trace and prove coefficient delivery, entry/exit state and restoration.", + "blocked_by": "No source-bound locations or replacement coverage identity are available." + }, + { + "question": "Can the selected provider supply a rank-16 consumer for the remaining 4,766 local rank mass?", + "why_it_matters": "The fractional rank-16 relaxation is what reduces the target requirement from 24 unpaid coordinates to ten.", + "first_step": "Exhibit an exact local decoder and trace its frames and calls through one complete selected-word boundary.", + "blocked_by": "The two-output anchor package has no selected-provider rank-16 consumer." + }, + { + "question": "Can seven anchors be placed within the target budget e<=170 per block?", + "why_it_matters": "The 112 affine additions leave only 58 rank-one-equivalent units for every other interface cost.", + "first_step": "Find one source-bound occurrence with the required clean outputs and price acquisition, routing, frames and cleanup.", + "blocked_by": "No selected trace alignment has been established." + } + ], + "upstream_checkpoint": { + "commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "priority_revision": 6, + "checked_utc": "2026-10-17T01:20:09Z", + "comparison": "Canonical main was refreshed from the original d8e0f83 base. The relevant guidance diff adds a P104 precision-contract pointer to bottleneck-brief.md; the selected record, current priorities, and quantitative predecessor receipts used here are unchanged." + } +} diff --git a/research/kappa010-complex-lever-floor/VERIFY.json b/research/kappa010-complex-lever-floor/VERIFY.json new file mode 100644 index 0000000000..99dd2a42ba --- /dev/null +++ b/research/kappa010-complex-lever-floor/VERIFY.json @@ -0,0 +1,26 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-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/community-frontier1094-audit/selected-replay.tar.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Binds the selected κ, ceiling model, two-output-anchor receipt, and the five-plane profile's identical selected replay archive; reconstructs the seven-block hypothetical profile; checks exact outward-rational moment intervals at a=1/9 for selected, anchor, five-plane and fractional local-rank models; certifies adjacent unpaid-count, fixed-u rank and per-block-fee boundaries with centre absent/present; and checks a passing a=1/99 positive control. This is a scoped aggregate budget screen, not a supplier or κ 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..5d6034878b --- /dev/null +++ b/research/kappa010-complex-lever-floor/verify.py @@ -0,0 +1,372 @@ +#!/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 json +import sys +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 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") + 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 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 rank-one children each, + # while e=112 charges the 112 local affine additions at one hypothetical + # rank-one-equivalent unit each. + 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 + + # 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 + + # 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, + }, + "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.", + ], + } + (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") + + +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..081f6614f3 --- /dev/null +++ b/research/kappa010-rank-cap-floor/README.md @@ -0,0 +1,67 @@ +# 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. + +## 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 refresh was attempted on 2026-10-17 but could not reach `api.github.com`; it fell back to a complete cached snapshot from 2026-10-16 23:54 UTC (246 open PRs and 1,856 discussion records). Live Discussions #1163, #1166 and #1167, plus relevant PRs #3064 and #3097, were opened on 2026-10-17. This is not a novelty certificate; recheck live overlap before any later expansion. + +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..0a2908963b --- /dev/null +++ b/research/kappa010-rank-cap-floor/RESULT.json @@ -0,0 +1,197 @@ +{ + "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 + } + } + }, + "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..f18e058d34 --- /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 κ > 0.1, certify the most favorable aggregate moment permitted by the current bit and complex coverage laws and rank caps; identify the exact unpaid-coordinate or depth thresholds needed to reopen the budget.", + "scope_change_reason": "The user raised the target from the repository's planning target κ > 0.01 to κ > 0.1. Before constructing an endpoint change, this exact target-level screen tests whether the existing coverage identities and depth envelopes can possibly support it.", + "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.", + "author": "Codex with OpenAI assistance", + "ai_assistance": "Substantial OpenAI Codex assistance; exact arithmetic, verifier, and report prepared with AI assistance.", + "open_questions": [ + { + "question": "Can two unpaid coordinates be carried through one complete dirty-input endpoint on the bit side?", + "why_it_matters": "Two is the minimum count that makes the aggregate floor pass at the current bit cap, but the actual endpoint could repay the apparent slack through the consumer or restoration.", + "first_step": "Trace a named two-coordinate candidate through one complete selected bit call and record all source, frame, consumer, and restoration charges.", + "blocked_by": "The current endpoint contract retains one unpaid coordinate and no changed complete call is available." + }, + { + "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-17T01:20:09Z", + "comparison": "Canonical main was refreshed from the original d8e0f83 base. The relevant guidance diff adds a P104 precision-contract pointer to bottleneck-brief.md; the selected record, current priorities, and quantitative predecessor receipts used here 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..25d776f6ef --- /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 predecessor screen receipts; checks the exact a=1/9 aggregate rank-cap lower bound, the paired-plane u=2/c=112 case, unpaid-coordinate and required-depth boundaries, and strict fail/pass controls. The all-mass-at-cap case is an optimistic budget relaxation, not a supplier." + } + ] +} diff --git a/research/kappa010-rank-cap-floor/verify.py b/research/kappa010-rank-cap-floor/verify.py new file mode 100644 index 0000000000..5bad90be19 --- /dev/null +++ b/research/kappa010-rank-cap-floor/verify.py @@ -0,0 +1,231 @@ +#!/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 +import json +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" + + +def read_json(path: str): + return json.loads((ROOT / path).read_text()) + + +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) + 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, + "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() From cc6718a494504207de0c78100c5a05ee94c449d1 Mon Sep 17 00:00:00 2001 From: Gonzalo-Mier Date: Sat, 17 Oct 2026 03:23:20 +0200 Subject: [PATCH 2/6] Clarify overlap with the fixed-profile kappa audit --- research/kappa010-complex-lever-floor/README.md | 2 +- research/kappa010-rank-cap-floor/README.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/research/kappa010-complex-lever-floor/README.md b/research/kappa010-complex-lever-floor/README.md index fc692b984b..51ccf7c688 100644 --- a/research/kappa010-complex-lever-floor/README.md +++ b/research/kappa010-complex-lever-floor/README.md @@ -67,7 +67,7 @@ The verifier binds the selected record, current local ceiling model, and two-out This is a target refinement of the `coverage-law-change` question, motivated by the donor-set target κ > 0.1. The local two-output temporary-sum map and its seven-block hypothesis are Cinna / commdata2338's [two-output anchor](../complex-two-output-sum-anchor-seed65ce19/README.md); retain its predecessor attributions. The interval ceiling and selected profile are credited in [complex-local-word-ceiling](../complex-local-word-ceiling/README.md). This package adds only the target-0.1 combined-lever evaluation. Prepared by Codex with substantial OpenAI assistance; no independent human review is claimed. New work is Apache-2.0. -The overlap helper returned `POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE`. Its refresh was attempted on 2026-10-17 but could not reach `api.github.com`; it fell back to a complete cached snapshot from 2026-10-16 23:54 UTC (246 open PRs and 1,856 discussion records). Local matches include the earlier `kappa01-complex-target-screen`, the P112 five-plane decoder and prior coverage-law packages. This package extends those specific profiles to `a=1/9` and certifies their anchor/rank/coverage tradeoffs; novelty is not claimed. Live Discussions #1163, #1166 and #1167, theory Discussion #2838, and relevant PRs #3064 and #3097 were opened on 2026-10-17. Canonical main was refreshed at `18aacb215fc3717b06be8ceb9fca62aeca0d3e99` (priority revision 6); the selected record and quantitative predecessor receipts are unchanged. +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 evaluates the selected profile, the pinned five-plane profile and the seven-anchor/centre/rank-16 relaxation, including exact unpaid-coordinate and per-block-fee boundaries; the 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 diff --git a/research/kappa010-rank-cap-floor/README.md b/research/kappa010-rank-cap-floor/README.md index 081f6614f3..312f71e4b5 100644 --- a/research/kappa010-rank-cap-floor/README.md +++ b/research/kappa010-rank-cap-floor/README.md @@ -62,6 +62,6 @@ This refines the `coverage-law-change` card for the user-set target κ > 0.1. It 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 refresh was attempted on 2026-10-17 but could not reach `api.github.com`; it fell back to a complete cached snapshot from 2026-10-16 23:54 UTC (246 open PRs and 1,856 discussion records). Live Discussions #1163, #1166 and #1167, plus relevant PRs #3064 and #3097, were opened on 2026-10-17. This is not a novelty certificate; recheck live overlap before any later expansion. +A fresh overlap refresh on 2026-10-17 covered 259 open PRs and 1,866 discussions (complete pagination). It surfaced open PR #3093, which audits the paid terms of two fixed local profiles (#2979 and #3042) at the same target. That is complementary to this package's lower bound over every histogram admitted by the current aggregate coverage laws and rank caps; this package also computes the unpaid/rank thresholds for both suppliers. PRs #3064 and #3097 and Discussions #1163, #1166 and #1167 were also checked. The overlap helper reports possible overlap, not novelty; see the exact scopes and recheck before expanding the work. Prepared by Codex with OpenAI assistance. New work is Apache-2.0. From bcb2b1169ad65dd4183baaf502b35556f986b193 Mon Sep 17 00:00:00 2001 From: Gonzalo-Mier Date: Sat, 17 Oct 2026 03:39:45 +0200 Subject: [PATCH 3/6] Screen tensorized paired-plane route at kappa 0.1 --- .../kappa010-complex-lever-floor/README.md | 24 +- .../kappa010-complex-lever-floor/RESULT.json | 205 +++++++++++++++++- .../kappa010-complex-lever-floor/SOURCES.json | 18 ++ .../kappa010-complex-lever-floor/TASK.json | 30 +-- .../kappa010-complex-lever-floor/VERIFY.json | 7 +- .../kappa010-complex-lever-floor/verify.py | 179 +++++++++++++++ 6 files changed, 439 insertions(+), 24 deletions(-) diff --git a/research/kappa010-complex-lever-floor/README.md b/research/kappa010-complex-lever-floor/README.md index 51ccf7c688..b1b904052b 100644 --- a/research/kappa010-complex-lever-floor/README.md +++ b/research/kappa010-complex-lever-floor/README.md @@ -45,11 +45,29 @@ The target also leaves little room for a complete anchor invoice. With all 4,766 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: additive composition still misses + +I checked a more aggressive escape using the exact [block-valued paired-plane endpoint](../paired-plane-block-rank/README.md) and its [49-support scalar fit](../paired-plane-minrank-bracket-audit/README.md). The fixed fit partitions the 112 ports into supports of sizes `{1: 2, 2: 31, 3: 16}`. Under the full port-space charge used by PR2203, a support of size `s` touches `s` mutually orthogonal nondegenerate planes and costs rank `2s`. Its exact copy profile is therefore `{2: 2, 4: 31, 6: 16}`, with mass **224 per payload copy**. Tensoring the fit by `d` copies gives unpaid count `u=2d` and multiplies this profile by `d`; the all-size block-rank receipt confirms the fixed mask has normalized query rank `49d`. + +Now combine those `d` copies with the seven-anchor profile. After replacing seven groups of 332 rank-one children by 112 children, the non-centre base mass is 3,982. I grant the strongest allowed idle/consumer relaxation by placing all of it at rank 51, and charge only the unavoidable dirty-output affine updates: each of the 110 arbitrary dirty destinations must receive a nonzero product-dependent correction, and one `ADD` changes one destination, so every 112-output block needs at least `q−2 = 110` additions. This is more favorable than the anchor's actual 112-add schedule. If the centre remains, its eight rank-8 children are restored to the profile along with its 64-unit charge. + +| Payload copies `d` | Unpaid `u=2d` | Target moment at the minimum 110 additions, centre-free / retained | Maximum affordable additions per block, centre-free / retained | +|---:|---:|---:|---:| +| 1 | 2 | 1.082289 / 1.093548 | none; it fails with zero additions | +| 2 | 4 | 1.063520 / 1.074779 | none; it fails with zero additions | +| 3 | 6 | 1.044752 / 1.056010 | 28 / 8 | +| 4 | 8 | 1.025983 / 1.037241 | 62 / 42 | +| 5 | 10 | 1.007214 / 1.018473 | 96 / 76 | + +The entries are certified outward-rational intervals; decimals are only for reading. Thus every `d≤5` fails even after allowing all remaining mass to use rank-51 children and reducing the anchor to its 110-update lower bound. For `d≥6`, the same minimum invoice already exceeds the coverage mass: at `d=6` it is over by exactly `208/9`, and each extra copy increases the excess by `3808/9`. Keeping the centre adds its charge and children equally on the two sides of this mass comparison, so it does not repair the excess. + +This closes only the **tensorized paired-plane fit plus additive seven-anchor map** under the selected coverage law and the one-target `ADD` contract. It does not price a changed support mask or a recursive child that jointly updates multiple dirty destinations. Such a child would have to reduce the 110-update floor by at least 14 (centre-free) or 34 (centre-retained) in the best `d=5` row, while also supplying the endpoint identity and full source/restoration contract. The fitted matrix alone does not do that. No supplier or κ improvement is claimed. + ## Scope and next step The result rejects only the fixed selected profile and the stated seven-anchor/centre-free/rank-16 relaxation. It is not a theorem about other local words, suppliers, recursion widths or multiplication algorithms. It also does not independently reprove the predecessor anchor's local bilinear map. -The next decisive experiment is a complete dirty-input endpoint with enough named live families to establish at least ten unpaid coordinates after source delivery and restoration. If that endpoint exists, its exact rank-16 consumer and all source, frame, routing, precision and cleanup charges must fit while preserving the budget slack. The most relevant blockers are the absence of a source-bound set of seven anchor locations and of a rank-16 consumer at the selected provider boundary. Until one complete endpoint clears those obligations, further lowering or anchor searches are not justified by this screen. +The next decisive experiment must change the endpoint or the recursive consumer together: the additive d-fold plane decoder cannot fit beside even the minimum dirty-output updates, while d≥6 also violates the paid-mass envelope. A bounded follow-up should start with one complete dirty-input block whose child output writes more than one dirty destination, then price that changed contract against the d=5 target row. The blocker is that no such multi-target recursive child or selected-provider placement is currently source-bound. Further searches over the same scalar support fit or anchor schedule cannot change this decision. ## Reproduction @@ -61,11 +79,11 @@ python3 scripts/research_package.py --package research/kappa010-complex-lever-fl python3.12 scripts/research_package.py --package research/kappa010-complex-lever-floor ``` -The verifier binds the selected record, current local ceiling model, and two-output-anchor result in [SOURCES.json](SOURCES.json). It checks the exact `a=1/9` interval boundaries `u=23/24`, `u=9/10` and `u=10/11`, the rank/unpaid and fee frontiers, plus the lower `a=1/99` positive control. +The verifier binds the selected record, current local ceiling model, two-output-anchor result, and paired-plane fit receipts in [SOURCES.json](SOURCES.json). It checks the exact `a=1/9` interval boundaries `u=23/24`, `u=9/10` and `u=10/11`, the rank/unpaid and fee frontiers, the 49-support full port-space profile, every tensor multiplicity `d=1..5` at its minimum dirty-update count, the `d≥6` mass excess, 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 temporary-sum map and its seven-block hypothesis are Cinna / commdata2338's [two-output anchor](../complex-two-output-sum-anchor-seed65ce19/README.md); retain its predecessor attributions. The interval ceiling and selected profile are credited in [complex-local-word-ceiling](../complex-local-word-ceiling/README.md). This package adds only the target-0.1 combined-lever evaluation. Prepared by Codex with substantial OpenAI assistance; no independent human review is claimed. New work is Apache-2.0. +This is a target refinement of the `coverage-law-change` question, motivated by the donor-set target κ > 0.1. The local two-output temporary-sum map and its seven-block hypothesis are Cinna / commdata2338's [two-output anchor](../complex-two-output-sum-anchor-seed65ce19/README.md); retain its predecessor attributions. 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. 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 evaluates the selected profile, the pinned five-plane profile and the seven-anchor/centre/rank-16 relaxation, including exact unpaid-coordinate and per-block-fee boundaries; the 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. diff --git a/research/kappa010-complex-lever-floor/RESULT.json b/research/kappa010-complex-lever-floor/RESULT.json index 2e79c594bb..6e60da534b 100644 --- a/research/kappa010-complex-lever-floor/RESULT.json +++ b/research/kappa010-complex-lever-floor/RESULT.json @@ -447,10 +447,213 @@ ], "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; not a lower bound on every decoder or a native schedule." + }, + "payload_copy_to_unpaid_rule": "u=2d", + "base_mass_repacked_at_rank": 51, + "base_mass_before_endpoint_and_dirty_updates": 3982, + "anchor_blocks": 7, + "minimum_one_target_dirty_updates_per_block": 110, + "minimum_affine_fee_per_block_used": 110, + "d_1_through_5_target_moments": [ + { + "payload_copies": 1, + "unpaid_coordinates": 2, + "minimum_dirty_updates_per_block": 110, + "at_minimum_affine_fee": { + "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 + } + }, + "maximum_passing_affine_fee_per_block": { + "0": null, + "64": null + } + }, + { + "payload_copies": 2, + "unpaid_coordinates": 4, + "minimum_dirty_updates_per_block": 110, + "at_minimum_affine_fee": { + "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 + } + }, + "maximum_passing_affine_fee_per_block": { + "0": null, + "64": null + } + }, + { + "payload_copies": 3, + "unpaid_coordinates": 6, + "minimum_dirty_updates_per_block": 110, + "at_minimum_affine_fee": { + "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 + } + }, + "maximum_passing_affine_fee_per_block": { + "0": [ + 28, + 29 + ], + "64": [ + 8, + 9 + ] + } + }, + { + "payload_copies": 4, + "unpaid_coordinates": 8, + "minimum_dirty_updates_per_block": 110, + "at_minimum_affine_fee": { + "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 + } + }, + "maximum_passing_affine_fee_per_block": { + "0": [ + 62, + 63 + ], + "64": [ + 42, + 43 + ] + } + }, + { + "payload_copies": 5, + "unpaid_coordinates": 10, + "minimum_dirty_updates_per_block": 110, + "at_minimum_affine_fee": { + "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 + } + }, + "maximum_passing_affine_fee_per_block": { + "0": [ + 96, + 97 + ], + "64": [ + 76, + 77 + ] + } + } + ], + "d6_minimum_fee_mass_excess": "208/9", + "mass_excess_growth_per_extra_copy": "3808/9", + "conclusion": "The tensorized pinned fit plus the seven-anchor map, with at least q-2 one-target dirty updates per block, misses a=1/9 for d=1..5; d>=6 exceeds the coverage mass even before other costs.", + "scope": "This excludes only the stated fit, additive anchor contract, and selected-profile relaxation. A different support fit, changed endpoint mask, or multi-target recursive child needs its own full charge and dirty-state proof." + }, "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 hypothetical 112-unit block fee prices affine additions only; all other interface charges are waived.", + "The new d-fold screen uses the pinned paired-plane support fit's port-space charge and the q-2 dirty-output update floor; it does not exclude changed masks or recursive children that update multiple dirty destinations under a different contract." ] } diff --git a/research/kappa010-complex-lever-floor/SOURCES.json b/research/kappa010-complex-lever-floor/SOURCES.json index 2e27e0c18e..98826e6c30 100644 --- a/research/kappa010-complex-lever-floor/SOURCES.json +++ b/research/kappa010-complex-lever-floor/SOURCES.json @@ -49,6 +49,24 @@ "usage": "input", "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/paired-plane-minrank-bracket-audit/CERTIFICATE.json", + "usage": "input", + "git_blob": "393db5def16d76b3a0ebddc983c9bab6c3cc25fc", + "sha256": "6f5d3478290156c4fe703104572cc3aa593ad50079476ae08c942833714e3179" + }, + { + "path": "research/paired-plane-scalar-mask-obstruction/PR1825-CERTIFICATE.json", + "usage": "input", + "git_blob": "7ca668d7d50c7276e89b0f6f9575e1b9f1ad9ef6", + "sha256": "4fd648f7b5178bff5441bf364d58234b7bc1a43b924bc6da03013c948f1473b1" + }, + { + "path": "research/paired-plane-block-rank/RESULT.json", + "usage": "input", + "git_blob": "2b137330e7edbbbe7bc07843a2708791b731add7", + "sha256": "8b78968378d7ed824ac2418fe40b36db04d9522c117349778655191b4ee10d6d" } ] } diff --git a/research/kappa010-complex-lever-floor/TASK.json b/research/kappa010-complex-lever-floor/TASK.json index 4849991670..779b1a4544 100644 --- a/research/kappa010-complex-lever-floor/TASK.json +++ b/research/kappa010-complex-lever-floor/TASK.json @@ -45,33 +45,27 @@ ] }, "scope_status": "refined", - "actual_scope": "At the donor-set target κ > 0.1, determine the exact unpaid-coordinate boundary for the strongest already explored complex-side lever bundle: seven two-output anchors, centre removal, and rank-16 repacking.", - "scope_change_reason": "The user raised the target to κ > 0.1. The exact rank-cap screen showed that the current one-unpaid coverage law cannot reach it under the selected envelopes. This follow-up evaluates the concrete anchor/centre/rank-16 combination at a=1/9 and identifies the additional coverage change it would require.", + "actual_scope": "At the donor-set target κ > 0.1, test whether a tensorized block-valued paired-plane endpoint can combine with seven two-output anchors under the selected complex budget and the dirty-output contract.", + "scope_change_reason": "The first target screen showed that one unpaid coordinate and the selected local profile are far below κ=0.1. The exact block-rank receipt offers a distinct vector-valued endpoint, so this bounded continuation tensorizes its pinned rank-49 fit, reprices every support under the full port-space tariff, and checks the complete d-fold profile against the anchor's mandatory dirty-output updates.", "bottleneck_link": "The complex supplier binds the selected κ. At κ=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": "Stop after certifying the exact a=1/9 boundary for the fixed selected profile and the seven-anchor/centre-free/rank-16 bundle. Do not expand into another anchor or decoder search until one complete dirty endpoint can realize the required ten unpaid coordinates with a priced consumer and source chronology.", + "stop_rule": "Stop after checking every integer tensor multiplicity d against the exact target moment and mass capacity under the minimum one-target dirty-update count. Do not search more supports or anchor schedules unless a changed recursive-child contract can reduce that update charge and comes with a complete dirty-state example and source-bound placement.", "outcome": "partial", - "evidence": "The certified outward-rational moment engine gives 1.151904798395 for the selected profile at its largest feasible centre-free unpaid count u=17, so the unchanged local word cannot be rescued by coverage changes alone. For seven hypothetical q=112 anchors, charging 112 rank-one-equivalent units per block, deleting the centre and repacking all 4,766 remaining rank mass into fractional rank-16 children, the exact target boundary is u=9 failing (moment 1.006167823580) and u=10 passing (0.991912305880). Retaining the 64-unit centre charge shifts the boundary to u=11. At u=4, the local uniform child rank must be at least 42 centre-free or 47 with the centre charge retained, while idle remainder stays at the rank-51 cap. At u=10 centre-free, total block fee e=170 passes and e=171 fails, leaving 58 units beyond the 112 affine additions. The pinned five-plane u=5 profile has local-terms-only moment 1.165241830803 at a=1/9, so coverage changes alone cannot rescue that fixed profile; rank-16 repacking still needs u=11 centre-free or u=12 with centre. No complete endpoint, high-rank decoder, source alignment, physical cost or supplier is constructed.", + "evidence": "The prior exact screens remain: the selected local word has moment 1.151904798395 at its largest feasible centre-free unpaid count u=17; the seven-anchor/centre-free/rank-16 relaxation first passes at u=10, and retaining the centre shifts that boundary to u=11. This continuation reconstructs the pinned 49-support paired-plane fit and finds its full port-space copy profile {2:2,4:31,6:16}, mass 224 per payload copy. For d tensor copies (u=2d), the most favorable seven-anchor base mass is repacked at rank 51 and each 112-output block is charged only the necessary q-2=110 dirty-target additions. At d=1..5, exact target moments remain above one (best case d=5: 1.007213975257 without centre, 1.018472569178 with centre); the fee frontiers are only 96 and 76 per block. At d=6, the minimum local mass exceeds the coverage capacity by 208/9, and each extra copy worsens that gap by 3808/9. Thus this fixed tensorized decoder plus additive anchor contract cannot reach a=1/9. No multi-target recursive child, fused endpoint, source alignment, physical supplier or κ improvement is constructed.", "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 a complete dirty-input endpoint leave ten coordinates unpaid per live family?", - "why_it_matters": "Ten is the first passing boundary even after granting centre removal and fractional rank-16 repacking.", - "first_step": "Bind one named candidate block to a selected-provider trace and prove coefficient delivery, entry/exit state and restoration.", - "blocked_by": "No source-bound locations or replacement coverage identity are available." + "question": "Can a changed recursive child update multiple dirty output destinations and beat the one-ADD-per-destination floor?", + "why_it_matters": "The best additive d=5 endpoint still needs at least 14 fewer rank-one-equivalent updates per block centre-free, or 34 fewer with the centre retained, before any other unknown costs.", + "first_step": "Give a complete q=3 dirty-input map with its child outputs, output writes, and exact restoration; then derive how the same contract scales to q=112.", + "blocked_by": "No selected-provider child with a multi-destination dirty-output contract or source-bound seven-anchor placement is available." }, { - "question": "Can the selected provider supply a rank-16 consumer for the remaining 4,766 local rank mass?", - "why_it_matters": "The fractional rank-16 relaxation is what reduces the target requirement from 24 unpaid coordinates to ten.", - "first_step": "Exhibit an exact local decoder and trace its frames and calls through one complete selected-word boundary.", - "blocked_by": "The two-output anchor package has no selected-provider rank-16 consumer." - }, - { - "question": "Can seven anchors be placed within the target budget e<=170 per block?", - "why_it_matters": "The 112 affine additions leave only 58 rank-one-equivalent units for every other interface cost.", - "first_step": "Find one source-bound occurrence with the required clean outputs and price acquisition, routing, frames and cleanup.", - "blocked_by": "No selected trace alignment has been established." + "question": "Can a different endpoint mask lower the full port-space charge per unpaid dimension?", + "why_it_matters": "The pinned paired-plane support fit costs 224 per payload copy, while the fixed tensorized construction misses the target after the mandatory anchor updates.", + "first_step": "Specify a changed directed zero mask and compute one exact fitting factorization plus its full group-space charge before screening a larger cover.", + "blocked_by": "The rank-49d theorem and charge profile apply only to the fixed selected matching and strict plane mask." } ], "upstream_checkpoint": { diff --git a/research/kappa010-complex-lever-floor/VERIFY.json b/research/kappa010-complex-lever-floor/VERIFY.json index 99dd2a42ba..49b96eda12 100644 --- a/research/kappa010-complex-lever-floor/VERIFY.json +++ b/research/kappa010-complex-lever-floor/VERIFY.json @@ -10,7 +10,10 @@ "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/community-frontier1094-audit/selected-replay.tar.gz" + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/paired-plane-minrank-bracket-audit/CERTIFICATE.json", + "research/paired-plane-scalar-mask-obstruction/PR1825-CERTIFICATE.json", + "research/paired-plane-block-rank/RESULT.json" ], "commands": [ { @@ -20,7 +23,7 @@ "{package}/verify.py" ], "timeout_seconds": 120, - "checks": "Binds the selected κ, ceiling model, two-output-anchor receipt, and the five-plane profile's identical selected replay archive; reconstructs the seven-block hypothetical profile; checks exact outward-rational moment intervals at a=1/9 for selected, anchor, five-plane and fractional local-rank models; certifies adjacent unpaid-count, fixed-u rank and per-block-fee boundaries with centre absent/present; and checks a passing a=1/99 positive control. This is a scoped aggregate budget screen, not a supplier or κ claim." + "checks": "Binds the selected κ, ceiling model, two-output-anchor receipt, and the five-plane profile's identical selected replay archive; reconstructs the seven-block hypothetical profile; checks exact outward-rational moment intervals at a=1/9 for selected, anchor, five-plane and fractional local-rank models; certifies adjacent unpaid-count, fixed-u rank and per-block-fee boundaries with centre absent/present; recomputes the pinned paired-plane support fit's full port-space charge; screens every tensor multiplicity d against the q-2 dirty-update floor; and checks a passing a=1/99 positive control. This is a scoped aggregate budget screen, not a supplier or κ claim." } ] } diff --git a/research/kappa010-complex-lever-floor/verify.py b/research/kappa010-complex-lever-floor/verify.py index 5d6034878b..ed94ef3ac7 100644 --- a/research/kappa010-complex-lever-floor/verify.py +++ b/research/kappa010-complex-lever-floor/verify.py @@ -15,8 +15,11 @@ 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 @@ -143,6 +146,124 @@ def passes(e: int) -> bool: 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; not a lower bound on every decoder or a native schedule.", + } + + +def block_anchor_case(base_mass: int, blocks: int, fee_per_block: int, + copies: int, centre: int) -> dict: + """Target moment for d tensor copies, with all remaining base mass at rank 51.""" + unpaid = 2 * copies + local: dict[int, Q | int] = {51: Q(base_mass, 51), 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 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") @@ -282,6 +403,49 @@ def main() -> None: 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 escape from the scalar endpoint audit: + # tensor d copies of the pinned 49-support paired-plane fit. The exact + # support spaces are repriced by their full F2 pairing ranks. The anchor + # still has 110 dirty destinations that each require a one-target ADD, so + # use e=110 per block as the most favorable ordinary affine schedule. + 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 + 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, + "minimum_dirty_updates_per_block": min_dirty_updates, + "at_minimum_affine_fee": centre_rows, + "maximum_passing_affine_fee_per_block": { + str(centre): maximum_block_anchor_fee(base_mass, blocks, + copies, centre) + for centre in (0, 64) + }, + }) + assert [x["maximum_passing_affine_fee_per_block"] for x in stacked_endpoint] == [ + {"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)}, + ] + # At d=6 the minimum local rank mass already exceeds the allowed mass; + # each further copy adds 224 paid units and removes 2W coverage units. + d6_excess = Q(base_mass + 224 * 6 + blocks * min_dirty_updates) - (Q(73 - 12) * families) + per_copy_excess = Q(224) + 2 * families + assert d6_excess == Q(208, 9) 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. @@ -349,11 +513,26 @@ def main() -> None: "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, + "minimum_one_target_dirty_updates_per_block": min_dirty_updates, + "minimum_affine_fee_per_block_used": min_dirty_updates, + "d_1_through_5_target_moments": stacked_endpoint, + "d6_minimum_fee_mass_excess": str(d6_excess), + "mass_excess_growth_per_extra_copy": str(per_copy_excess), + "conclusion": "The tensorized pinned fit plus the seven-anchor map, with at least q-2 one-target dirty updates per block, misses a=1/9 for d=1..5; d>=6 exceeds the coverage mass even before other costs.", + "scope": "This excludes only the stated fit, additive anchor contract, and selected-profile relaxation. A different support fit, changed endpoint mask, or multi-target recursive child needs its own full charge and dirty-state proof.", + }, "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 new d-fold screen uses the pinned paired-plane support fit's port-space charge and the q-2 dirty-output update floor; it does not exclude changed masks or recursive children that update multiple dirty destinations under a different contract.", ], } (HERE / "RESULT.json").write_text(json.dumps(result, indent=2) + "\n") From e697fb9ef8d57a3ddf843ac5a38ae70b3633ca6b Mon Sep 17 00:00:00 2001 From: Gonzalo-Mier Date: Sat, 17 Oct 2026 03:52:51 +0200 Subject: [PATCH 4/6] Correct paired-plane scalar cost screen --- .../kappa010-complex-lever-floor/README.md | 46 ++- .../kappa010-complex-lever-floor/RESULT.json | 346 +++++++++++++++--- .../kappa010-complex-lever-floor/SOURCES.json | 36 +- .../kappa010-complex-lever-floor/TASK.json | 36 +- .../kappa010-complex-lever-floor/VERIFY.json | 9 +- .../kappa010-complex-lever-floor/verify.py | 139 +++++-- 6 files changed, 479 insertions(+), 133 deletions(-) diff --git a/research/kappa010-complex-lever-floor/README.md b/research/kappa010-complex-lever-floor/README.md index b1b904052b..ce19880da4 100644 --- a/research/kappa010-complex-lever-floor/README.md +++ b/research/kappa010-complex-lever-floor/README.md @@ -1,4 +1,4 @@ -# Joint-lever floor for a κ = 0.1 target +# κ = 0.1 budget screens and a corrected paired-plane route **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`. @@ -45,29 +45,35 @@ The target also leaves little room for a complete anchor invoice. With all 4,766 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: additive composition still misses +## Tensorized paired-plane endpoint: separate scalar work from child rank -I checked a more aggressive escape using the exact [block-valued paired-plane endpoint](../paired-plane-block-rank/README.md) and its [49-support scalar fit](../paired-plane-minrank-bracket-audit/README.md). The fixed fit partitions the 112 ports into supports of sizes `{1: 2, 2: 31, 3: 16}`. Under the full port-space charge used by PR2203, a support of size `s` touches `s` mutually orthogonal nondegenerate planes and costs rank `2s`. Its exact copy profile is therefore `{2: 2, 4: 31, 6: 16}`, with mass **224 per payload copy**. Tensoring the fit by `d` copies gives unpaid count `u=2d` and multiplies this profile by `d`; the all-size block-rank receipt confirms the fixed mask has normalized query rank `49d`. +The exact [block-valued paired-plane endpoint](../paired-plane-block-rank/README.md) and its [49-support fitting matrix](../paired-plane-minrank-bracket-audit/README.md) partition the 112 ports into supports of sizes `{1: 2, 2: 31, 3: 16}`. Under the full port-space charge used by PR2203, a support of size `s` costs rank `2s`; the per-copy child profile is `{2: 2, 4: 31, 6: 16}`, with mass **224**. Tensor multiplicity `d` gives profile mass `224d`; the proposed two-plane coverage rule is `u=2d`. -Now combine those `d` copies with the seven-anchor profile. After replacing seven groups of 332 rank-one children by 112 children, the non-centre base mass is 3,982. I grant the strongest allowed idle/consumer relaxation by placing all of it at rank 51, and charge only the unavoidable dirty-output affine updates: each of the 110 arbitrary dirty destinations must receive a nonzero product-dependent correction, and one `ADD` changes one destination, so every 112-output block needs at least `q−2 = 110` additions. This is more favorable than the anchor's actual 112-add schedule. If the centre remains, its eight rank-8 children are restored to the profile along with its 64-unit charge. +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. -| Payload copies `d` | Unpaid `u=2d` | Target moment at the minimum 110 additions, centre-free / retained | Maximum affordable additions per block, centre-free / retained | +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.082289 / 1.093548 | none; it fails with zero additions | -| 2 | 4 | 1.063520 / 1.074779 | none; it fails with zero additions | -| 3 | 6 | 1.044752 / 1.056010 | 28 / 8 | -| 4 | 8 | 1.025983 / 1.037241 | 62 / 42 | -| 5 | 10 | 1.007214 / 1.018473 | 96 / 76 | +| 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. -The entries are certified outward-rational intervals; decimals are only for reading. Thus every `d≤5` fails even after allowing all remaining mass to use rank-51 children and reducing the anchor to its 110-update lower bound. For `d≥6`, the same minimum invoice already exceeds the coverage mass: at `d=6` it is over by exactly `208/9`, and each extra copy increases the excess by `3808/9`. Keeping the centre adds its charge and children equally on the two sides of this mass comparison, so it does not repair the excess. +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 child implementation, operand preparation, frame paths, precision/tape effects, restoration, and complete source placement remain to be priced. As a sensitivity, if other interface charges were translated to rank-one-equivalent units, the passing `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. -This closes only the **tensorized paired-plane fit plus additive seven-anchor map** under the selected coverage law and the one-target `ADD` contract. It does not price a changed support mask or a recursive child that jointly updates multiple dirty destinations. Such a child would have to reduce the 110-update floor by at least 14 (centre-free) or 34 (centre-retained) in the best `d=5` row, while also supplying the endpoint identity and full source/restoration contract. The fitted matrix alone does not do that. No supplier or κ improvement is claimed. +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 -The result rejects only the fixed selected profile and the stated seven-anchor/centre-free/rank-16 relaxation. It is not a theorem about other local words, suppliers, recursion widths or multiplication algorithms. It also does not independently reprove the predecessor anchor's local bilinear map. +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 decisive experiment must change the endpoint or the recursive consumer together: the additive d-fold plane decoder cannot fit beside even the minimum dirty-output updates, while d≥6 also violates the paid-mass envelope. A bounded follow-up should start with one complete dirty-input block whose child output writes more than one dirty destination, then price that changed contract against the d=5 target row. The blocker is that no such multi-target recursive child or selected-provider placement is currently source-bound. Further searches over the same scalar support fit or anchor schedule cannot change this decision. +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, and account for every child payload, scalar operation, frame, inverse, precision effect, and caller transfer. A pass there would make the d=3 profile 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 result cannot do that work. ## Reproduction @@ -79,16 +85,16 @@ python3 scripts/research_package.py --package research/kappa010-complex-lever-fl python3.12 scripts/research_package.py --package research/kappa010-complex-lever-floor ``` -The verifier binds the selected record, current local ceiling model, two-output-anchor result, and paired-plane fit receipts in [SOURCES.json](SOURCES.json). It checks the exact `a=1/9` interval boundaries `u=23/24`, `u=9/10` and `u=10/11`, the rank/unpaid and fee frontiers, the 49-support full port-space profile, every tensor multiplicity `d=1..5` at its minimum dirty-update count, the `d≥6` mass excess, and the lower `a=1/99` positive control. +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 temporary-sum map and its seven-block hypothesis are Cinna / commdata2338's [two-output anchor](../complex-two-output-sum-anchor-seed65ce19/README.md); retain its predecessor attributions. 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. Prepared by Codex with substantial OpenAI assistance; no independent human review is claimed. New work is Apache-2.0. +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 evaluates the selected profile, the pinned five-plane profile and the seven-anchor/centre/rank-16 relaxation, including exact unpaid-coordinate and per-block-fee boundaries; the 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. +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 a complete dirty-input endpoint leave ten coordinates unpaid?** It matters because ten is the first passing boundary even after granting a rank-16 consumer and centre removal. First step: bind one named block to a selected-provider trace and prove its entry/exit map, coefficient delivery and restoration. Blocker: no source locations or changed coverage identity are supplied. -2. **Can the selected provider realize a rank-16 consumer for the remaining 4,766 units?** The fractional profile passes at `u=10`, but it does not give a physical decoder. First step: exhibit an exact local decoder and its frames, then run the full cost through the selected word. Blocker: the anchor package has no selected-provider rank-16 consumer. -3. **Can seven two-output anchors be placed within the target budget of `e≤170` per block?** The 112 affine additions leave at most 58 rank-one-equivalent units for every other interface cost. First step: find one source-bound occurrence with the two clean required outputs and price its acquisition, routing, frame and cleanup. Blocker: no selected trace alignment has been established. +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 index 6e60da534b..c1a382ac0a 100644 --- a/research/kappa010-complex-lever-floor/RESULT.json +++ b/research/kappa010-complex-lever-floor/RESULT.json @@ -467,14 +467,286 @@ "base_mass_repacked_at_rank": 51, "base_mass_before_endpoint_and_dirty_updates": 3982, "anchor_blocks": 7, - "minimum_one_target_dirty_updates_per_block": 110, - "minimum_affine_fee_per_block_used": 110, - "d_1_through_5_target_moments": [ + "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." + }, + "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, - "minimum_dirty_updates_per_block": 110, - "at_minimum_affine_fee": { + "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, @@ -495,17 +767,13 @@ "moment_approx": "1.093547649292", "below_one": false } - }, - "maximum_passing_affine_fee_per_block": { - "0": null, - "64": null } }, { "payload_copies": 2, "unpaid_coordinates": 4, - "minimum_dirty_updates_per_block": 110, - "at_minimum_affine_fee": { + "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, @@ -526,17 +794,13 @@ "moment_approx": "1.074778879264", "below_one": false } - }, - "maximum_passing_affine_fee_per_block": { - "0": null, - "64": null } }, { "payload_copies": 3, "unpaid_coordinates": 6, - "minimum_dirty_updates_per_block": 110, - "at_minimum_affine_fee": { + "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, @@ -557,23 +821,13 @@ "moment_approx": "1.056010109235", "below_one": false } - }, - "maximum_passing_affine_fee_per_block": { - "0": [ - 28, - 29 - ], - "64": [ - 8, - 9 - ] } }, { "payload_copies": 4, "unpaid_coordinates": 8, - "minimum_dirty_updates_per_block": 110, - "at_minimum_affine_fee": { + "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, @@ -594,23 +848,13 @@ "moment_approx": "1.037241339206", "below_one": false } - }, - "maximum_passing_affine_fee_per_block": { - "0": [ - 62, - 63 - ], - "64": [ - 42, - 43 - ] } }, { "payload_copies": 5, "unpaid_coordinates": 10, - "minimum_dirty_updates_per_block": 110, - "at_minimum_affine_fee": { + "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, @@ -631,29 +875,21 @@ "moment_approx": "1.018472569178", "below_one": false } - }, - "maximum_passing_affine_fee_per_block": { - "0": [ - 96, - 97 - ], - "64": [ - 76, - 77 - ] } } ], - "d6_minimum_fee_mass_excess": "208/9", + "d8_zero_fee_mass_excess": "298/3", "mass_excess_growth_per_extra_copy": "3808/9", - "conclusion": "The tensorized pinned fit plus the seven-anchor map, with at least q-2 one-target dirty updates per block, misses a=1/9 for d=1..5; d>=6 exceeds the coverage mass even before other costs.", - "scope": "This excludes only the stated fit, additive anchor contract, and selected-profile relaxation. A different support fit, changed endpoint mask, or multi-target recursive child needs its own full charge and dirty-state proof." + "conclusion": "Under the corrected separated-scalar model, the zero-rank-one-fee exponent relaxation first passes a=1/9 at d=3 (moment 0.984346 centre-free, 0.995605 with centre); d=1,2 fail and d=8 is mass-infeasible. This is only a relaxed profile result. The earlier d=1..5 failure used a hypothetical rank-one-equivalent ADD tariff and is retained as sensitivity, not as the selected scalar cost model.", + "scope": "The exact paired-plane factorization and dirty-output anchor are not composed into a selected-provider source block. Decoder linear setup/cleanup, 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 new d-fold screen uses the pinned paired-plane support fit's port-space charge and the q-2 dirty-output update floor; it does not exclude changed masks or recursive children that update multiple dirty destinations under a different contract." + "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 d=3 moment pass uses a fractional rank-51 repacking of the remaining 3,982 rank mass and waives decoder linear setup/cleanup and source placement; it 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 index 98826e6c30..ab674a435a 100644 --- a/research/kappa010-complex-lever-floor/SOURCES.json +++ b/research/kappa010-complex-lever-floor/SOURCES.json @@ -14,6 +14,30 @@ "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" }, + { + "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", @@ -45,10 +69,10 @@ "sha256": "68475b19da4a6f3af799425a12072391b481ede51c8b269684f238befdb04bbf" }, { - "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "path": "research/paired-plane-block-rank/RESULT.json", "usage": "input", - "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", - "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + "git_blob": "2b137330e7edbbbe7bc07843a2708791b731add7", + "sha256": "8b78968378d7ed824ac2418fe40b36db04d9522c117349778655191b4ee10d6d" }, { "path": "research/paired-plane-minrank-bracket-audit/CERTIFICATE.json", @@ -61,12 +85,6 @@ "usage": "input", "git_blob": "7ca668d7d50c7276e89b0f6f9575e1b9f1ad9ef6", "sha256": "4fd648f7b5178bff5441bf364d58234b7bc1a43b924bc6da03013c948f1473b1" - }, - { - "path": "research/paired-plane-block-rank/RESULT.json", - "usage": "input", - "git_blob": "2b137330e7edbbbe7bc07843a2708791b731add7", - "sha256": "8b78968378d7ed824ac2418fe40b36db04d9522c117349778655191b4ee10d6d" } ] } diff --git a/research/kappa010-complex-lever-floor/TASK.json b/research/kappa010-complex-lever-floor/TASK.json index 779b1a4544..ad3a8c69b8 100644 --- a/research/kappa010-complex-lever-floor/TASK.json +++ b/research/kappa010-complex-lever-floor/TASK.json @@ -45,33 +45,39 @@ ] }, "scope_status": "refined", - "actual_scope": "At the donor-set target κ > 0.1, test whether a tensorized block-valued paired-plane endpoint can combine with seven two-output anchors under the selected complex budget and the dirty-output contract.", - "scope_change_reason": "The first target screen showed that one unpaid coordinate and the selected local profile are far below κ=0.1. The exact block-rank receipt offers a distinct vector-valued endpoint, so this bounded continuation tensorizes its pinned rank-49 fit, reprices every support under the full port-space tariff, and checks the complete d-fold profile against the anchor's mandatory dirty-output updates.", - "bottleneck_link": "The complex supplier binds the selected κ. At κ=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.", + "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 each modeled tensor multiplicity against the exact complex moment 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 model changes d=3 from failure to an exact relaxed moment pass, so the earlier fixed-route rejection was too strong. Source placement and the full native 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": "Stop after checking every integer tensor multiplicity d against the exact target moment and mass capacity under the minimum one-target dirty-update count. Do not search more supports or anchor schedules unless a changed recursive-child contract can reduce that update charge and comes with a complete dirty-state example and source-bound placement.", + "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": "The prior exact screens remain: the selected local word has moment 1.151904798395 at its largest feasible centre-free unpaid count u=17; the seven-anchor/centre-free/rank-16 relaxation first passes at u=10, and retaining the centre shifts that boundary to u=11. This continuation reconstructs the pinned 49-support paired-plane fit and finds its full port-space copy profile {2:2,4:31,6:16}, mass 224 per payload copy. For d tensor copies (u=2d), the most favorable seven-anchor base mass is repacked at rank 51 and each 112-output block is charged only the necessary q-2=110 dirty-target additions. At d=1..5, exact target moments remain above one (best case d=5: 1.007213975257 without centre, 1.018472569178 with centre); the fee frontiers are only 96 and 76 per block. At d=6, the minimum local mass exceeds the coverage capacity by 208/9, and each extra copy worsens that gap by 3808/9. Thus this fixed tensorized decoder plus additive anchor contract cannot reach a=1/9. No multi-target recursive child, fused endpoint, source alignment, physical supplier or κ improvement is constructed.", + "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.", "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 a changed recursive child update multiple dirty output destinations and beat the one-ADD-per-destination floor?", - "why_it_matters": "The best additive d=5 endpoint still needs at least 14 fewer rank-one-equivalent updates per block centre-free, or 34 fewer with the centre retained, before any other unknown costs.", - "first_step": "Give a complete q=3 dirty-input map with its child outputs, output writes, and exact restoration; then derive how the same contract scales to q=112.", - "blocked_by": "No selected-provider child with a multi-destination dirty-output contract or source-bound seven-anchor placement is available." + "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": "Can a different endpoint mask lower the full port-space charge per unpaid dimension?", - "why_it_matters": "The pinned paired-plane support fit costs 224 per payload copy, while the fixed tensorized construction misses the target after the mandatory anchor updates.", - "first_step": "Specify a changed directed zero mask and compute one exact fitting factorization plus its full group-space charge before screening a larger cover.", - "blocked_by": "The rank-49d theorem and charge profile apply only to the fixed selected matching and strict plane mask." + "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 omitted query setup, child wrappers and cleanup may invalidate the relaxed pass.", + "first_step": "Write the literal one-block operation schedule, including dirty-state restoration, then apply the existing scalar adapters and recursive ranks.", + "blocked_by": "The algebraic fitting certificate supplies no native schedule or provider placement." + }, + { + "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:20:09Z", - "comparison": "Canonical main was refreshed from the original d8e0f83 base. The relevant guidance diff adds a P104 precision-contract pointer to bottleneck-brief.md; the selected record, current priorities, and quantitative predecessor receipts used here are unchanged." + "checked_utc": "2026-10-17T01:52:15Z", + "comparison": "Immediately before PR submission, fetched canonical origin/main; it remains exactly 18aacb215fc3717b06be8ceb9fca62aeca0d3e99. Priority revision 6, task catalogue, family status, selected record, and bottleneck guidance have no changes from the prior checkpoint." } } diff --git a/research/kappa010-complex-lever-floor/VERIFY.json b/research/kappa010-complex-lever-floor/VERIFY.json index 49b96eda12..32341c1783 100644 --- a/research/kappa010-complex-lever-floor/VERIFY.json +++ b/research/kappa010-complex-lever-floor/VERIFY.json @@ -5,15 +5,16 @@ "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/community-frontier1094-audit/selected-replay.tar.gz", + "research/paired-plane-block-rank/RESULT.json", "research/paired-plane-minrank-bracket-audit/CERTIFICATE.json", - "research/paired-plane-scalar-mask-obstruction/PR1825-CERTIFICATE.json", - "research/paired-plane-block-rank/RESULT.json" + "research/paired-plane-scalar-mask-obstruction/PR1825-CERTIFICATE.json" ], "commands": [ { @@ -23,7 +24,7 @@ "{package}/verify.py" ], "timeout_seconds": 120, - "checks": "Binds the selected κ, ceiling model, two-output-anchor receipt, and the five-plane profile's identical selected replay archive; reconstructs the seven-block hypothetical profile; checks exact outward-rational moment intervals at a=1/9 for selected, anchor, five-plane and fractional local-rank models; certifies adjacent unpaid-count, fixed-u rank and per-block-fee boundaries with centre absent/present; recomputes the pinned paired-plane support fit's full port-space charge; screens every tensor multiplicity d against the q-2 dirty-update floor; and checks a passing a=1/99 positive control. This is a scoped aggregate budget screen, not a supplier or κ claim." + "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 moment intervals at a=1/9 for selected, anchor, five-plane, and fractional local-rank models; certifies unpaid-count, rank and tariff-sensitivity boundaries; recomputes the pinned paired-plane support fit's full port-space charge; screens all mass-feasible tensor multiplicities d=1..7 with scalar ADDs separate and checks d=8 mass infeasibility; verifies the arbitrary-dirty anchor's scalar guard receipt and the a=1/99 positive control. This is a scoped aggregate budget screen, not a supplier or \u03ba claim." } ] } diff --git a/research/kappa010-complex-lever-floor/verify.py b/research/kappa010-complex-lever-floor/verify.py index ed94ef3ac7..e3526874d4 100644 --- a/research/kappa010-complex-lever-floor/verify.py +++ b/research/kappa010-complex-lever-floor/verify.py @@ -232,9 +232,16 @@ def paired_plane_port_charge() -> dict: def block_anchor_case(base_mass: int, blocks: int, fee_per_block: int, copies: int, centre: int) -> dict: - """Target moment for d tensor copies, with all remaining base mass at rank 51.""" + """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), 1: blocks * fee_per_block} + 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 @@ -243,6 +250,14 @@ def block_anchor_case(base_mass: int, blocks: int, fee_per_block: int, 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.""" @@ -268,11 +283,13 @@ 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"] @@ -292,10 +309,10 @@ def main() -> None: ) 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 rank-one children each, - # while e=112 charges the 112 local affine additions at one hypothetical - # rank-one-equivalent unit each. + # 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"] @@ -315,6 +332,17 @@ def main() -> None: 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 @@ -403,16 +431,55 @@ def main() -> None: 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 escape from the scalar endpoint audit: - # tensor d copies of the pinned 49-support paired-plane fit. The exact - # support spaces are repriced by their full F2 pairing ranks. The anchor - # still has 110 dirty destinations that each require a one-target ADD, so - # use e=110 per block as the most favorable ordinary affine schedule. + # 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 = { @@ -425,26 +492,21 @@ def main() -> None: stacked_endpoint.append({ "payload_copies": copies, "unpaid_coordinates": 2 * copies, - "minimum_dirty_updates_per_block": min_dirty_updates, - "at_minimum_affine_fee": centre_rows, - "maximum_passing_affine_fee_per_block": { - str(centre): maximum_block_anchor_fee(base_mass, blocks, - copies, centre) - for centre in (0, 64) - }, + "scalar_dirty_update_floor_per_block": min_dirty_updates, + "if_mispriced_as_rank_one_equivalent_fee_110_per_block": centre_rows, }) - assert [x["maximum_passing_affine_fee_per_block"] for x in stacked_endpoint] == [ + 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)}, ] - # At d=6 the minimum local rank mass already exceeds the allowed mass; - # each further copy adds 224 paid units and removes 2W coverage units. - d6_excess = Q(base_mass + 224 * 6 + blocks * min_dirty_updates) - (Q(73 - 12) * families) + # 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 d6_excess == Q(208, 9) and per_copy_excess == Q(3808, 9) > 0 + 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 @@ -519,20 +581,36 @@ def main() -> None: "base_mass_repacked_at_rank": 51, "base_mass_before_endpoint_and_dirty_updates": base_mass, "anchor_blocks": blocks, - "minimum_one_target_dirty_updates_per_block": min_dirty_updates, - "minimum_affine_fee_per_block_used": min_dirty_updates, - "d_1_through_5_target_moments": stacked_endpoint, - "d6_minimum_fee_mass_excess": str(d6_excess), + "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.", + }, + "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": "The tensorized pinned fit plus the seven-anchor map, with at least q-2 one-target dirty updates per block, misses a=1/9 for d=1..5; d>=6 exceeds the coverage mass even before other costs.", - "scope": "This excludes only the stated fit, additive anchor contract, and selected-profile relaxation. A different support fit, changed endpoint mask, or multi-target recursive child needs its own full charge and dirty-state proof.", + "conclusion": "Under the corrected separated-scalar model, the zero-rank-one-fee exponent relaxation first passes a=1/9 at d=3 (moment 0.984346 centre-free, 0.995605 with centre); d=1,2 fail and d=8 is mass-infeasible. This is only a relaxed profile result. The earlier d=1..5 failure used a hypothetical rank-one-equivalent ADD tariff and is retained as sensitivity, not as the selected scalar cost model.", + "scope": "The exact paired-plane factorization and dirty-output anchor are not composed into a selected-provider source block. Decoder linear setup/cleanup, 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 new d-fold screen uses the pinned paired-plane support fit's port-space charge and the q-2 dirty-output update floor; it does not exclude changed masks or recursive children that update multiple dirty destinations under a different contract.", + "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 d=3 moment pass uses a fractional rank-51 repacking of the remaining 3,982 rank mass and waives decoder linear setup/cleanup and source placement; it 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") @@ -545,6 +623,7 @@ def main() -> None: 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__": From 412484e848cba66b6af65523d01e65cb84f36ebb Mon Sep 17 00:00:00 2001 From: Gonzalo-Mier Date: Sat, 17 Oct 2026 03:57:25 +0200 Subject: [PATCH 5/6] Mark paired-plane child tariff as conditional --- .../kappa010-complex-lever-floor/README.md | 12 +++++++----- .../kappa010-complex-lever-floor/RESULT.json | 9 +++++---- .../kappa010-complex-lever-floor/SOURCES.json | 18 ++++++++++++++++++ .../kappa010-complex-lever-floor/TASK.json | 16 ++++++++-------- .../kappa010-complex-lever-floor/VERIFY.json | 2 +- .../kappa010-complex-lever-floor/verify.py | 9 +++++---- 6 files changed, 44 insertions(+), 22 deletions(-) diff --git a/research/kappa010-complex-lever-floor/README.md b/research/kappa010-complex-lever-floor/README.md index ce19880da4..2f95f32b2e 100644 --- a/research/kappa010-complex-lever-floor/README.md +++ b/research/kappa010-complex-lever-floor/README.md @@ -1,4 +1,4 @@ -# κ = 0.1 budget screens and a corrected paired-plane route +# κ = 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`. @@ -47,13 +47,13 @@ This gives a concrete target-scale requirement for this bundle: even after grant ## Tensorized paired-plane endpoint: separate scalar work from child rank -The exact [block-valued paired-plane endpoint](../paired-plane-block-rank/README.md) and its [49-support fitting matrix](../paired-plane-minrank-bracket-audit/README.md) partition the 112 ports into supports of sizes `{1: 2, 2: 31, 3: 16}`. Under the full port-space charge used by PR2203, a support of size `s` costs rank `2s`; the per-copy child profile is `{2: 2, 4: 31, 6: 16}`, with mass **224**. Tensor multiplicity `d` gives profile mass `224d`; the proposed two-plane coverage rule is `u=2d`. +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 | +| 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 | @@ -65,7 +65,9 @@ Seven hypothetical q=112 dirty-output anchors replace 332 rank-one children by 1 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. -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 child implementation, operand preparation, frame paths, precision/tape effects, restoration, and complete source placement remain to be priced. As a sensitivity, if other interface charges were translated to rank-one-equivalent units, the passing `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. +`*` 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. @@ -73,7 +75,7 @@ The unchanged bit-side primitive endpoint is `a=0.001733427039589844234749`, whi 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, and account for every child payload, scalar operation, frame, inverse, precision effect, and caller transfer. A pass there would make the d=3 profile 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 result cannot do that work. +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 diff --git a/research/kappa010-complex-lever-floor/RESULT.json b/research/kappa010-complex-lever-floor/RESULT.json index c1a382ac0a..7d7f5a5882 100644 --- a/research/kappa010-complex-lever-floor/RESULT.json +++ b/research/kappa010-complex-lever-floor/RESULT.json @@ -461,7 +461,7 @@ "6": 16 }, "port_space_mass_per_payload_copy": 224, - "scope": "Pinned disjoint-support fit, priced by full port-space Gram ranks; not a lower bound on every decoder or a native schedule." + "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, @@ -490,6 +490,7 @@ "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, @@ -880,8 +881,8 @@ ], "d8_zero_fee_mass_excess": "298/3", "mass_excess_growth_per_extra_copy": "3808/9", - "conclusion": "Under the corrected separated-scalar model, the zero-rank-one-fee exponent relaxation first passes a=1/9 at d=3 (moment 0.984346 centre-free, 0.995605 with centre); d=1,2 fail and d=8 is mass-infeasible. This is only a relaxed profile result. The earlier d=1..5 failure used a hypothetical rank-one-equivalent ADD tariff and is retained as sensitivity, not as the selected scalar cost model.", - "scope": "The exact paired-plane factorization and dirty-output anchor are not composed into a selected-provider source block. Decoder linear setup/cleanup, frames, precision, tape, restoration and whole-supplier transfer remain unpriced; no new kappa is established." + "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.", @@ -889,7 +890,7 @@ "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 d=3 moment pass uses a fractional rank-51 repacking of the remaining 3,982 rank mass and waives decoder linear setup/cleanup and source placement; it is not an implementation or kappa improvement.", + "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 index ab674a435a..1dcd1c163a 100644 --- a/research/kappa010-complex-lever-floor/SOURCES.json +++ b/research/kappa010-complex-lever-floor/SOURCES.json @@ -14,6 +14,12 @@ "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", @@ -68,6 +74,12 @@ "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", @@ -80,6 +92,12 @@ "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", diff --git a/research/kappa010-complex-lever-floor/TASK.json b/research/kappa010-complex-lever-floor/TASK.json index ad3a8c69b8..e9a02d9b0f 100644 --- a/research/kappa010-complex-lever-floor/TASK.json +++ b/research/kappa010-complex-lever-floor/TASK.json @@ -45,13 +45,13 @@ ] }, "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 each modeled tensor multiplicity against the exact complex moment 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 model changes d=3 from failure to an exact relaxed moment pass, so the earlier fixed-route rejection was too strong. Source placement and the full native decoder cost remain open.", + "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.", + "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": [ @@ -63,9 +63,9 @@ }, { "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 omitted query setup, child wrappers and cleanup may invalidate the relaxed pass.", - "first_step": "Write the literal one-block operation schedule, including dirty-state restoration, then apply the existing scalar adapters and recursive ranks.", - "blocked_by": "The algebraic fitting certificate supplies no native schedule or provider placement." + "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?", @@ -77,7 +77,7 @@ "upstream_checkpoint": { "commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", "priority_revision": 6, - "checked_utc": "2026-10-17T01:52:15Z", - "comparison": "Immediately before PR submission, fetched canonical origin/main; it remains exactly 18aacb215fc3717b06be8ceb9fca62aeca0d3e99. Priority revision 6, task catalogue, family status, selected record, and bottleneck guidance have no changes from the prior checkpoint." + "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 index 32341c1783..57e69111f7 100644 --- a/research/kappa010-complex-lever-floor/VERIFY.json +++ b/research/kappa010-complex-lever-floor/VERIFY.json @@ -24,7 +24,7 @@ "{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 moment intervals at a=1/9 for selected, anchor, five-plane, and fractional local-rank models; certifies unpaid-count, rank and tariff-sensitivity boundaries; recomputes the pinned paired-plane support fit's full port-space charge; screens all mass-feasible tensor multiplicities d=1..7 with scalar ADDs separate and checks d=8 mass infeasibility; verifies the arbitrary-dirty anchor's scalar guard receipt and the a=1/99 positive control. This is a scoped aggregate budget screen, not a supplier or \u03ba claim." + "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 index e3526874d4..8da3232eb8 100644 --- a/research/kappa010-complex-lever-floor/verify.py +++ b/research/kappa010-complex-lever-floor/verify.py @@ -226,7 +226,7 @@ def paired_plane_port_charge() -> dict: "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; not a lower bound on every decoder or a native schedule.", + "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.", } @@ -594,14 +594,15 @@ def main() -> None: "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": "Under the corrected separated-scalar model, the zero-rank-one-fee exponent relaxation first passes a=1/9 at d=3 (moment 0.984346 centre-free, 0.995605 with centre); d=1,2 fail and d=8 is mass-infeasible. This is only a relaxed profile result. The earlier d=1..5 failure used a hypothetical rank-one-equivalent ADD tariff and is retained as sensitivity, not as the selected scalar cost model.", - "scope": "The exact paired-plane factorization and dirty-output anchor are not composed into a selected-provider source block. Decoder linear setup/cleanup, frames, precision, tape, restoration and whole-supplier transfer remain unpriced; no new kappa is established.", + "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.", @@ -609,7 +610,7 @@ def main() -> None: "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 d=3 moment pass uses a fractional rank-51 repacking of the remaining 3,982 rank mass and waives decoder linear setup/cleanup and source placement; it is not an implementation or kappa improvement.", + "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.", ], } From 7d40236bf22109ad64ae95a1d25eff7fa40478b5 Mon Sep 17 00:00:00 2001 From: Gonzalo-Mier Date: Sat, 17 Oct 2026 04:02:10 +0200 Subject: [PATCH 6/6] Screen selected bit profile for kappa 0.1 --- research/kappa010-rank-cap-floor/README.md | 8 +- research/kappa010-rank-cap-floor/RESULT.json | 80 ++++++++++++++++++++ research/kappa010-rank-cap-floor/TASK.json | 18 ++--- research/kappa010-rank-cap-floor/VERIFY.json | 2 +- research/kappa010-rank-cap-floor/verify.py | 74 ++++++++++++++++++ 5 files changed, 171 insertions(+), 11 deletions(-) diff --git a/research/kappa010-rank-cap-floor/README.md b/research/kappa010-rank-cap-floor/README.md index 312f71e4b5..31422dfff3 100644 --- a/research/kappa010-rank-cap-floor/README.md +++ b/research/kappa010-rank-cap-floor/README.md @@ -40,6 +40,12 @@ If the centre/copy charge is also removed, the minimum unpaid counts become 2 (b 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 @@ -62,6 +68,6 @@ This refines the `coverage-law-change` card for the user-set target κ > 0.1. It 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. -A fresh overlap refresh on 2026-10-17 covered 259 open PRs and 1,866 discussions (complete pagination). It surfaced open PR #3093, which audits the paid terms of two fixed local profiles (#2979 and #3042) at the same target. That is complementary to this package's lower bound over every histogram admitted by the current aggregate coverage laws and rank caps; this package also computes the unpaid/rank thresholds for both suppliers. PRs #3064 and #3097 and Discussions #1163, #1166 and #1167 were also checked. The overlap helper reports possible overlap, not novelty; see the exact scopes and recheck before expanding the work. +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 index 0a2908963b..8015a60919 100644 --- a/research/kappa010-rank-cap-floor/RESULT.json +++ b/research/kappa010-rank-cap-floor/RESULT.json @@ -88,6 +88,86 @@ } } }, + "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, diff --git a/research/kappa010-rank-cap-floor/TASK.json b/research/kappa010-rank-cap-floor/TASK.json index f18e058d34..136d87124a 100644 --- a/research/kappa010-rank-cap-floor/TASK.json +++ b/research/kappa010-rank-cap-floor/TASK.json @@ -45,21 +45,21 @@ ] }, "scope_status": "refined", - "actual_scope": "For the donor-set target κ > 0.1, certify the most favorable aggregate moment permitted by the current bit and complex coverage laws and rank caps; identify the exact unpaid-coordinate or depth thresholds needed to reopen the budget.", - "scope_change_reason": "The user raised the target from the repository's planning target κ > 0.01 to κ > 0.1. Before constructing an endpoint change, this exact target-level screen tests whether the existing coverage identities and depth envelopes can possibly support it.", + "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.", + "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 two unpaid coordinates be carried through one complete dirty-input endpoint on the bit side?", - "why_it_matters": "Two is the minimum count that makes the aggregate floor pass at the current bit cap, but the actual endpoint could repay the apparent slack through the consumer or restoration.", - "first_step": "Trace a named two-coordinate candidate through one complete selected bit call and record all source, frame, consumer, and restoration charges.", - "blocked_by": "The current endpoint contract retains one unpaid coordinate and no changed complete call is available." + "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?", @@ -77,7 +77,7 @@ "upstream_checkpoint": { "commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", "priority_revision": 6, - "checked_utc": "2026-10-17T01:20:09Z", - "comparison": "Canonical main was refreshed from the original d8e0f83 base. The relevant guidance diff adds a P104 precision-contract pointer to bottleneck-brief.md; the selected record, current priorities, and quantitative predecessor receipts used here are unchanged." + "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 index 25d776f6ef..9d69dc91b7 100644 --- a/research/kappa010-rank-cap-floor/VERIFY.json +++ b/research/kappa010-rank-cap-floor/VERIFY.json @@ -24,7 +24,7 @@ "{package}/verify.py" ], "timeout_seconds": 120, - "checks": "Binds the selected record and predecessor screen receipts; checks the exact a=1/9 aggregate rank-cap lower bound, the paired-plane u=2/c=112 case, unpaid-coordinate and required-depth boundaries, and strict fail/pass controls. The all-mass-at-cap case is an optimistic budget relaxation, not a supplier." + "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 index 5bad90be19..2b90028816 100644 --- a/research/kappa010-rank-cap-floor/verify.py +++ b/research/kappa010-rank-cap-floor/verify.py @@ -20,7 +20,9 @@ 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 @@ -31,12 +33,23 @@ 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) @@ -160,6 +173,58 @@ def main() -> None: 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, @@ -206,6 +271,15 @@ def main() -> None: "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,