diff --git a/research/p104-helper-subspace-splits/BOUNDARIES.json b/research/p104-helper-subspace-splits/BOUNDARIES.json new file mode 100644 index 0000000000..c6ce5174bd --- /dev/null +++ b/research/p104-helper-subspace-splits/BOUNDARIES.json @@ -0,0 +1,255 @@ +[ + { + "source_step": 0, + "anchor": [ + "ADD", + 653, + 652, + "-1", + 120 + ], + "witness": { + "kind": "boundary_basis", + "reverse": true, + "helper": 652, + "cut": 11382, + "frame": 120, + "output": [ + [ + 205, + "-2" + ], + [ + 648, + "-1" + ], + [ + 649, + "-1" + ], + [ + 650, + "1" + ], + [ + 652, + "1" + ] + ], + "cancel": [ + [ + 648, + "1" + ], + [ + 649, + "1" + ], + [ + 650, + "-1" + ] + ] + } + }, + { + "source_step": 1, + "anchor": [ + "ADD", + 346, + 341, + "1", + 240 + ], + "witness": { + "kind": "boundary_basis", + "reverse": false, + "helper": 341, + "cut": 11167, + "frame": 240, + "output": [ + [ + 93, + "-2" + ], + [ + 339, + "-2" + ], + [ + 341, + "1" + ], + [ + 351, + "2" + ] + ], + "cancel": [ + [ + 337, + "2" + ] + ] + } + }, + { + "source_step": 2, + "anchor": [ + "ADD", + 597, + 596, + "-1", + 1053 + ], + "witness": { + "kind": "boundary_basis", + "reverse": true, + "helper": 596, + "cut": 11400, + "frame": 1053, + "output": [ + [ + 188, + "-1" + ], + [ + 592, + "-1" + ], + [ + 593, + "1" + ], + [ + 594, + "1" + ], + [ + 596, + "1" + ] + ], + "cancel": [ + [ + 592, + "1" + ], + [ + 593, + "-1" + ], + [ + 594, + "-1" + ] + ] + } + }, + { + "source_step": 3, + "anchor": [ + "ADD", + 669, + 668, + "-1", + 1051 + ], + "witness": { + "kind": "boundary_basis", + "reverse": true, + "helper": 668, + "cut": 11471, + "frame": 1051, + "output": [ + [ + 115, + "2" + ], + [ + 664, + "1" + ], + [ + 665, + "1" + ], + [ + 666, + "-1" + ], + [ + 668, + "1" + ] + ], + "cancel": [ + [ + 664, + "-1" + ], + [ + 665, + "-1" + ], + [ + 666, + "1" + ] + ] + } + }, + { + "source_step": 4, + "anchor": [ + "ADD", + 685, + 684, + "-1", + 1049 + ], + "witness": { + "kind": "boundary_basis", + "reverse": true, + "helper": 684, + "cut": 11515, + "frame": 1049, + "output": [ + [ + 126, + "2" + ], + [ + 680, + "-1" + ], + [ + 681, + "1" + ], + [ + 682, + "1" + ], + [ + 684, + "1" + ] + ], + "cancel": [ + [ + 680, + "1" + ], + [ + 681, + "-1" + ], + [ + 682, + "-1" + ] + ] + } + } +] diff --git a/research/p104-helper-subspace-splits/NOTICE b/research/p104-helper-subspace-splits/NOTICE index f34687ff7e..f2157e9003 100644 --- a/research/p104-helper-subspace-splits/NOTICE +++ b/research/p104-helper-subspace-splits/NOTICE @@ -3,8 +3,13 @@ Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. The same assistant performed the construction and author-side checks. Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. -Ali Romman: PR5580 contact step and PR5544/5545 complete P104 caller. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. thu-nmrc: PR5551 contact improvements. diff --git a/research/p104-helper-subspace-splits/PREPARATION.json b/research/p104-helper-subspace-splits/PREPARATION.json new file mode 100644 index 0000000000..663e1f2bcb --- /dev/null +++ b/research/p104-helper-subspace-splits/PREPARATION.json @@ -0,0 +1,45 @@ +{ + "helper": 573, + "replacements": [ + { + "event": 13651, + "old": [ + "MOVE", + 573, + 3, + 595, + false + ], + "suppliers": [ + [ + 572, + "1" + ], + [ + 732, + "-2" + ] + ] + }, + { + "event": 13676, + "old": [ + "MOVE", + 573, + 595, + 603, + false + ], + "suppliers": [ + [ + 572, + "1" + ], + [ + 710, + "2" + ] + ] + } + ] +} diff --git a/research/p104-helper-subspace-splits/PROOF.md b/research/p104-helper-subspace-splits/PROOF.md index ca97998444..594b26982f 100644 --- a/research/p104-helper-subspace-splits/PROOF.md +++ b/research/p104-helper-subspace-splits/PROOF.md @@ -1,9 +1,10 @@ # Independent helper splits and the complete cost -This proof changes the helper input and output contract of the exact PR5565 -word. It retains every main endpoint, paid Gaussian call and owned lifetime. -All scalar identities below are over the rationals. The native check supplies -exact phases and the rule for every positive tensor width. +This proof changes the helper input and output contract of the exact PR5601 +word. It composes released relay and boundary changes, nine independent +splits and two prepared queries. Every main endpoint is retained. Every +owned operation and removed target is checked and charged. Scalar identities +are rational; the native check supplies exact phases at every positive width. ## 1. A split criterion @@ -59,7 +60,8 @@ one U-to-V target by a U-to-F target and an F-to-V target. This uses a new input, not two outputs computed from one input. It does not assume a helper is zero. The early output is a public field and stays live until the caller returns. The successor input is public from the start and -is first used at the cut. No new COPY, CLEAR or owned lifetime is introduced. +is first used at the cut. The split itself introduces no new COPY, CLEAR +or owned lifetime. The source's owned erasures remain charged under the inherited contract. All three basis changes use common physical charts. They therefore commute @@ -68,70 +70,146 @@ with the relevant chart operator. Native normalization gives ranks stay outside the tensor substitution. The frame induction applies at every positive width; it is not a test at width one alone. -## 2. The first explicit split +## 2. Five released boundary relations + +The geometric input is PR5601 at `8f7e870b22885a367b347dc12791da98fd53f83d`. +The PR5605 constructor at `4a57d245ac3918ccc9947a867ece24573605e243` first +reconstructs its exact relay word on the common PR5580 source. Its eight +changed intervals give paid change `H6-H1-H2-H3`. +The unchanged PR5612 constructor at +`faa9f6dbe6b8cc4a996d3edeca71823056453e1a` then delays helper 696's preparation +through the complementary component in helper 700. It removes the remaining +owned-738 contact into 159. Four initial ADDs cancel the nuisance input sum +on outputs 159 and 222; nine full-frame operations restore helpers 696, +697, 698, 700 and 703. Its exact source and output hashes are checked. +The paid delta is `H4+H7-H5-H6`, with every target retained. + +The combined relay's 13 changed intervals are disjoint from PR5601's 21 +changed intervals, including insertions. A strict merge rejects overlap, +retains PR5601's frame metadata, and replays the complete result. Both +sources' input corrections and late cleanup remain in the merged program. +The retained PR5602 constructor and witness come from +`6c224aa720203c4f4615e6538d8038a275387db8`. No coefficient, helper, frame, +cancellation vector or output vector in those relations changes. Only the +chronological cut indices change, with explicit event anchors in `BOUNDARIES.json`. + +For a forward boundary relation, the complete prefix gives a helper input +combination after cancellation by coframed fields. A scalar input basis +makes this combination one independent input. The helper has no later source +read, so it can finish at that frame. The reverse relations supply the +corresponding early-input rule. The source constructor uses an algebraic +transpose to derive that rule; it does not execute the owned program backward. +The final program restores the eight COPY opcodes. Its complete subsequence +of operations involving owned fields equals the original chronological +subsequence of the merged relay source, byte for byte, before the independent +splits rename owned roles. The final preparation adds its own owned role. + +The five fixed relations use helpers 652, 341, 596, 668 and 684. Each replaces +one H9 helper target by H4 and removes one paid H5. The complete arbitrary-input +interface is checked after every relation. The sixth PR5602 relation uses a +frame-597 contact absent from the PR5565 cascade; it is not used. + +## 3. Nine independent splits + +After those five changes, the first split uses the cut after zero-based +event 12520, chart 306 of dimension four, and pivot 259. Its helper group +has initial chart 3 (dimension zero) and final chart 127 (dimension nine). +With e_r the coordinate at role r, the exact vectors are -The source is PR5565 at `9af814164b9dfc21f19ec737959d67cb71488c95`. -Use the cut after zero-based event 13775, chart 120 of dimension five, and -pivot 648. The boundary group has initial chart 3 (dimension zero) and final -chart 127 (dimension nine). With e_r the coordinate at role r, the exact -vectors are +```math +a=e_{261}^T+(e_{256}^T+e_9^T)/2+2e_{259}^T,\qquad b=e_{259}/2, +``` ```math -a=e_{652}^T,\quad b=e_{652}-e_{648}+e_{650}-e_{649}, +c=2(e_{259}^T+e_{61}^T+e_{265}^T), ``` ```math -c=e_{652}^T,\quad d=e_{652}-2e_{205}-e_{648}+e_{650}-e_{649}. +d=(e_{262}-e_{270}+e_{265}+e_{264}-e_{256}-e_{271}+e_{263})/2. ``` The complete prefix gives aP=c; the complete suffix gives Sb=d. -Both pairings are one. The boundary basis uses six scalar events and the -local basis uses five. With their inverses, the split adds eighteen ADDs -and four sign SCALEs. It replaces H9 by independent H5 and H4 targets. -The full sequence, including each updated event index, is in `SPLITS.json`. +Both pairings are one. The boundary basis has 14 scalar events and the +local basis has four. With their inverses, this adds 30 ADDs and six dyadic +SCALEs. It replaces one H9 target by independent H4 and H5 targets. +`SPLITS.json` gives every subsequent cut and all four exact vectors. `check_cut` reconstructs each prefix functional and propagates each suffix -column. It checks that all other input and output coefficients are zero. -The verifier then checks every public and owned row after each complete -split. A separate dense-integer transpose replay checks all 571,536 entries -of the final 756 by 756 interface. +column. It checks zero support on every other input and output. Full row +replay checks each intermediate construction. A separate dense-integer +transpose replay checks all 565,504 entries of the final 752 by 752 interface. -## 3. The complete target change +The nine splits are two H9 to H4+H5, five H9 to H2+H7, and two H9 to H1+H8. +They add nine independent inputs before preparation. The 735 public fields +become 744, with 536 helpers and 208 main fields. The source has 25,132 events; +the relay has 25,179; the boundary step has 25,184; the split word has 25,440. +The split step adds 256 scalar events. Its helper profile is -The thirteen splits are +```text +{1:2, 2:5, 4:91, 5:6, 7:5, 8:16, 9:411}. +``` -- six H9 to H4 + H5; -- five H9 to H2 + H7; -- two H9 to H1 + H8. +The verifier replays the retained PR5580 and PR5565 words. It checks the +PR5565 paid delta `-8H1-H3-2H4+4H5` and helper delta `-H8+H9`, then the +PR5601 paid delta `-2H2+2H3-2H4+H5` and helper delta `H4-H5`. These are +credited source changes, not new discoveries in this package. -They add 13 independent helper inputs. The source's 735 public fields become -748, of which 540 are helpers and 208 are main fields. Eight owned lifetime -roles remain; only one is live at a time. The 25,133 source events become -25,475. Every source paid occurrence remains, with the same ordered pair of -charts, rank and ownership. Some register names change to identify the -successor input. The new local helper profile is +For 00. +The preparation below adds one more strictly positive term. Against the +consumed PR5601 word, the complete target-minus-paid moment increases by -```text -{1:2, 2:5, 4:89, 5:11, 7:5, 8:16, 9:412}. +```math +18[7g(4,5)+5g(2,7)+2g(1,8)+g(1,2)+g(3,3)+g(1,1) + +5^t+6^t-4^t-7^t]. ``` -The verifier also replays the retained PR5580 source. It checks that PR5565 -changes its local paid profile by `-8H1-H3-2H4+4H5` and its helper profile -by `-H8+H9`. These source changes are by Pierre-Loic Doulcet (hexapode). The new splits retain -that paid profile. The earlier fifteen-split component on PR5580 is frozen -at `31a4de233bbdd65c04c63dc3398ecf0eed8e1375`. Two of its cuts are absent -from the PR5565 composition, but the lower paid cost gives a larger kappa. +The five boundary relations supply five g(4,5) terms. The nine splits supply +the next two g(4,5), five g(2,7) and two g(1,8) terms. The relay supplies +`g(1,2)+g(3,3)=1+2^t+3^t-6^t`. Preparation supplies `g(1,1)=2-2^t`. +The delayed relay supplies `5^t+6^t-4^t-7^t>0`, since strict concavity gives +`5^t-4^t>7^t-6^t`. +Every target debit and removed paid call enters the final invoice. The old +components' reported kappa gains are not added. + +## 3a. Prepare the rank-two prefix -For every 0(a+b)^t`. Each split strictly increases the target moment and leaves -the paid moment fixed. The signed local target change is +PR5606 supplies two exact value identities for prefix helper 573. In the +new split word, its input is set to zero. At events 13651 and 13676, the +complete normalized rows satisfy ```math -2H_1+5H_2+6H_4+6H_5+5H_7+2H_8-13H_9. +r_{573}=r_{572}-2r_{732} \quad\hbox{at chart 595}, ``` -Its rank mass is zero, as required. A source-bound complete caller, not a -standalone packing relaxation, supplies the resulting exponent claim. +```math +r_{573}=r_{572}+2r_{710} \quad\hbox{at chart 603}. +``` + +The suppliers are live in the destination chart at each site. These are +checks on the new word; they are not assumed from the old source. Each +rank-one query is replaced by CLEAR, INIT, COPY and ADD. The helper is owned +from the start, and its final normalized row is zero before the last CLEAR. +The rank-two productive target is removed. Thus the local paid profile loses +two H1 calls, and the target profile loses one H2. + +The constructor renames retired role 573 to owned role 751. Public roles above +573 shift down by one; the eight original owned roles shift down by one. +All main roles are below 573 and keep their labels. The final word declares +nine owned roles, eleven initialization/erasure lifetimes and peak occupancy +two. Earlier frozen inputs retain their original eight-role format. The +checker derives matrix width and ownership bounds from this declared inventory. + +The final word has 743 independent public inputs, 535 helpers and 25,448 +events. Its 752 by 752 matrix includes all nine owned roles. The final helper +profile is + +```text +{1:2, 2:4, 4:91, 5:6, 7:5, 8:16, 9:411}. +``` + +The added COPY/ADD work and all three new lifetimes enter the scalar and +route bounds. The complete bill uses the smaller target count and peak two; +it does not retain the old target credit or one-owned-field bound. ## 4. Native maps and the caller @@ -152,8 +230,8 @@ contacts, 53,248 central-square column checks, 3,328 main Gaussian targets, spectators, exact phases and every whole target. The complete counts are ```text -paid calls: 66726 -productive fields: 13048 = 18*540 + 32*104 +paid calls: 66546 +productive fields: 12958 = 18*535 + 32*104 rank mass surplus: 760 maximum target: 145 maximum paid rank: 72 @@ -168,16 +246,24 @@ It is not left at the old 12,814 value. ## 5. Strictification, compiler and outer transfer Two independent rational interval engines evaluate the complete moments. -The exact raw crossing is in (0.00310045630724, 0.00310045630725). -`RESULT.json` gives its rational endpoints and the strict tested margin. The claimed kappa is 0.00310045 and the tested saving is -0.0031004505. Their gap funds the finite compiler and outer parameters. An exact negative +The exact raw crossing is in (0.00310440547057, 0.00310440547058). +`RESULT.json` gives its rational endpoints and the strict tested margin. The claimed kappa is 0.00310440546 and the tested saving is +0.003104405465. Their gap funds the finite compiler and outer parameters. An exact negative derivative bound on [0,0.0034] makes this crossing the raw ceiling for this fixed invoice under the retained BIT cap. It is not a global optimum. +PR5613 reaches the same signed recursive moment with a different inventory: +its word has 72 more rank-five paid calls and 72 more rank-five targets. Thus the +delayed relay adds no new moment beyond that released construction. This +package retains the five fixed boundaries and nine splits and gives a smaller +complete inventory. The tighter compiler reserve below permits a saving +0.00000000546 above PR5613's rounded claim of 0.00310440. This is rounding +headroom in the common invoice, not another physical mechanism. + Power 1024, cutoff 17, target floor 18 and tail offset 1/5 are retained. The extra independent fields require a different tail bound: both charged tail ratios are below 39/40, and `(39/40)^128 < 1/16`. Eight such blocks still -give the retained `2^-32` remainder. The fixed reserve is `10^-10`. +give the retained `2^-32` remainder. The fixed reserve is `10^-12`. The complete normalized cost is strictly less than one. The old cutoff 20 fails and is retained as a control. @@ -202,7 +288,7 @@ identities and every new numerical condition within that framework. The enormous uniform word and complete rounded multiplier are not materialized. These are author-side checks by the same AI-assisted author. They are not independent human acceptance or a proof-kernel theorem. -The final exact discovery screen tests 52 boundary groups and finds no +The final exact discovery screen tests 46 boundary groups and finds no further candidate in its finite basis-pair class. It does not prove a maximum over bases, cuts, scalar programs, frames, controllers or multiplication algorithms. diff --git a/research/p104-helper-subspace-splits/README.md b/research/p104-helper-subspace-splits/README.md index f6303a8813..121f15971a 100644 --- a/research/p104-helper-subspace-splits/README.md +++ b/research/p104-helper-subspace-splits/README.md @@ -1,45 +1,56 @@ -# Conditional kappa 0.00310045 from independent helper splits - -This construction raises complete conditional **kappa to 0.00310045**. -The gain over [PR5565](https://github.com/CrocSwap/integer-mult-bounds/pull/5565) -(0.00308520) is **0.00001525**, about **0.4943%**. The gain over selected -0.003027288235 is **0.000073161765**. The selected record is unchanged. - -The mechanism changes the independent helper basis. At a common-frame cut, -one helper combination can finish early and a fresh independent input can -use the remaining program. Thirteen explicit splits replace 527 helper -jobs by 540 helper jobs. They add 342 scalar events and no recursive Gaussian -call. Both input and output support are checked over every field; a local -pure row alone does not earn a new target. - -Read the [proof](PROOF.md), [exact cuts](SPLITS.json), [complete word](WORD.json.gz), -[receipt](RESULT.json), [source pins](SOURCES.json), and [validation record](VALIDATION.md). -The first split is an explicit 22-event change from one H9 target to independent -H5 and H4 targets. The complete caller uses the new word at all 18 full sites. +# Conditional kappa 0.00310440546 from composed helper splits + +This construction gives complete conditional **kappa 0.00310440546**. +It improves the merged [PR5599](https://github.com/CrocSwap/integer-mult-bounds/pull/5599) +claim of 0.00310045 by **0.00000395546**. It also improves the consumed +[PR5601](https://github.com/CrocSwap/integer-mult-bounds/pull/5601) +claim by **0.00001845546** and the released +[PR5608](https://github.com/CrocSwap/integer-mult-bounds/pull/5608) claim by +**0.00000256546**. The gain over selected 0.003027288235 is **0.000077117225** +(about **2.5474%**). The selected record is unchanged. + +At a common-frame cut, a pure helper input functional and a pure helper +output direction can have unit pairing. Explicit scalar bases then let one +independent target finish early and a fresh independent input use the rest +of the program. Both complete boundary supports must be proved. A pure +intermediate row alone does not earn a second target. + +The construction combines the released PR5605 shared relay and PR5612 delayed +relay with PR5601, +then applies five fixed PR5602 boundary relations and nine independent helper +splits. Finally it applies PR5606's two preparation identities in the new +basis. The preparation removes two paid rank-one queries and debits the +rank-two helper target. Its extra owned work is charged. + +Read the [proof](PROOF.md), [five fixed relations](BOUNDARIES.json), +[nine exact cuts](SPLITS.json), [preparation sites](PREPARATION.json), +[complete word](WORD.json.gz), [receipt](RESULT.json), +[source pins](SOURCES.json), and [validation record](VALIDATION.md). | Quantity | Result | | --- | ---: | -| Local public inputs | 748 | -| Independent helpers per full call | 540 | -| Owned lifetimes / peak owned fields | 8 / 1 | -| Local events | 25,475 | -| Complete paid calls | 66,726, unchanged | -| Complete productive fields | 13,048 | -| Complete rank-mass surplus | 760, unchanged | -| Tested saving | 0.0031004505 | -| Complete conditional kappa | 0.00310045 | -| Raw crossing | (0.00310045630724, 0.00310045630725) | -| Exact native maps | 2,923 | - -The added helpers enter the complete completion-tail calculation. The tail -bound changes to 39/40, with `(39/40)^128 < 1/16`. The compiler logarithm -power changes from 1000 to 1024. Every native map, helper normalizer, main -adapter, scalar basis operation, route, COPY/CLEAR cost, thin query and -whole idle is included. The ordinary BIT saving remains 0.0034. Two exact -moment engines and all 54 strict plus four functional outer conditions are -checked. The receipt gives the raw crossing and the finite compiler threshold. -A negative derivative bound supplies the raw ceiling for this fixed invoice -on [0,0.0034]; it does not bound other constructions. +| Local public inputs / independent helpers | 743 / 535 | +| Owned roles / lifetimes / peak | 9 / 11 / 2 | +| Local events | 25,448 | +| Complete paid calls | 66,546 | +| Complete productive fields | 12,958 | +| Complete rank-mass surplus | 760 | +| Tested saving | 0.003104405465 | +| Complete conditional kappa | 0.00310440546 | +| Raw crossing | (0.00310440547057, 0.00310440547058) | +| Exact native maps | 2,916 | + +Every helper normalizer, main adapter, scalar basis operation, route, +COPY/CLEAR path, thin query and whole idle is charged. The independent field +count enters the completion-tail bound. Tail decay is 39/40 and the compiler +logarithm power is 1024. The ordinary BIT saving stays at 0.0034. Two exact +moment engines, every compiler condition, 54 strict outer conditions and +four functional conditions are checked. The finite compiler threshold is +`N = 2^80511200000000000`; that word is not materialized. + +A negative derivative bound gives the raw ceiling for this fixed invoice +on [0,0.0034]. The final discovery screen finds no further tested basis pair +in 46 boundary groups. Neither result proves a global optimum. ## Reproduce @@ -50,8 +61,8 @@ python3 -B scripts/research_package.py --package research/p104-helper-subspace-s python3 -B scripts/research_package.py --package research/p104-helper-subspace-splits ``` -The registered hook runs normally and with `-O`. Its success markers are -`PASS_P104_HELPER_SUBSPACE_KAPPA_00310045` and +The registered hook runs normally and with `-O`. Success markers are +`PASS_P104_HELPER_SUBSPACE_KAPPA_00310440546` and `PASS_REGISTERED_RESEARCH_PACKAGE`. Direct replay needs no Git or network: ```sh @@ -59,109 +70,108 @@ python3 -I -B research/p104-helper-subspace-splits/verify.py python3 -I -O -B research/p104-helper-subspace-splits/verify.py ``` -Normal replay is read-only. `--write` explicitly regenerates the two result -artifacts. Inputs are authenticated before imported source code executes. -Each replay uses a fresh bytecode-cache path. The checks reject contaminated -prefix and suffix vectors, missing boundary basis operations, an unearned -whole target, extra helper credit, a missing paid call, a wrong native phase, -a missing central translation, an inadequate cutoff and insufficient BIT stock. +Normal replay is read-only. `--write` explicitly regenerates the word and +receipt. Eighteen live inputs are authenticated before any source import. +The checks reject a wrong boundary event, contaminated prefix or suffix, +missing basis work, unearned target credit, a missing paid call, a wrong +native phase, a missing central translation, an inadequate cutoff and +insufficient BIT stock. The complete nine-role owned inventory and all eleven lifetimes are checked. -## Scope and coordination +## Sources and coordination -The scientific base is canonical main +The scientific inputs start from canonical main `5e0052ca0aa3036a3afa8b0438927377c8d97d53`, priority revision 7. +This follow-up branch starts from refreshed canonical main +`6cf7a683f447b9f1e2333791907fd92be5009a63`. That main revision contains the +earlier PR5599 result at `09dd0965711ca7eeb169057a420abab1c9052137`. +A maintainer merged that earlier result while this composition was in progress. +This follow-up preserves the frozen scientific inputs. The priority, selected +result and all shared executable inputs are unchanged at the refreshed base. The [canonical claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19183208) -records the changed question and local screens. The final publication overlap -cache covered 334 open PRs and 4,863 Discussion records, with complete remote -pagination and incomplete sparse local coverage. Source and coverage details -are coordination evidence, not a novelty proof. - -The consumed PR5565 word is pinned to -`9af814164b9dfc21f19ec737959d67cb71488c95`. It includes Pierre-Loic Doulcet's published -commuting-contact cascade and the released PR5580/PR5569/PR5561 lineage. -The source copy is retained in this branch at commit -`bf64e66656843a64e798b8374cd9f53add3f6f46`. Its SHA256 and Git blob match -the recorded PR5565 source. The PR5580 copy remains an active comparison -input: replay checks the exact paid and helper changes supplied by PR5565. -Registered replay needs this branch history and its main base; it does not -need cached objects from unmerged PR branches. +records the changed question, released components and composition checks. +The last full overlap snapshot covered 340 open PRs and 4,874 Discussion +records, with complete remote pagination and incomplete sparse local coverage. +These counts describe coverage; they are not a novelty proof. + +The main input is PR5601 at +`8f7e870b22885a367b347dc12791da98fd53f83d`. It contains Pierre-Loic Doulcet's +PR5565 cascade and the PR5580/PR5569/PR5561 lineage. The fixed boundary +constructor and witnesses are from PR5602 at +`6c224aa720203c4f4615e6538d8038a275387db8`. Their bytes are retained unchanged. +Only the five published relations with helpers 652, 341, 596, 668 and 684 +are used. The sixth relation uses a contact removed by PR5565 and is omitted. +The relay constructor is from PR5605 at +`4a57d245ac3918ccc9947a867ece24573605e243`. The delayed-relay constructor is +from PR5612 at `faa9f6dbe6b8cc4a996d3edeca71823056453e1a`. Both are retained +unchanged. Their 13 combined source edits are disjoint from PR5601's 21 source +edits against their common PR5580 input. The preparation +identities are from PR5606 at `cd7d89345c6c5d2114625e5ce912a52ecd5e1d27`; +they are checked on the new split word before the retired helper is renamed +into the owned range. PR5608 supplied a useful earlier relay/split composition. +No new boundary, relay, preparation or frame search is introduced. + +PR5613 at `32f23af8790cc3c435bb1f495d861332b4f000e3` combines the delayed relay +with one fixed boundary relation already used here. It gives the same signed +recursive moment with 72 more paid calls and 72 more targets. The tighter +compiler reserve `10^-12` gives **0.00000000546** above that PR's rounded +0.00310440 claim. This last gain uses numerical headroom in the common invoice; +it is not a new physical mechanism. + +The verifier also replays the retained PR5580 and PR5565 words and checks +both source deltas. Each retained input is pinned to an ancestor of this +branch. Registered replay needs no cached unmerged-branch objects. The earlier fifteen-split component on PR5580 remains frozen at -`31a4de233bbdd65c04c63dc3398ecf0eed8e1375`. Two cuts are absent from this -composition. PR5565's lower paid cost more than offsets that lost target -gain. The complete claim increases by 0.00000206 over that component. -This package introduces no new commuting-contact search. -No new Gaussian itinerary is introduced. Active frame-extension work in -[Discussion5575](https://github.com/CrocSwap/integer-mult-bounds/discussions/5575) -is a separate investigation. - -The final refresh also found [parallel coupled-basis and handoff work](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154639). -It uses the same rank-one mechanism and separately changes paid boundary -work. The [public composition handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19183908) -releases the earlier fifteen cuts and leaves the six paid-boundary changes -with the parallel claim. That claim is testing their composition. This -package composes only the released PR5565 source with helper splits. No -exclusive method novelty or gain from the parallel paid changes is claimed. -The new scalar contacts and input count change the hypotheses of -[PR5590](https://github.com/CrocSwap/integer-mult-bounds/pull/5590)’s fixed-contact floor. - -The scope changes the scalar word, the input count and the target contract. -It therefore differs from a scalar-only simplification or a fixed-input -helper stop. The unchanged paid histogram now supports a different, -fully independent target histogram. +`31a4de233bbdd65c04c63dc3398ecf0eed8e1375`. The +[parallel claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154639) +released PR5602 before this final composition check. The shared rank-one +mechanism and every reused boundary relation are credited. No exclusive +method discovery is claimed. The old components' reported gains are not +added: this word, its full native interface and its complete bill are checked. + +## Credit and limits + +- **Ali Romman**, with OpenAI Codex assistance: independent helper splits; + the separate PR5602 boundary relations and PR5601 three-contact change; + PR5580 contact step and PR5544/5545 complete P104 caller and replay. +- **flyingviper**: PR5605 shared relay, PR5612 delayed relay, and the + PR5608/PR5613 compositions. + **Scratch-net**: PR5606 prepared-helper identities and target debit. +- **Pierre-Loic Doulcet / hexapode**: PR5565 commuting-contact cascade. +- **Joel Pulikkan / GamingPuzzled**: PR5569 priced handoff and PR5472 successor + construction. **DreamingOfClouds**: PR5561 free endpoints and PR5568 tools. + **thu-nmrc**: PR5551 contact improvements. +- **Gareth Davidson / bitplane**, **David Arias** and **Cinna Davis**: PR2305 + composition, PR2152 coalesced word, PR2219 private reuse and controller + lineage. **Jacob Alan Sussman**: productive mixed-target recursion. + **zxv** and **Cao Yifan**: retained interval, compiler and native/pricing + lineage. Earlier geometry, BIT and analytic credit remains in source notices. + +The elementary basis identity is not claimed as a new general theorem. +This package supplies an explicit independent-target construction and a +complete conditional price. The same AI-assisted author constructed and +checked it; no subagents or independent human review. Apache-2.0. See [NOTICE](NOTICE). The five selected framework assumptions remain: native implementation at all widths, owned erasure, uniform compiler closure, precision and tape cost, -and analytic recovery. The helper-endpoint contract also remains. -The complete rounded multiplier and enormous uniform compiler word are not -materialized. The same AI-assisted author constructed and checked this -package. Independent human review, proof-kernel acceptance and global -optimality are not claimed. - -## Sources and credit - -- **Pierre-Loic Doulcet / hexapode**: [PR5565](https://github.com/CrocSwap/integer-mult-bounds/pull/5565) - supplies the exact commuting-contact source word. -- **Ali Romman**: [PR5580](https://github.com/CrocSwap/integer-mult-bounds/pull/5580) - supplies its preceding contact step; [PR5544](https://github.com/CrocSwap/integer-mult-bounds/pull/5544) - and [PR5545](https://github.com/CrocSwap/integer-mult-bounds/pull/5545) supply - the complete P104 caller and source replay. -- **Joel Pulikkan / GamingPuzzled**: [PR5569](https://github.com/CrocSwap/integer-mult-bounds/pull/5569) - supplies the priced helper handoff; [PR5472](https://github.com/CrocSwap/integer-mult-bounds/pull/5472) - supplies an earlier successor-handoff construction. -- **DreamingOfClouds**: [PR5561](https://github.com/CrocSwap/integer-mult-bounds/pull/5561) - supplies free helper endpoints and PR5568 supplies search tools. - **thu-nmrc** supplies the PR5551 contact improvements. -- **Gareth Davidson / bitplane**, **David Arias** and **Cinna Davis** supply - the PR2305 composition, PR2152 coalesced word and PR2219 private reuse. - Cinna Davis also supplies the controller lineage. -- **Jacob Alan Sussman** supplies productive mixed-target recursion. - **zxv** and **Cao Yifan** supply the retained interval, compiler and - native/pricing lineage. Source notices preserve earlier geometry, BIT - and analytic credit. - -The elementary rank-one basis identity is not claimed as a new general -linear-algebra theorem. The contribution is this explicit independent-target -construction and its complete conditional price. New work is by Ali Romman -with substantial OpenAI Codex assistance; no subagents. Apache-2.0. -See [NOTICE](NOTICE). +and analytic recovery. The helper-endpoint contract also remains. The full +rounded multiplier and huge uniform word are not materialized. Independent +scientific acceptance and global optimality are not claimed. ## Open next questions -An independent reviewer can check the first split and then replay the complete -package. Further gains could use a different compatible cut order, basis or -frame itinerary. Both prefix and suffix support must be proved before a -new target receives credit. The finite discovery screen does not establish a global -maximum. [TASK.json](TASK.json) gives the first checks and remaining obligations. +An independent reviewer can check the fixed boundary relations and the first +split, then replay the complete package. More general bases, cut orders or +new frame paths remain open. Every additional target needs a clean independent +input/output contract and a complete caller bill. [TASK.json](TASK.json) +records the remaining obligations. -The optional continuation screen is reproducible with: +The finite continuation screen is available with: ```sh python3 -I -B research/p104-helper-subspace-splits/search.py ``` -It tests exact elimination-basis pairs at cuts immediately after MOVE events, -inside equal-boundary helper groups. On the final word it finds no further -candidate in 52 groups. This result covers those tested pairs. It does not -exclude different cut sequences, arbitrary basis combinations or new frames. -The complete-kappa verifier does not depend on a discovery search failure. +It tests exact elimination-basis pairs after MOVE events within equal-boundary +helper groups. Its failure to find another candidate is not an optimum proof. +The complete-kappa verifier does not depend on that search failure. diff --git a/research/p104-helper-subspace-splits/RESULT.json b/research/p104-helper-subspace-splits/RESULT.json index 35f75c8555..1e90afdd03 100644 --- a/research/p104-helper-subspace-splits/RESULT.json +++ b/research/p104-helper-subspace-splits/RESULT.json @@ -1,27 +1,134 @@ { - "authenticated_inputs": 13, + "authenticated_inputs": 18, + "boundaries": [ + { + "cut": 11382, + "events": 25181, + "helper": 652, + "helpers": { + "4": 85, + "5": 4, + "8": 14, + "9": 424 + }, + "paid": { + "1": 2202, + "2": 456, + "3": 494, + "4": 91, + "5": 167, + "6": 18, + "7": 15 + }, + "reverse": true + }, + { + "cut": 11167, + "events": 25178, + "helper": 341, + "helpers": { + "4": 86, + "5": 4, + "8": 14, + "9": 423 + }, + "paid": { + "1": 2202, + "2": 456, + "3": 494, + "4": 91, + "5": 166, + "6": 18, + "7": 15 + }, + "reverse": false + }, + { + "cut": 11400, + "events": 25180, + "helper": 596, + "helpers": { + "4": 87, + "5": 4, + "8": 14, + "9": 422 + }, + "paid": { + "1": 2202, + "2": 456, + "3": 494, + "4": 91, + "5": 165, + "6": 18, + "7": 15 + }, + "reverse": true + }, + { + "cut": 11471, + "events": 25182, + "helper": 668, + "helpers": { + "4": 88, + "5": 4, + "8": 14, + "9": 421 + }, + "paid": { + "1": 2202, + "2": 456, + "3": 494, + "4": 91, + "5": 164, + "6": 18, + "7": 15 + }, + "reverse": true + }, + { + "cut": 11515, + "events": 25184, + "helper": 684, + "helpers": { + "4": 89, + "5": 4, + "8": 14, + "9": 420 + }, + "paid": { + "1": 2202, + "2": 456, + "3": 494, + "4": 91, + "5": 163, + "6": 18, + "7": 15 + }, + "reverse": true + } + ], "complete_cost": { "compiler": { - "H": 707182000000000, - "N": "2^707182000000000", + "H": 80511200000000000, + "N": "2^80511200000000000", "eta": { - "lower": "0.000000136964415492079857925247", - "upper": "0.000000136964415492079857925248" + "lower": "0.000000134230972128213080564458", + "upper": "0.000000134230972128213080564459" }, - "gap": "1/14000000000", - "integer_test_exponent": 50513, + "gap": "1/1400000000000", + "integer_test_exponent": 57508, "logarithm_power": 1024, "theta": "63/64", - "uniform_saving": "21703153/7000000000", + "uniform_saving": "86923353/28000000000", "word_materialized": false }, "full_forward_calls": 18, - "gain": "61/4000000", - "kappa": "62009/20000000", - "kappa_decimal": ".00310045", + "gain": "922773/50000000000", + "kappa": "155220273/50000000000", + "kappa_decimal": ".00310440546", "margin_at_previous": { - "lower": "3.715057037515374246068780385152", - "upper": "3.715057037515374246068780385153" + "lower": "4.488346782018422611631558671661", + "upper": "4.488346782018422611631558671662" }, "negative_controls": { "old_BIT": "Rejected by outer inequalities", @@ -29,10 +136,10 @@ }, "nonrecursive": { "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", - "local_paid_rank_mass": 6014, - "local_routes": 5183000, - "local_scalar": 220232, - "peak_owned_fields": 1, + "local_paid_rank_mass": 5986, + "local_routes": 5175000, + "local_scalar": 220154, + "peak_owned_fields": 2, "raw_budget": 1000000000, "raw_scalar_upper": 184647552, "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word." @@ -47,175 +154,175 @@ }, "outer": { "functional_checks": { - "actual_new_BIT_stock_sublinear": "3485999999253/3500000000000", - "fixed_halo_explicit_metadata_branch": "269500000001/3500000000", - "new_BIT_row_stock_sublinear_in_active_group": "13957999997009/14000000000000", - "new_semantic_group_guard": "3/14000000000" + "actual_new_BIT_stock_sublinear": "348599999999253/350000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000", + "new_semantic_group_guard": "3/1400000000000" }, "margins": { - "boundary_algebraic_matrix": "607688255956593697/196000000000000000000", - "fused_gaussian": "607688255869781091/196000000000000000000", - "global_coordinate_router": "1356447/437500000", - "group_bit_router": "18990258433430659/6125000000000000000", - "group_scans": "6999999999/7000000000", - "main_transform": "607688241956593697/196000000000000000000", - "microbox_face_corrections": "269500000001/3500000000", - "polynomial_products": "13999999999/14000000000", - "sparse_union_movement": "80232688255956593697/196000000000000000000" + "boundary_algebraic_matrix": "6084634707195653832353/1960000000000000000000000", + "fused_gaussian": "6084634707186961497059/1960000000000000000000000", + "global_coordinate_router": "135817739/43750000000", + "group_bit_router": "190144834643342546783/61250000000000000000000", + "group_scans": "699999999999/700000000000", + "main_transform": "6084634705795653832353/1960000000000000000000000", + "microbox_face_corrections": "26950000000001/350000000000", + "polynomial_products": "1399999999999/1400000000000", + "sparse_union_movement": "802334634707195653832353/1960000000000000000000000" }, "parameters": { - "a": "1356447/437500000", - "b": "8681261/2800000000", - "beta": "13999999997/14000000000", + "a": "135817739/43750000000", + "b": "4346167649/1400000000000", + "beta": "1399999999997/1400000000000", "bit_saving": "17/5000", - "cap_xi": "178232688241956593697/196000000000000000000", - "complex_uniform_saving": "21703153/7000000000", - "d": "1/14000000000", - "epsilon": "13999999999/14000000000", - "kappa": "62009/20000000", - "lambda_": "3987598199/4000000000", - "lambda_prime": "13956593697/14000000000", - "layout": "1/14000000000", - "q": "43406303/14000000000", - "r0": "1/140000000000", - "stop": "1/14000000000", - "tested_saving": "6200901/2000000000" + "cap_xi": "1782334634705795653832353/1960000000000000000000000", + "complex_uniform_saving": "86923353/28000000000", + "d": "1/1400000000000", + "epsilon": "1399999999999/1400000000000", + "kappa": "155220273/50000000000", + "lambda_": "79751647563/80000000000", + "lambda_prime": "1395653832353/1400000000000", + "layout": "1/1400000000000", + "q": "4346167647/1400000000000", + "r0": "1/14000000000000", + "stop": "1/1400000000000", + "tested_saving": "620881093/200000000000" }, "strict_checks": { - "actual_bit_above_effective": "131053/437500000", - "actual_logarithmic_gamma_guard": "1/14000000000", - "actual_logarithmic_group_guard": "17767311779043406303/98000000000000000000", - "alpha_logarithm_absorption": "1/140000000000", - "boundary_algebraic_matrix_above_kappa": "55956593697/196000000000000000000", - "cap_above_band": "80232688241956593697/196000000000000000000", - "cap_below_cell": "17767311744043406303/196000000000000000000", - "cap_below_phase_cell_power": "213767311758043406303/196000000000000000000", - "complex_above_effective": "1/14000000000", - "complex_below_one_over_32": "78818739/2800000000", - "complex_endpoint": "1/7000000000", - "epsilon_below_one": "1/14000000000", - "epsilon_positive": "13999999999/14000000000", + "actual_bit_above_effective": "12932261/43750000000", + "actual_logarithmic_gamma_guard": "1/1400000000000", + "actual_logarithmic_group_guard": "177665365296304346167647/980000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000", + "boundary_algebraic_matrix_above_kappa": "5595653832353/1960000000000000000000000", + "cap_above_band": "802334634705795653832353/1960000000000000000000000", + "cap_below_cell": "177665365292804346167647/1960000000000000000000000", + "cap_below_phase_cell_power": "2137665365294204346167647/1960000000000000000000000", + "complex_above_effective": "1/1400000000000", + "complex_below_one_over_32": "39403832351/1400000000000", + "complex_endpoint": "1/700000000000", + "epsilon_below_one": "1/1400000000000", + "epsilon_positive": "1399999999999/1400000000000", "fine_prime_halo_umbrella": "7/2", - "fused_gaussian_above_kappa": "55869781091/196000000000000000000", - "gaussian_above_main": "6956593697/98000000000000000000", - "global_coordinate_router_above_kappa": "1/3500000000", - "global_gamma_power_slack": "9/140000000000", - "group_below_dimension": "1/7000000000", - "group_bit_router_above_kappa": "2183430659/6125000000000000000", - "group_gauge_power_slack": "17767311778343406303/98000000000000000000", - "group_key_fits_record": "1/7000000000", - "group_positive": "13999999997/14000000000", - "group_scans_above_kappa": "6978296849/7000000000", + "fused_gaussian_above_kappa": "5586961497059/1960000000000000000000000", + "gaussian_above_main": "695653832353/980000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000", + "global_gamma_power_slack": "9/14000000000000", + "group_below_dimension": "1/700000000000", + "group_bit_router_above_kappa": "218342546783/61250000000000000000000", + "group_gauge_power_slack": "177665365296234346167647/980000000000000000000000", + "group_key_fits_record": "1/700000000000", + "group_positive": "1399999999997/1400000000000", + "group_scans_above_kappa": "697826916177/700000000000", "halo_covers_generic_inverse_radius": "5", - "improvement_over_user_baseline": "684739790400418148631/500000000000000000000000", - "lambda_above_internal": "1/28000000000", - "lambda_above_sigma": "3/28000000000", - "lambda_above_tau": "1/28000000000", - "lambda_prime_above_lambda": "1/28000000000", - "lambda_prime_above_leaf": "5591318739/39200000000000000000", - "leaf_saving_above_effective": "2791318739/39200000000000000000", - "main_transform_above_kappa": "41956593697/196000000000000000000", - "membership_arithmetic_fits_record": "1/14000000000", - "microbox_face_corrections_above_kappa": "134744574213/1750000000", - "microbox_halo_volume": "1106000000003/14000000000", - "new_complex_uniform_saving_above_b": "1/14000000000", - "new_semantic_guard_with_C1_one": "1/14000000000", - "polynomial_products_above_kappa": "13956593699/14000000000", - "positive_layout_slack": "1/14000000000", - "q_below_effective": "1/14000000000", - "q_below_internal": "1/14000000000", - "q_below_leaf": "5591318739/39200000000000000000", - "q_positive": "43406303/14000000000", - "short_record_fallback": "2791318739/2800000000", - "source_axis_superpolynomial": "1/14000000000", - "sparse_union_movement_above_kappa": "79625000055956593697/196000000000000000000", - "stop_below_one": "13999999999/14000000000", - "stop_positive": "1/14000000000", + "improvement_over_user_baseline": "686717520400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000000", + "lambda_above_sigma": "3/2800000000000", + "lambda_above_tau": "1/2800000000000", + "lambda_prime_above_lambda": "1/2800000000000", + "lambda_prime_above_leaf": "2795653832351/1960000000000000000000000", + "leaf_saving_above_effective": "1395653832351/1960000000000000000000000", + "main_transform_above_kappa": "4195653832353/1960000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000", + "microbox_face_corrections_above_kappa": "2694891345809/35000000000", + "microbox_halo_volume": "110600000000003/1400000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000", + "polynomial_products_above_kappa": "279130766471/280000000000", + "positive_layout_slack": "1/1400000000000", + "q_below_effective": "1/1400000000000", + "q_below_internal": "1/1400000000000", + "q_below_leaf": "2795653832351/1960000000000000000000000", + "q_positive": "4346167647/1400000000000", + "short_record_fallback": "1395653832351/1400000000000", + "source_axis_superpolynomial": "1/1400000000000", + "sparse_union_movement_above_kappa": "796250000005595653832353/1960000000000000000000000", + "stop_below_one": "1399999999999/1400000000000", + "stop_positive": "1/1400000000000", "strassen_integer_power_gap": "1951441519231", - "support_router_span": "3/14000000000", + "support_router_span": "3/1400000000000", "theta_positive_polynomial_power": "2", - "union_header_fits_record": "3/14000000000", - "union_tag_work_per_visit_fits_record": "3/14000000000" + "union_header_fits_record": "3/1400000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000" } }, "paid": { - "1": 41214, + "1": 41160, "16": 416, - "2": 8262, + "2": 8208, "24": 416, - "3": 8874, + "3": 8892, "32": 416, - "4": 1656, + "4": 1638, "40": 416, "48": 416, - "5": 3024, + "5": 2934, "56": 416, "6": 324, "64": 416, - "7": 252, + "7": 270, "72": 208 }, - "paid_calls": 66726, - "previous_open_pr5565": "7713/2500000", - "productive_fields": 13048, + "paid_calls": 66546, + "previous_open_pr5601": "61719/20000000", + "productive_fields": 12958, "query_shears": 15, "rank_mass_surplus": 760, "raw_ceiling": { - "derivative_upper": "-741665511346505619707405027113237790341393747177503845065075007/3138550867693340381917894711603833208051177722232017256448", + "derivative_upper": "-740697379185468431509527785786174826824653618646482726012475981/3138550867693340381917894711603833208051177722232017256448", "interval": [ "0", "17/5000" ] }, "raw_headroom": [ - "157681/25000000000000", - "25229/4000000000000" + "1057/100000000000000", + "529/50000000000000" ], "raw_root_interval": [ - "77511407681/25000000000000", - "12401825229/4000000000000" + "310440547057/100000000000000", + "155220273529/50000000000000" ], - "relative_gain_percent": "7625/15426", + "relative_gain_percent": "307591/514325", "strictification": { "alpha": { - "lower": "0.999999994094860604597376680636", - "upper": "0.999999994094860604597376680637" + "lower": "0.999999999994326766581078689953", + "upper": "0.999999999994326766581078689954" }, "cutoff": 17, "delta": { - "lower": "0.972208404163139976829701213167", - "upper": "0.972208404163139976829701213168" + "lower": "0.967529831449501193014279307231", + "upper": "0.967529831449501193014279307232" }, "floor": 18, "gamma": { - "lower": "0.967537821927968182942254182934", - "upper": "0.967537821927968182942254182935" + "lower": "0.968053457228490967558213760766", + "upper": "0.968053457228490967558213760767" }, - "normalized_paid_upper": "5242880004882813/5242880536870912", + "normalized_paid_upper": "1048576000976562501/1048576001073741824", "power": 1024, - "reserve": "1/10000000000", + "reserve": "1/1000000000000", "tail_block": 128, "tail_decay": "39/40", "tail_offset": "1/5", - "tested": "6200901/2000000000" + "tested": "620881093/200000000000" }, "targets": { "1": 36, "145": 208, "17": 416, - "2": 90, + "2": 72, "25": 416, "33": 416, - "4": 1602, + "4": 1638, "41": 416, "49": 416, - "5": 198, + "5": 108, "57": 416, "65": 416, "7": 90, "73": 208, "8": 288, - "9": 7416 + "9": 7398 }, "whole_idle_jobs": 3120 }, @@ -225,66 +332,70 @@ "No independent human or proof-kernel acceptance or global optimality is claimed." ], "local": { - "endpoint_coefficients": 571536, + "endpoint_coefficients": 565504, "helpers": { "1": 2, - "2": 5, - "4": 89, - "5": 11, + "2": 4, + "4": 91, + "5": 6, "7": 5, "8": 16, - "9": 412 + "9": 411 }, - "owned_lifetimes": 8, + "owned_fields": 9, + "owned_lifetimes": 11, "paid": { - "1": 2203, - "2": 459, - "3": 493, - "4": 92, - "5": 168, + "1": 2200, + "2": 456, + "3": 494, + "4": 91, + "5": 163, "6": 18, - "7": 14 + "7": 15 }, - "paid_rank_mass": 6014, - "peak_owned_fields": 1, - "public_inputs": 748, - "real_scalar_allowance": 220232 + "paid_rank_mass": 5986, + "peak_owned_fields": 2, + "public_inputs": 743, + "real_scalar_allowance": 220154 }, "local_helper_delta": { "1": 2, "2": 5, - "4": 6, - "5": 6, + "4": 2, + "5": 2, "7": 5, "8": 2, - "9": -13 + "9": -9 }, "native": { - "distinct_maps": 2923, - "helper_normalizers": 1080, + "distinct_maps": 2916, + "helper_normalizers": 1070, "helpers": { "1": 2, - "2": 5, - "4": 89, - "5": 11, + "2": 4, + "4": 91, + "5": 6, "7": 5, "8": 16, - "9": 412 + "9": 411 }, "main_adapters": 208, "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", - "recipe_payload_sha256": "b2e6b538f6152ccf0024ca57381e46b2fe6b75b89504d935009dade234cc3f18", + "recipe_payload_sha256": "39dc742c360be94a585dd25e3fc37d5a3ef2f505e2bd6c152ad184fbad820133", "wrong_phase_rejected": true }, "negative_controls": { "contaminated_prefix": "Exact prefix functional; no other input", "contaminated_suffix": "Exact suffix direction; no other output", "extra_helper_credit": "Every productive helper has a native target", + "false_preparation_identity": "Exact current-value preparation identity", "missing_central_translation": "Rejected by the complete Laurent endpoint", "missing_input_basis": "All public and owned rows", "missing_output_basis": "All public and owned rows", "unearned_whole_target": "All public and owned exits", - "unpaid_gaussian": "Complete field and call counts" + "unpaid_gaussian": "Complete field and call counts", + "unremoved_prepared_target": "Every productive helper has a native target", + "wrong_boundary_event": "Exact boundary event anchor" }, "physical_caller": { "central_square_columns": 53248, @@ -334,154 +445,153 @@ 31 ] }, + "preparation": { + "debited_target_rank": 2, + "new_owned_role": 751, + "old_helper": 573, + "sites": [ + { + "event": 13651, + "rank": 1 + }, + { + "event": 13676, + "rank": 1 + } + ] + }, "published_source_delta": { - "helpers": { - "8": -1, - "9": 1 + "PR5565": { + "helpers": { + "8": -1, + "9": 1 + }, + "paid": { + "1": -8, + "3": -1, + "4": -2, + "5": 4 + } }, - "paid": { - "1": -8, - "3": -1, - "4": -2, - "5": 4 + "PR5601": { + "helpers": { + "4": 1, + "5": -1 + }, + "paid": { + "2": -2, + "3": 2, + "4": -2, + "5": 1 + } } }, + "relay": { + "delayed_paid_delta": { + "4": 1, + "5": -1, + "6": -1, + "7": 1 + }, + "frame_edits": 21, + "relay_edits": 13 + }, "separate_columns": { "arithmetic": "Dense integer rows with binary denominators; reverse chronology", - "coefficients": 571536, - "columns": 756 + "coefficients": 565504, + "columns": 752 }, "splits": [ { - "cut_after": 13775, - "events": 25155, - "pivot": 648, - "public": 736, - "ranks": [ - 5, - 4 - ] - }, - { - "cut_after": 13765, - "events": 25177, - "pivot": 592, - "public": 737, - "ranks": [ - 5, - 4 - ] - }, - { - "cut_after": 13706, - "events": 25195, - "pivot": 664, - "public": 738, - "ranks": [ - 5, - 4 - ] - }, - { - "cut_after": 13673, - "events": 25217, - "pivot": 680, - "public": 739, - "ranks": [ - 5, - 4 - ] - }, - { - "cut_after": 12526, - "events": 25253, + "cut_after": 12520, + "events": 25220, "pivot": 259, - "public": 740, + "public": 736, "ranks": [ 4, 5 ] }, { - "cut_after": 12448, - "events": 25285, + "cut_after": 12442, + "events": 25252, "pivot": 432, - "public": 741, + "public": 737, "ranks": [ 4, 5 ] }, { - "cut_after": 13961, - "events": 25299, + "cut_after": 13913, + "events": 25266, "pivot": 722, - "public": 742, + "public": 738, "ranks": [ 2, 7 ] }, { - "cut_after": 13647, - "events": 25317, + "cut_after": 13629, + "events": 25284, "pivot": 14, - "public": 743, + "public": 739, "ranks": [ 2, 7 ] }, { - "cut_after": 13648, - "events": 25335, + "cut_after": 13630, + "events": 25302, "pivot": 76, - "public": 744, + "public": 740, "ranks": [ 2, 7 ] }, { - "cut_after": 13648, - "events": 25369, + "cut_after": 13630, + "events": 25334, "pivot": 345, - "public": 745, + "public": 741, "ranks": [ 2, 7 ] }, { - "cut_after": 13637, - "events": 25419, + "cut_after": 13618, + "events": 25384, "pivot": 573, - "public": 746, + "public": 742, "ranks": [ 2, 7 ] }, { - "cut_after": 12078, - "events": 25445, + "cut_after": 12071, + "events": 25410, "pivot": 405, - "public": 747, + "public": 743, "ranks": [ 8, 1 ] }, { - "cut_after": 12610, - "events": 25475, + "cut_after": 12603, + "events": 25440, "pivot": 225, - "public": 748, + "public": 744, "ranks": [ 8, 1 ] } ], - "status": "PASS_P104_HELPER_SUBSPACE_KAPPA_00310045" + "status": "PASS_P104_HELPER_SUBSPACE_KAPPA_00310440546" } diff --git a/research/p104-helper-subspace-splits/SOURCES.json b/research/p104-helper-subspace-splits/SOURCES.json index f83bf3c818..bb8cb5eca3 100644 --- a/research/p104-helper-subspace-splits/SOURCES.json +++ b/research/p104-helper-subspace-splits/SOURCES.json @@ -99,6 +99,48 @@ "git_blob": "4ebe6fcb7adf319bf6b247cf23d89eb1ca4cd914", "sha256": "3d62828f53e654e3db218bf4611a47aed4a677d48043713dc004db0f8a32990d", "pin": "head:bf64e66656843a64e798b8374cd9f53add3f6f46:research/p104-helper-subspace-splits/inputs/PR5565-WORD.json.gz" + }, + { + "path": "research/p104-helper-subspace-splits/inputs/PR5601-WORD.json.gz", + "usage": "input", + "git_blob": "3c9a5ce8969f40f03724a73d34f984dd17efde96", + "sha256": "ac81682679d1eb628a2a0a330b55a7a79722531ca163cd565a3eba5d87589979", + "pin": "head:55914a0de83df255bd7e7071d79ad04b81ca1070:research/p104-helper-subspace-splits/inputs/PR5601-WORD.json.gz" + }, + { + "path": "research/p104-helper-subspace-splits/inputs/PR5602-construct.py", + "usage": "input", + "git_blob": "ef5936ca89d6502d7f6af1ce6903d8500c117401", + "sha256": "2360066b0a1390c60a86d9788ada1504478e7e48bbfe3fcdf27a5563379fc001", + "pin": "head:0bccb2ff858db877119217f7d98409ee6a24ccce:research/p104-helper-subspace-splits/inputs/PR5602-construct.py" + }, + { + "path": "research/p104-helper-subspace-splits/inputs/PR5602-WITNESS.json", + "usage": "input", + "git_blob": "8073b3c9772a4a7c94e07d613c2f5c45b1c650fc", + "sha256": "e4dfc526453eb9d232772ffdb587fff1923e247341405aee031318b0fb9cb638", + "pin": "head:0bccb2ff858db877119217f7d98409ee6a24ccce:research/p104-helper-subspace-splits/inputs/PR5602-WITNESS.json" + }, + { + "path": "research/p104-helper-subspace-splits/inputs/PR5605-construct.py", + "usage": "input", + "git_blob": "31f9b76c9b3d9c410aec1d0945d967ed985154c3", + "sha256": "5831eb6f88cd6ed8200f32d2794dd9535ea06aa0d3ae6dd111a58bc01b611cbd", + "pin": "head:4ae31ae93e86d6ab7ddd75e42fee86cf21cdb8c8:research/p104-helper-subspace-splits/inputs/PR5605-construct.py" + }, + { + "path": "research/p104-helper-subspace-splits/inputs/PR5606-construct.py", + "usage": "provenance", + "git_blob": "e2c1473be00e78b91b4139493e31e47b591ac0df", + "sha256": "037d5f00f1c92b6f59020f90f11345251b429ba2bb2c39a65966b5e73094756a", + "pin": "head:4ae31ae93e86d6ab7ddd75e42fee86cf21cdb8c8:research/p104-helper-subspace-splits/inputs/PR5606-construct.py" + }, + { + "path": "research/p104-helper-subspace-splits/inputs/PR5612-delayed.py", + "usage": "input", + "git_blob": "afd1bd8e084a31071d3ae6002e7183f6e3c8e891", + "sha256": "fcb8b97785ae05db6f60c38d8d75ee4fe856ea41a1327b772eff7a6ee388b3c8", + "pin": "head:a692fd471ee7c47fa30ae755b80e51ef7e022689:research/p104-helper-subspace-splits/inputs/PR5612-delayed.py" } ], "external_inputs": [ @@ -117,6 +159,46 @@ "source_path": "research/p104-commuting-contact/WORD.json.gz", "sha256": "3d62828f53e654e3db218bf4611a47aed4a677d48043713dc004db0f8a32990d", "git_blob": "4ebe6fcb7adf319bf6b247cf23d89eb1ca4cd914" + }, + { + "local_path": "inputs/PR5601-WORD.json.gz", + "source_repository": "aliromman/integer-mult-bounds", + "source_commit": "8f7e870b22885a367b347dc12791da98fd53f83d", + "source_path": "research/p104-coupled-frame-step/WORD.json.gz", + "sha256": "ac81682679d1eb628a2a0a330b55a7a79722531ca163cd565a3eba5d87589979", + "git_blob": "3c9a5ce8969f40f03724a73d34f984dd17efde96" + }, + { + "local_path": "inputs/PR5602-construct.py", + "source_repository": "aliromman/integer-mult-bounds", + "source_commit": "6c224aa720203c4f4615e6538d8038a275387db8", + "source_path": "research/p104-coupled-helper-bases/construct.py", + "sha256": "2360066b0a1390c60a86d9788ada1504478e7e48bbfe3fcdf27a5563379fc001", + "git_blob": "ef5936ca89d6502d7f6af1ce6903d8500c117401" + }, + { + "local_path": "inputs/PR5602-WITNESS.json", + "source_repository": "aliromman/integer-mult-bounds", + "source_commit": "6c224aa720203c4f4615e6538d8038a275387db8", + "source_path": "research/p104-coupled-helper-bases/WITNESS.json", + "sha256": "e4dfc526453eb9d232772ffdb587fff1923e247341405aee031318b0fb9cb638", + "git_blob": "8073b3c9772a4a7c94e07d613c2f5c45b1c650fc" + }, + { + "local_path": "inputs/PR5605-construct.py", + "source_repository": "flyingviper/integer-mult-bounds", + "source_commit": "4a57d245ac3918ccc9947a867ece24573605e243", + "source_path": "research/p104-shared-residual-relay/construct.py", + "sha256": "5831eb6f88cd6ed8200f32d2794dd9535ea06aa0d3ae6dd111a58bc01b611cbd", + "git_blob": "31f9b76c9b3d9c410aec1d0945d967ed985154c3" + }, + { + "local_path": "inputs/PR5612-delayed.py", + "source_repository": "flyingviper/integer-mult-bounds", + "source_commit": "faa9f6dbe6b8cc4a996d3edeca71823056453e1a", + "source_path": "research/p104-delayed-shared-relay/delayed.py", + "sha256": "fcb8b97785ae05db6f60c38d8d75ee4fe856ea41a1327b772eff7a6ee388b3c8", + "git_blob": "afd1bd8e084a31071d3ae6002e7183f6e3c8e891" } ], "code_derivation": [ @@ -127,6 +209,15 @@ "sha256": "a4df92b46234bb56a966df30d9c1d43251e1346e9a1ad06cf5ee30a79c7ae591", "git_blob": "bb135338f1c57c48147cb214d14f542cdfe4e533", "scope": "Pricing code attribution; this predecessor file is not executed." + }, + { + "local_path": "inputs/PR5606-construct.py", + "source_repository": "Scratch-net/integer-mult-bounds", + "source_commit": "cd7d89345c6c5d2114625e5ce912a52ecd5e1d27", + "source_path": "research/p104-prepared-split-reuse/construct.py", + "sha256": "037d5f00f1c92b6f59020f90f11345251b429ba2bb2c39a65966b5e73094756a", + "git_blob": "e2c1473be00e78b91b4139493e31e47b591ac0df", + "scope": "The fixed preparation identities are adapted to the final split word and explicit nine-role owned inventory; this predecessor constructor is not executed." } ] } diff --git a/research/p104-helper-subspace-splits/SPLITS.json b/research/p104-helper-subspace-splits/SPLITS.json index 5108daabf7..9a9aa0c460 100644 --- a/research/p104-helper-subspace-splits/SPLITS.json +++ b/research/p104-helper-subspace-splits/SPLITS.json @@ -1,118 +1,6 @@ [ { - "cut_after": 13775, - "frame": 120, - "pivot": 648, - "a": { - "652": "1" - }, - "b": { - "652": "1", - "648": "-1", - "650": "1", - "649": "-1" - }, - "c": { - "652": "1" - }, - "d": { - "652": "1", - "205": "-2", - "648": "-1", - "650": "1", - "649": "-1" - }, - "ranks": [ - 5, - 4 - ] - }, - { - "cut_after": 13765, - "frame": 1053, - "pivot": 592, - "a": { - "596": "1" - }, - "b": { - "596": "1", - "594": "1", - "592": "-1", - "593": "1" - }, - "c": { - "596": "1" - }, - "d": { - "596": "1", - "594": "1", - "188": "-1", - "592": "-1", - "593": "1" - }, - "ranks": [ - 5, - 4 - ] - }, - { - "cut_after": 13706, - "frame": 1051, - "pivot": 664, - "a": { - "668": "1" - }, - "b": { - "668": "1", - "665": "1", - "666": "-1", - "664": "1" - }, - "c": { - "668": "1" - }, - "d": { - "668": "1", - "115": "2", - "665": "1", - "666": "-1", - "664": "1" - }, - "ranks": [ - 5, - 4 - ] - }, - { - "cut_after": 13673, - "frame": 1049, - "pivot": 680, - "a": { - "684": "1" - }, - "b": { - "684": "1", - "681": "1", - "680": "-1", - "682": "1" - }, - "c": { - "684": "1" - }, - "d": { - "684": "1", - "681": "1", - "126": "2", - "680": "-1", - "682": "1" - }, - "ranks": [ - 5, - 4 - ] - }, - { - "cut_after": 12526, + "cut_after": 12520, "frame": 306, "pivot": 259, "a": { @@ -144,7 +32,7 @@ ] }, { - "cut_after": 12448, + "cut_after": 12442, "frame": 516, "pivot": 432, "a": { @@ -178,7 +66,7 @@ ] }, { - "cut_after": 13961, + "cut_after": 13913, "frame": 424, "pivot": 722, "a": { @@ -205,7 +93,7 @@ ] }, { - "cut_after": 13647, + "cut_after": 13629, "frame": 462, "pivot": 14, "a": { @@ -233,7 +121,7 @@ ] }, { - "cut_after": 13648, + "cut_after": 13630, "frame": 252, "pivot": 76, "a": { @@ -261,7 +149,7 @@ ] }, { - "cut_after": 13648, + "cut_after": 13630, "frame": 391, "pivot": 345, "a": { @@ -284,7 +172,6 @@ "350": "-1/2", "343": "1/2", "93": "-1", - "341": "-1", "347": "1/2", "349": "1/2", "348": "1/2", @@ -296,7 +183,7 @@ ] }, { - "cut_after": 13637, + "cut_after": 13618, "frame": 603, "pivot": 573, "a": { @@ -314,7 +201,6 @@ }, "d": { "710": "1/2", - "115": "1", "572": "1", "498": "2", "306": "-1", @@ -327,6 +213,7 @@ "456": "2", "252": "-1", "247": "-1", + "115": "1", "311": "-2", "205": "-1", "126": "-1", @@ -340,7 +227,7 @@ ] }, { - "cut_after": 12078, + "cut_after": 12071, "frame": 477, "pivot": 405, "a": { @@ -372,7 +259,7 @@ ] }, { - "cut_after": 12610, + "cut_after": 12603, "frame": 267, "pivot": 225, "a": { diff --git a/research/p104-helper-subspace-splits/TASK.json b/research/p104-helper-subspace-splits/TASK.json index a230fe5b90..7fe6bb964a 100644 --- a/research/p104-helper-subspace-splits/TASK.json +++ b/research/p104-helper-subspace-splits/TASK.json @@ -46,33 +46,27 @@ ] }, "scope_status": "changed", - "actual_scope": "Change the independent P104 helper basis and split 13 targets into two independent targets at common-frame cuts. Verify a complete conditional kappa gain on the published PR5565 word.", + "actual_scope": "Compose the released PR5601 frame word, PR5605 shared relay and PR5612 delayed relay, five fixed PR5602 boundary relations, nine independent helper splits and PR5606 preparation identities. Verify the complete conditional kappa gain with the removed H2 target and nine owned roles charged.", "scope_change_reason": "The donor explicitly requested a different mechanism and a kappa gain. This changes the scalar word, independent input count and helper target contract. It is outside fixed-endpoint retiming and the historical frozen provider catalogue. The card classifies this assigned work; no task was rerolled.", - "bottleneck_link": "At unchanged recursive paid cost relative to PR5565, 13 independent target splits strictly increase the concave target moment. Every new input has an explicit returned Gaussian target.", + "bottleneck_link": "The disjoint shared/delayed relay merge and fixed boundary changes reduce paid cost. Independent target splits increase the target moment. Two exact preparations remove queries while debiting their rank-two target. The full caller charges every changed helper, owned lifetime, route and compiler cost.", "budget_minutes": null, "stop_rule": "Require full arbitrary-input and native identities and a complete improved kappa. Stop the finite discovery scan after no further tested split remains; do not claim global optimality.", "outcome": "completed", - "evidence": "SPLITS.json, PROOF.md and RESULT.json bind each cut, the complete word, native maps and full price. VALIDATION.md records executed checks.", + "evidence": "BOUNDARIES.json, SPLITS.json, PREPARATION.json, PROOF.md and RESULT.json bind every composition step, complete interface, native map and full price. VALIDATION.md records executed checks.", "author": "Ali Romman with OpenAI Codex assistance", "ai_assistance": "Substantial OpenAI Codex assistance. The same assistant constructed and checked the result. No subagents or independent human review.", "open_questions": [ { "question": "Can an independent reviewer accept the new helper basis, every returned independent target and the complete conditional price?", "why_it_matters": "Author-side exact checks do not replace independent scientific review.", - "first_step": "Check the first rank-one split in PROOF.md, then replay all cuts, native maps and the complete price.", + "first_step": "Check the disjoint source edits, five fixed boundary relations, first rank-one split and both preparation identities, including the H2 target debit and peak owned occupancy two; then replay the full certificate.", "blocked_by": "No missing technical input; independent review is pending." }, { "question": "Can a different compatible cut order or changed common frame support more independent target splits?", - "why_it_matters": "The finite exact screen does not prove a global maximum.", - "first_step": "Use the new word and test both prefix and suffix support before assigning credit. Coordinate with Discussion5575 for any changed frame itinerary.", - "blocked_by": "Every added target must have a clean independent input/output contract and a complete caller bill." - }, - { - "question": "Can the fifteen released target splits compose with the six paid-boundary changes in the parallel Discussion claim?", - "why_it_matters": "The target gain and paid gain could be compatible, but the input bases and cuts must be checked together.", - "first_step": "Use the public handoff at discussioncomment-19183908. The parallel claim has released its word at 8384fb9eda5a2fd47556364b26185f3ba3cbd050 and is testing the earlier fifteen-split component. Coordinate there before testing any further composition.", - "blocked_by": "The parallel claim owns the paid-boundary synthesis. This package does not assert a combined certificate with that work." + "why_it_matters": "The final 46-group finite basis-pair screen does not prove a global maximum.", + "first_step": "Use the final word and test both prefix and suffix support before assigning target credit. Check live Discussion scopes before changing bases or frame paths.", + "blocked_by": "Every added target or removed query needs a clean complete interface and full caller bill. New preparation or relay search must first be coordinated with the source contributors." } ] } diff --git a/research/p104-helper-subspace-splits/VALIDATION.md b/research/p104-helper-subspace-splits/VALIDATION.md index 7f73fd1454..6c1c54c21b 100644 --- a/research/p104-helper-subspace-splits/VALIDATION.md +++ b/research/p104-helper-subspace-splits/VALIDATION.md @@ -1,51 +1,103 @@ # Validation record Environment: macOS, CPython 3.12.14, standard library only. Scientific -replays run serially in the isolated `codex/kappa-structural-20261025` worktree. -The scientific base is canonical main -`5e0052ca0aa3036a3afa8b0438927377c8d97d53`. +replays run serially in the isolated contribution worktree. -## Current composition +The frozen scientific input base is canonical main +`5e0052ca0aa3036a3afa8b0438927377c8d97d53`, priority revision 7. +The follow-up branch starts from refreshed canonical main +`6cf7a683f447b9f1e2333791907fd92be5009a63`. That main contains PR5599 at +`09dd0965711ca7eeb169057a420abab1c9052137`, merged by a maintainer during +this work. The selected frontier and shared executable inputs are unchanged. -The direct isolated normal replay passed with explicit artifact generation: +## Current complete replay + +The direct isolated normal replay passed with artifact generation: ```sh python3 -I -B research/p104-helper-subspace-splits/verify.py --write ``` -It checked 13 prefix and suffix witnesses, each complete arbitrary-input -interface, 571,536 final transpose coefficients, 2,923 exact native maps, -1,080 helper normalizers, 208 main adapters and the complete physical caller. -Two exact moment engines, all compiler conditions, 54 strict outer conditions -and four functional conditions passed. All eight local/controller mutation -controls rejected. The retained wrong-phase, old-cutoff and old-BIT controls -also rejected. The raw crossing is in -(0.00310045630724, 0.00310045630725). - -The verifier authenticates 13 live inputs before importing any source code. -It replays both retained source words and checks the exact paid and helper -deltas supplied by PR5565. All new splits preserve the PR5565 paid profile. -The new local paid rank mass is 6014 and enters the native growth bound. -The exact discovery run tested 52 final boundary groups and found no further -candidate in its finite basis-pair class. This is not a global optimum. - -Registered normal/optimized replay is in progress. The committed-byte check -and fresh read-only Git-free export will follow. These checks are not yet -claimed for this composition in this revision. - -## Retained evidence - -The earlier fifteen-split component on PR5580 passed normal, optimized, -registered and read-only Git-free replay at scientific commit -`31a4de233bbdd65c04c63dc3398ecf0eed8e1375`. That evidence applies to its -0.00309839 claim. It is not substituted for the new composition checks. - -The source copies are pinned to their retained paths at ancestor commits -`29fe88ba218b5d2192d8e31f07a01d1141afdacd` (PR5580) and -`bf64e66656843a64e798b8374cd9f53add3f6f46` (PR5565). Each SHA256 and Git blob -equals the recorded published source. Registered replay needs no cached -unmerged-branch objects. Full-history preflight was not run because this -checkout is shallow. +The marker is `PASS_P104_HELPER_SUBSPACE_KAPPA_00310440546`. +The claimed saving is 0.00310440546, tested at 0.003104405465. The exact raw +crossing is (0.00310440547057, 0.00310440547058). The reserve is 10^-12. +Power and logarithm power remain 1024. The compiler threshold is +`N = 2^80511200000000000`. + +The verifier authenticates 18 live inputs before source imports. It replays +the PR5580, PR5565 and PR5601 words and checks both source deltas. The unchanged +PR5605 and PR5612 constructors build the shared and delayed relays. Their +13 combined source edits are disjoint from PR5601's 21 edits. The delayed +paid delta is exactly H4+H7-H5-H6, with every target retained. + +It then checks five fixed PR5602 boundary relations, nine independent cuts +and both PR5606 preparation identities on the new word. Every intermediate +arbitrary-input interface passes. Only the witness event indices change. +The H2 target is debited and both replaced H1 queries are removed. Nine +owned roles, eleven lifetimes and peak occupancy two are charged. + +The final checks cover 565,504 transpose coefficients, 2,916 exact native +maps, 1,070 helper normalizers, 208 main adapters and the complete physical +caller. Two exact moment engines, all compiler conditions, 54 strict outer +conditions and four functional conditions pass. Eleven local/controller +mutation controls reject, as do the wrong-phase, old-cutoff and old-BIT controls. + +The scalar allowance is 220154 and the route allowance is 5175000 per local +call; their sum is below 10000000. The paid rank mass is 5986. The complete +nonrecursive bound is 184647552, below 1000000000. + +A separate exact receipt comparison uses PR5613 at +`32f23af8790cc3c435bb1f495d861332b4f000e3`. Its bill differs by 72 extra rank-five +paid calls and 72 extra rank-five targets. Thus its signed moment equals +this one. That comparison does not independently accept PR5613's construction. +The tighter reserve uses headroom in that common invoice; it does not claim +another physical mechanism. + +The final finite split screen tested 46 boundary groups and found no further +candidate. The screen is restricted to the declared after-MOVE basis-pair class. + +Registered normal and optimized replays both passed at scientific commit +`3e038c5da1b56e9c9e3ad76c0592e91914f7eb6d`. The metadata/source-pin check and +36-file committed-byte check passed. The official export and its integrity +check also passed. These commands reproduce those checks: + +```sh +python3 -B scripts/research_package.py --package research/p104-helper-subspace-splits --check-only +python3 -B scripts/research_package.py --package research/p104-helper-subspace-splits +python3 -B scripts/check_research_commit.py --package research/p104-helper-subspace-splits +python3 -B scripts/export_research_package.py export --package research/p104-helper-subspace-splits --ref 3e038c5da1b56e9c9e3ad76c0592e91914f7eb6d --output /tmp/helper-splits.tar +python3 -B scripts/export_research_package.py check /tmp/helper-splits.tar +``` + +The exported package passed a fresh isolated optimized replay with no Git +directory, an empty PATH, file mode 0444 and directory mode 0555. The run +used an absolute CPython 3.12.14 executable with `-I -O -B`. All 37 files, +including the export manifest, kept their hashes and modes. A one-byte change +to the retained PR5612 constructor then failed at its SHA256 check before +import. The test restored the exact source bytes and mode and checked all +files again. The harness returned +`PASS_READ_ONLY_GIT_FREE_REPLAY_AND_SOURCE_FAULT`. + +Only this validation record changes after the frozen scientific replay. +The final publication check compares all other 35 package/input files with +that commit. No pre-existing unmerged branch objects or writable source files +were needed for the sealed replay. These are author-side checks, not +independent scientific acceptance. + +## Source history and limits + +The source copies are pinned to retained paths at ancestor commits +`29fe88ba218b5d2192d8e31f07a01d1141afdacd` (PR5580), +`bf64e66656843a64e798b8374cd9f53add3f6f46` (PR5565), +`55914a0de83df255bd7e7071d79ad04b81ca1070` (PR5601), +`0bccb2ff858db877119217f7d98409ee6a24ccce` (PR5602), +`4ae31ae93e86d6ab7ddd75e42fee86cf21cdb8c8` (PR5605 and PR5606), and +`a692fd471ee7c47fa30ae755b80e51ef7e022689` (PR5612). +Each SHA256 and Git blob equals its recorded published source. Registered +replay needs no cached unmerged-branch objects. Full-history preflight is +not run because this checkout is shallow. Independent human review and hosted CI are pending. No complete rounded -multiplier or enormous uniform word was materialized. +multiplier or enormous uniform word was materialized. The five selected +framework assumptions and the helper-endpoint contract remain. No global +optimum is claimed. diff --git a/research/p104-helper-subspace-splits/VERIFY.json b/research/p104-helper-subspace-splits/VERIFY.json index f02fe9b970..da4ab62c4b 100644 --- a/research/p104-helper-subspace-splits/VERIFY.json +++ b/research/p104-helper-subspace-splits/VERIFY.json @@ -16,7 +16,12 @@ "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", "research/query-thinned-controllers/RESULT.json", "research/p104-helper-subspace-splits/inputs/PR5580-WORD.json.gz", - "research/p104-helper-subspace-splits/inputs/PR5565-WORD.json.gz" + "research/p104-helper-subspace-splits/inputs/PR5565-WORD.json.gz", + "research/p104-helper-subspace-splits/inputs/PR5601-WORD.json.gz", + "research/p104-helper-subspace-splits/inputs/PR5602-construct.py", + "research/p104-helper-subspace-splits/inputs/PR5602-WITNESS.json", + "research/p104-helper-subspace-splits/inputs/PR5605-construct.py", + "research/p104-helper-subspace-splits/inputs/PR5612-delayed.py" ], "commands": [ { @@ -26,7 +31,7 @@ "{package}/verify.py" ], "timeout_seconds": 600, - "checks": "Check all 13 independent cuts, every rational row and reverse column, native maps, complete caller and invoice, two moment engines, compiler and outer predicates; reject false inputs, outputs, target credit and cost." + "checks": "Check the disjoint shared/delayed relay merge, five fixed boundaries, nine independent splits, both preparation identities and target debit, every rational row and column, all native maps, the physical caller, full invoice, two moment engines, compiler and outer predicates. Reject false identities, support, credits and costs." }, { "argv": [ @@ -36,7 +41,7 @@ "{package}/verify.py" ], "timeout_seconds": 600, - "checks": "Check all 13 independent cuts, every rational row and reverse column, native maps, complete caller and invoice, two moment engines, compiler and outer predicates; reject false inputs, outputs, target credit and cost." + "checks": "Check the disjoint shared/delayed relay merge, five fixed boundaries, nine independent splits, both preparation identities and target debit, every rational row and column, all native maps, the physical caller, full invoice, two moment engines, compiler and outer predicates. Reject false identities, support, credits and costs." } ] } diff --git a/research/p104-helper-subspace-splits/WORD.json.gz b/research/p104-helper-subspace-splits/WORD.json.gz index e325091e30..b60955f312 100644 Binary files a/research/p104-helper-subspace-splits/WORD.json.gz and b/research/p104-helper-subspace-splits/WORD.json.gz differ diff --git a/research/p104-helper-subspace-splits/construct.py b/research/p104-helper-subspace-splits/construct.py index 698a4cbcc0..f73b8d4d75 100644 --- a/research/p104-helper-subspace-splits/construct.py +++ b/research/p104-helper-subspace-splits/construct.py @@ -4,10 +4,144 @@ The source word and caller retain the credits in README.md. """ from copy import deepcopy +from collections import Counter +from difflib import SequenceMatcher from fractions import Fraction as Q import local as L +def merge_relay(original, changed): + """Merge disjoint published edits against their common PR5580 source.""" + C = L.load(L.HERE/'inputs/PR5605-construct.py', 'released_relay_constructor') + D = L.load(L.HERE/'inputs/PR5612-delayed.py', 'released_delayed_constructor') + relay = C.construct(original) + shared = L.replay(relay) + relay = D.construct(relay) + delayed = L.replay(relay) + delta = Counter(delayed['paid']) + delta.subtract(shared['paid']) + delta = {r:n for r,n in delta.items() if n} + L.need(delta == {4:1,5:-1,6:-1,7:1}, 'Exact published delayed-relay paid delta') + L.need(delayed['helpers'] == shared['helpers'], 'The delayed relay retains every target') + L.need(all(relay[k] == original[k] for k in original if k != 'program'), + 'The relay changes only the scalar program and transports') + + def edits(word): + a = [tuple(e) for e in original['program']] + b = [tuple(e) for e in word['program']] + return [(i,j,word['program'][u:v]) for op,i,j,u,v in + SequenceMatcher(None,a,b,autojunk=False).get_opcodes() if op != 'equal'] + + frame_edits, relay_edits = edits(changed), edits(relay) + for i,j,_ in frame_edits: + for u,v,_ in relay_edits: + L.need(not (max(i,u) < min(j,v) or (i == j and u <= i <= v) or + (u == v and i <= u <= j)), 'Disjoint exact source edits') + word, program, start = deepcopy(changed), [], 0 + for i,j,events in sorted(frame_edits+relay_edits): + L.need(start <= i, 'Ordered nonoverlapping source edits') + program += original['program'][start:i]+events + start = j + word['program'] = deepcopy(program+original['program'][start:]) + L.replay(word) + return word, {'frame_edits':len(frame_edits), 'relay_edits':len(relay_edits), + 'delayed_paid_delta':delta} + + +def prepare_helper(source, declaration): + """Reuse PR5606's two exact value identities and remove the H2 target.""" + n, h = source['public'], declaration['helper'] + L.need(n == 744 and source.get('owned_fields', 8) == 8, 'Complete pre-preparation interface') + L.need(h == 573 and source['initial'][h] == 3 and source['final'][h] == 603, + 'The declared rank-two prefix helper') + L.need(len(source['frames'][603])-len(source['frames'][3]) == 2, 'Debited target rank') + L.need(h > max(set(source['live']) | {r+112 for r in source['live']}), 'Main roles retain their labels') + sites = {item['event']:item for item in declaration['replacements']} + L.need(len(sites) == 2, 'Two prepared query sites') + rows = [{r:Q(1)} if r < n and r != h else {} for r in range(n+8)] + current = source['initial']+[None]*8 + program, receipts = [['INIT',h,3]], [] + for i,e in enumerate(source['program']): + op,r = e[:2] + if i in sites: + item = sites[i] + L.need(e == item['old'] and op == 'MOVE' and r == h and not e[4], 'Exact prepared paid site') + target = {} + for s,q in item['suppliers']: + L.need(current[s] == e[3], 'Coframed preparation supplier') + L.add(target,rows[s],Q(q)) + L.need(target == rows[h], 'Exact current-value preparation identity') + a,b = item['suppliers'] + program += [['CLEAR',h,e[2]],['INIT',h,e[3]], + ['COPY',h,a[0],a[1],e[3]],['ADD',h,b[0],b[1],e[3]]] + current[h] = e[3] + receipts.append({'event':i, 'rank':len(source['frames'][e[3]])-len(source['frames'][e[2]])}) + continue + program.append(e[:]) + if op == 'MOVE': + current[r] = e[3] + elif op in ('INIT','CLEAR'): + rows[r] = {} + current[r] = e[2] if op == 'INIT' else None + elif op == 'SCALE': + rows[r] = {k:Q(e[-2])*v for k,v in rows[r].items()} + elif op == 'COPY': + rows[r] = {k:Q(e[-2])*v for k,v in rows[e[2]].items()} + else: + L.add(rows[r],rows[e[2]],Q(e[-2])) + L.need(len(receipts) == 2 and all(x['rank'] == 1 for x in receipts) and not rows[h], + 'Two rank-one queries removed and a zero final helper') + program.append(['CLEAR',h,603]) + + def rename(r): + return n+7 if r == h else r-int(r > h) + + for e in program: + e[1] = rename(e[1]) + if e[0] in ('ADD','COPY'): + e[2] = rename(e[2]) + word = deepcopy(source) + word.update(schema='p104-helper-subspace-prepared/1', public=n-1, owned_fields=9, + initial=source['initial'][:h]+source['initial'][h+1:], + final=source['final'][:h]+source['final'][h+1:], program=program) + L.replay(word) + return word, {'old_helper':h, 'new_owned_role':n+7, 'debited_target_rank':2, 'sites':receipts} + + +def boundary_changes(source, changes, published): + """Apply five fixed PR5602 relations at checked PR5601 event positions.""" + C = L.load(L.HERE/'inputs/PR5602-construct.py', 'released_boundary_constructor') + L.need([c['source_step'] for c in changes] == list(range(5)), 'Five published boundary relations') + word, evidence = deepcopy(source), [] + public = word['public'] + + def owned_events(w): + return [e for e in w['program'] if e[1] >= public or + (e[0] in ('ADD', 'COPY') and e[2] >= public)] + + owned = owned_events(source) + before = L.replay(word) + for item in changes: + c = item['witness'] + original = published['steps'][item['source_step']] + L.need(dict(c, cut=original['cut']) == original, 'Unchanged published boundary relation') + oriented = C.transpose(word) if c['reverse'] else word + L.need(oriented['program'][c['cut']] == item['anchor'], 'Exact boundary event anchor') + word = C.boundary_basis(word, c) + after = L.replay(word) + for name, expected in (('paid', {5:-1}), ('helpers', {4:1, 9:-1})): + delta = Counter(after[name]) + delta.subtract(before[name]) + L.need({r:n for r,n in delta.items() if n} == expected, 'Exact boundary '+name+' delta') + evidence.append({'helper':c['helper'], 'cut':c['cut'], 'reverse':c['reverse'], + 'events':len(word['program']), 'paid':after['paid'], 'helpers':after['helpers']}) + before = after + C.restore_copy_opcodes(word) + L.need(owned_events(word) == owned, 'The complete chronological owned paths are unchanged') + L.replay(word) + return word, evidence + + def inverse(program): return [[e[0], *e[1:-2], str(1/Q(e[-2]) if e[0] == 'SCALE' else -Q(e[-2])), e[-1]] @@ -71,8 +205,9 @@ def check_cut(word, h): 'Two strictly productive nested targets') L.need(h['ranks'] == [len(word['frames'][f])-len(word['frames'][u]), len(word['frames'][v])-len(word['frames'][f])], 'Declared split ranks') - rows = [{r: Q(1)} if r < n else {} for r in range(n+8)] - current = word['initial']+[None]*8 + owned = word.get('owned_fields', 8) + rows = [{r: Q(1)} if r < n else {} for r in range(n+owned)] + current = word['initial']+[None]*owned for e in word['program'][:cut+1]: op, r = e[:2] if op == 'MOVE': @@ -91,7 +226,7 @@ def check_cut(word, h): for r, q in a.items(): L.add(total, rows[r], q) L.need(total == c, 'Exact prefix functional; no other input') - column = [b.get(r, Q(0)) for r in range(n+8)] + column = [b.get(r, Q(0)) for r in range(n+owned)] for e in word['program'][cut+1:]: op, r = e[:2] if op in ('INIT', 'CLEAR'): @@ -102,7 +237,7 @@ def check_cut(word, h): column[r] = Q(e[-2])*column[e[2]] elif op == 'ADD': column[r] += Q(e[-2])*column[e[2]] - L.need(column == [d.get(r, Q(0)) for r in range(n+8)], 'Exact suffix direction; no other output') + L.need(column == [d.get(r, Q(0)) for r in range(n+owned)], 'Exact suffix direction; no other output') L.need(sum(x*b.get(r, 0) for r, x in a.items()) == sum(x*d.get(r, 0) for r, x in c.items()) == 1, 'Both independent pairings') return a, b, c, d diff --git a/research/p104-helper-subspace-splits/inputs/PR5601-WORD.json.gz b/research/p104-helper-subspace-splits/inputs/PR5601-WORD.json.gz new file mode 100644 index 0000000000..3c9a5ce896 Binary files /dev/null and b/research/p104-helper-subspace-splits/inputs/PR5601-WORD.json.gz differ diff --git a/research/p104-helper-subspace-splits/inputs/PR5602-WITNESS.json b/research/p104-helper-subspace-splits/inputs/PR5602-WITNESS.json new file mode 100644 index 0000000000..8073b3c977 --- /dev/null +++ b/research/p104-helper-subspace-splits/inputs/PR5602-WITNESS.json @@ -0,0 +1,981 @@ +{ + "schema": "p104-coupled-helper-bases/1", + "steps": [ + { + "kind": "boundary_basis", + "reverse": true, + "helper": 652, + "cut": 11360, + "frame": 120, + "output": [ + [ + 205, + "-2" + ], + [ + 648, + "-1" + ], + [ + 649, + "-1" + ], + [ + 650, + "1" + ], + [ + 652, + "1" + ] + ], + "cancel": [ + [ + 648, + "1" + ], + [ + 649, + "1" + ], + [ + 650, + "-1" + ] + ] + }, + { + "kind": "boundary_basis", + "reverse": false, + "helper": 341, + "cut": 11151, + "frame": 240, + "output": [ + [ + 93, + "-2" + ], + [ + 339, + "-2" + ], + [ + 341, + "1" + ], + [ + 351, + "2" + ] + ], + "cancel": [ + [ + 337, + "2" + ] + ] + }, + { + "kind": "boundary_basis", + "reverse": true, + "helper": 596, + "cut": 11378, + "frame": 1053, + "output": [ + [ + 188, + "-1" + ], + [ + 592, + "-1" + ], + [ + 593, + "1" + ], + [ + 594, + "1" + ], + [ + 596, + "1" + ] + ], + "cancel": [ + [ + 592, + "1" + ], + [ + 593, + "-1" + ], + [ + 594, + "-1" + ] + ] + }, + { + "kind": "boundary_basis", + "reverse": true, + "helper": 668, + "cut": 11449, + "frame": 1051, + "output": [ + [ + 115, + "2" + ], + [ + 664, + "1" + ], + [ + 665, + "1" + ], + [ + 666, + "-1" + ], + [ + 668, + "1" + ] + ], + "cancel": [ + [ + 664, + "-1" + ], + [ + 665, + "-1" + ], + [ + 666, + "1" + ] + ] + }, + { + "kind": "boundary_basis", + "reverse": true, + "helper": 684, + "cut": 11493, + "frame": 1049, + "output": [ + [ + 126, + "2" + ], + [ + 680, + "-1" + ], + [ + 681, + "1" + ], + [ + 682, + "1" + ], + [ + 684, + "1" + ] + ], + "cancel": [ + [ + 680, + "1" + ], + [ + 681, + "-1" + ], + [ + 682, + "-1" + ] + ] + }, + { + "kind": "boundary_basis", + "reverse": true, + "helper": 649, + "cut": 11525, + "frame": 597, + "output": [ + [ + 649, + "1" + ], + [ + 650, + "-1" + ] + ], + "cancel": [ + [ + 198, + "1/2" + ], + [ + 650, + "1" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 10053, + "frame": 306, + "group": [ + 3, + 127 + ], + "pivot": 61, + "v": [ + [ + 257, + "-1/2" + ], + [ + 261, + "1" + ] + ], + "u": [ + [ + 257, + "1" + ] + ], + "source_functional": [ + [ + 61, + "2" + ], + [ + 259, + "2" + ], + [ + 265, + "2" + ] + ], + "output_direction": [ + [ + 115, + "-1/2" + ], + [ + 173, + "1/2" + ], + [ + 188, + "-1/2" + ], + [ + 205, + "-1/2" + ], + [ + 257, + "1/2" + ], + [ + 258, + "-1/2" + ], + [ + 263, + "1/2" + ], + [ + 265, + "1/2" + ], + [ + 268, + "-1/2" + ], + [ + 269, + "-1/2" + ], + [ + 271, + "1/2" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 12429, + "frame": 516, + "group": [ + 3, + 127 + ], + "pivot": 432, + "v": [ + [ + 20, + "1" + ], + [ + 110, + "-2" + ], + [ + 435, + "1" + ] + ], + "u": [ + [ + 37, + "2" + ], + [ + 110, + "1" + ] + ], + "source_functional": [ + [ + 21, + "-1" + ], + [ + 435, + "-1" + ] + ], + "output_direction": [ + [ + 432, + "2" + ], + [ + 433, + "2" + ], + [ + 434, + "-1" + ], + [ + 435, + "-1" + ], + [ + 436, + "-1" + ], + [ + 437, + "-1" + ], + [ + 440, + "-1" + ], + [ + 441, + "-1" + ], + [ + 446, + "1" + ], + [ + 447, + "1" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 13584, + "frame": 603, + "group": [ + 3, + 127 + ], + "pivot": 572, + "v": [ + [ + 572, + "1/4" + ], + [ + 573, + "-1/4" + ], + [ + 710, + "1" + ] + ], + "u": [ + [ + 710, + "1" + ] + ], + "source_functional": [ + [ + 572, + "1/4" + ], + [ + 573, + "-1/4" + ] + ], + "output_direction": [ + [ + 115, + "2" + ], + [ + 126, + "-2" + ], + [ + 205, + "-2" + ], + [ + 242, + "2" + ], + [ + 243, + "-2" + ], + [ + 247, + "-2" + ], + [ + 249, + "2" + ], + [ + 252, + "-2" + ], + [ + 306, + "-2" + ], + [ + 311, + "-4" + ], + [ + 317, + "-2" + ], + [ + 456, + "4" + ], + [ + 457, + "-4" + ], + [ + 498, + "4" + ], + [ + 499, + "2" + ], + [ + 502, + "-2" + ], + [ + 503, + "2" + ], + [ + 572, + "2" + ], + [ + 573, + "-2" + ], + [ + 710, + "1" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 13638, + "frame": 391, + "group": [ + 3, + 127 + ], + "pivot": 345, + "v": [ + [ + 345, + "1/8" + ], + [ + 351, + "-1/4" + ], + [ + 712, + "1" + ] + ], + "u": [ + [ + 712, + "1" + ] + ], + "source_functional": [ + [ + 93, + "1/4" + ] + ], + "output_direction": [ + [ + 93, + "4" + ], + [ + 205, + "-4" + ], + [ + 343, + "-2" + ], + [ + 344, + "-2" + ], + [ + 345, + "-2" + ], + [ + 347, + "-2" + ], + [ + 348, + "-2" + ], + [ + 349, + "-2" + ], + [ + 350, + "2" + ], + [ + 351, + "2" + ], + [ + 712, + "1" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 13670, + "frame": 462, + "group": [ + 3, + 127 + ], + "pivot": 14, + "v": [ + [ + 14, + "1/8" + ], + [ + 52, + "-1/4" + ], + [ + 727, + "1" + ] + ], + "u": [ + [ + 727, + "1" + ] + ], + "source_functional": [ + [ + 14, + "1/4" + ] + ], + "output_direction": [ + [ + 14, + "4" + ], + [ + 126, + "-4" + ], + [ + 402, + "-4" + ], + [ + 403, + "-4" + ], + [ + 727, + "1" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 13975, + "frame": 424, + "group": [ + 3, + 127 + ], + "pivot": 3, + "v": [ + [ + 3, + "1/4" + ], + [ + 67, + "1/8" + ], + [ + 722, + "1" + ] + ], + "u": [ + [ + 722, + "1" + ] + ], + "source_functional": [ + [ + 3, + "1/4" + ] + ], + "output_direction": [ + [ + 3, + "4" + ], + [ + 115, + "-4" + ], + [ + 370, + "-4" + ], + [ + 372, + "-4" + ], + [ + 722, + "1" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 14010, + "frame": 252, + "group": [ + 3, + 127 + ], + "pivot": 76, + "v": [ + [ + 76, + "1/8" + ], + [ + 87, + "-1/4" + ], + [ + 717, + "1" + ] + ], + "u": [ + [ + 717, + "1" + ] + ], + "source_functional": [ + [ + 76, + "1/4" + ] + ], + "output_direction": [ + [ + 76, + "4" + ], + [ + 188, + "-4" + ], + [ + 226, + "-4" + ], + [ + 227, + "-4" + ], + [ + 717, + "1" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 9716, + "frame": 267, + "group": [ + 3, + 127 + ], + "pivot": 224, + "v": [ + [ + 57, + "1" + ] + ], + "u": [ + [ + 57, + "-1" + ], + [ + 81, + "1" + ] + ], + "source_functional": [ + [ + 227, + "-1" + ] + ], + "output_direction": [ + [ + 115, + "1/2" + ], + [ + 146, + "1/2" + ], + [ + 151, + "1/2" + ], + [ + 188, + "-1" + ], + [ + 205, + "1/2" + ], + [ + 225, + "1/2" + ], + [ + 226, + "-1/2" + ], + [ + 227, + "-1" + ], + [ + 229, + "1/2" + ], + [ + 230, + "1/2" + ], + [ + 233, + "1/2" + ], + [ + 234, + "1/2" + ], + [ + 236, + "-1" + ], + [ + 237, + "-1/2" + ], + [ + 238, + "1/2" + ] + ] + }, + { + "kind": "coupled_handoff", + "cut": 12126, + "frame": 477, + "group": [ + 3, + 127 + ], + "pivot": 400, + "v": [ + [ + 42, + "1" + ] + ], + "u": [ + [ + 41, + "1" + ], + [ + 42, + "1" + ] + ], + "source_functional": [ + [ + 403, + "1" + ] + ], + "output_direction": [ + [ + 126, + "3/2" + ], + [ + 133, + "1/2" + ], + [ + 146, + "1/2" + ], + [ + 151, + "-1/2" + ], + [ + 400, + "1" + ], + [ + 401, + "-1" + ], + [ + 403, + "1" + ], + [ + 404, + "-1/2" + ], + [ + 405, + "-1/2" + ], + [ + 406, + "-1/2" + ], + [ + 407, + "-1/2" + ], + [ + 408, + "-1/2" + ], + [ + 409, + "-1" + ], + [ + 410, + "-1/2" + ], + [ + 412, + "1/2" + ], + [ + 413, + "1" + ], + [ + 414, + "1/2" + ] + ] + } + ] +} diff --git a/research/p104-helper-subspace-splits/inputs/PR5602-construct.py b/research/p104-helper-subspace-splits/inputs/PR5602-construct.py new file mode 100644 index 0000000000..ef5936ca89 --- /dev/null +++ b/research/p104-helper-subspace-splits/inputs/PR5602-construct.py @@ -0,0 +1,215 @@ +"""Construct the fixed helper basis changes and coupled handoffs. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The source word and its contributors are recorded in SOURCES.json. +""" +from copy import deepcopy +from fractions import Fraction as Q +import local as L + + +def row(pairs): + out = {r: Q(q) for r, q in pairs} + L.need(len(out) == len(pairs) and all(out.values()), 'Unique nonzero witness row') + return out + + +def unit(q): + n, d = abs(q.numerator), q.denominator + return n > 0 and n & (n-1) == 0 and d & (d-1) == 0 + + +def main_fields(w): + return set(w['live']) | {r+112 for r in w['live']} + + +def prefix(w, cut): + n = w['public'] + rows = [{i: Q(1)} for i in range(n)] + [{} for _ in range(8)] + frames = w['initial'][:] + [None]*8 + L.need(0 <= cut < len(w['program']), 'Cut in the literal word') + for e in w['program'][:cut+1]: + op, r = e[:2] + if op == 'MOVE': + L.need(frames[r] == e[2], 'Prefix transport source') + frames[r] = e[3] + elif op in ('INIT', 'CLEAR'): + rows[r] = {} + frames[r] = e[2] if op == 'INIT' else None + else: + L.need(frames[r] == e[-1], 'Prefix scalar chart') + if op == 'SCALE': + rows[r] = {k: Q(e[-2])*v for k, v in rows[r].items()} + else: + L.need(frames[e[2]] == e[-1], 'Prefix source chart') + if op == 'COPY': + L.need(not rows[r], 'Source COPY into zero') + L.add(rows[r], rows[e[2]], Q(e[-2])) + return rows, frames + + +def suffix_columns(w, cut): + cols = [{i: Q(1)} for i in range(w['public'])] + [{} for _ in range(8)] + for e in reversed(w['program'][cut+1:]): + op, r = e[:2] + if op == 'MOVE': + continue + if op in ('INIT', 'CLEAR'): + cols[r] = {} + elif op == 'SCALE': + cols[r] = {k: Q(e[-2])*v for k, v in cols[r].items()} + else: + L.add(cols[e[2]], cols[r], Q(e[-2])) + if op == 'COPY': + cols[r] = {} + return cols + + +def transpose(w): + program = [] + for e in reversed(w['program']): + op, r = e[:2] + if op == 'MOVE': + z = ['MOVE', r, e[3], e[2], e[4]] + elif op in ('ADD', 'COPY'): + z = ['ADD', e[2], r, e[3], e[4]] + elif op == 'SCALE': + z = e[:] + else: + L.need(op in ('INIT', 'CLEAR'), 'Transpose opcode') + z = ['CLEAR' if op == 'INIT' else 'INIT', r, e[2]] + program.append(z) + return dict(w, initial=w['final'][:], final=w['initial'][:], program=program) + + +def boundary_basis(w, c): + w = transpose(w) if c['reverse'] else deepcopy(w) + h, cut, frame = c['helper'], c['cut'], c['frame'] + output, cancel = row(c['output']), row(c['cancel']) + helpers = set(range(w['public'])) - main_fields(w) + L.need(h in helpers and unit(output.get(h, Q(0))), 'Helper unit boundary pivot') + source = w['initial'][h] + L.need(set(output) <= {r for r in helpers if w['initial'][r] == source}, + 'Boundary basis uses one helper input chart') + rows, frames = prefix(w, cut) + L.need(frames[h] == frame and h not in cancel and + all(frames[r] == frame for r in cancel), 'Available boundary cancellation') + value = rows[h].copy() + for r, q in cancel.items(): + L.add(value, rows[r], -q) + L.need(value == output, 'Exact boundary helper relation') + tail = w['program'][cut+1:] + L.need(not any(e[0] in ('ADD', 'COPY') and e[2] == h for e in tail), + 'Retired helper has no later source read') + coefficient = output[h] + before = [['ADD', h, r, str(-q/coefficient), source] + for r, q in sorted(output.items()) if r != h] + middle = [['ADD', h, r, str(-q), frame] for r, q in sorted(cancel.items())] + if coefficient != 1: + middle.append(['SCALE', h, str(1/coefficient), frame]) + w['program'] = before + w['program'][:cut+1] + middle + [e for e in tail if e[1] != h] + w['final'][h] = frame + return transpose(w) if c['reverse'] else w + + +def inverse(ops): + out = [] + for e in reversed(ops): + z = e[:] + z[-2] = str(1/Q(e[-2]) if e[0] == 'SCALE' else -Q(e[-2])) + out.append(z) + return out + + +def basis(a, b, p, frame): + """Return a matrix R with a R = e_p^T and R e_p = b.""" + L.need(sum(a.get(h, 0)*q for h, q in b.items()) == 1, 'Dual basis pairing') + q = next((h for h in sorted(a) if unit(a[h])), None) + L.need(q is not None, 'Dyadic basis pivot') + ops = [] if p == q else [ + ['ADD', p, q, '1', frame], ['ADD', q, p, '-1', frame], + ['ADD', p, q, '1', frame], ['SCALE', q, '-1', frame]] + ops += [['ADD', j, q, str(c), frame] for j, c in sorted(b.items()) if j != q] + if a[q] != 1: + ops.append(['SCALE', q, str(1/a[q]), frame]) + ops += [['ADD', q, j, str(-c/a[q]), frame] for j, c in sorted(a.items()) if j != q] + return ops + + +def relabel(e, mapping): + z = e[:] + z[1] = mapping(z[1]) + if z[0] in ('ADD', 'COPY'): + z[2] = mapping(z[2]) + return z + + +def handoff(w, c): + n, cut, frame, p = w['public'], c['cut'], c['frame'], c['pivot'] + source, target = c['group'] + group = {h for h in range(n) if h not in main_fields(w) and + (w['initial'][h], w['final'][h]) == (source, target)} + v, u = row(c['v']), row(c['u']) + pairing = sum(v.get(h, 0)*q for h, q in u.items()) + L.need(unit(pairing), 'Nonzero dyadic handoff pairing') + v = {h: q/pairing for h, q in v.items()} + rows, frames = prefix(w, cut) + L.need(all(f is None for f in frames[n:]), 'No owned field at handoff cut') + L.need(p in group and frames[p] == frame and + all(0 <= h < n and frames[h] == frame for h in v.keys() | u.keys()), + 'Public handoff fields share the cut chart') + L.need(L.span(w['frames'][source]) < L.span(w['frames'][frame]) < + L.span(w['frames'][target]), 'Strict nested handoff boundaries') + cols, a, b = suffix_columns(w, cut), {}, {} + for r, q in v.items(): + L.add(a, rows[r], q) + for r, q in u.items(): + L.add(b, cols[r], q) + L.need(a == row(c['source_functional']) and b == row(c['output_direction']), + 'Exact prefix and suffix handoff witnesses') + L.need(set(a) <= group and set(b) <= group, 'Handoff has only helper boundary support') + input_ops, cut_basis = basis(a, b, p, source), basis(v, u, p, frame) + output_ops = inverse(input_ops) + for e in output_ops: + e[-1] = target + old = lambda r: r+1 if r >= n else r + tail = lambda r: n if r == p else old(r) + out = deepcopy(w) + out['public'] = n+1 + out['initial'].append(frame) + out['final'][p] = frame + out['final'].append(target) + out['program'] = input_ops + [relabel(e, old) for e in w['program'][:cut+1]] + out['program'] += inverse(cut_basis) + [relabel(e, tail) for e in cut_basis] + out['program'] += [relabel(e, tail) for e in w['program'][cut+1:]] + out['program'] += [relabel(e, tail) for e in output_ops] + return out + + +def restore_copy_opcodes(w): + fresh, copies = set(), 0 + for e in w['program']: + op, r = e[:2] + if op == 'INIT': + fresh.add(r) + elif r in fresh and op != 'MOVE': + L.need(op == 'ADD', 'First owned write is the retained copy') + e[0] = 'COPY' + fresh.remove(r) + copies += 1 + L.need(not fresh and copies == 8, 'All eight owned copy paths remain') + + +def construct(base, witness): + L.need(witness['schema'] == 'p104-coupled-helper-bases/1', 'Witness schema') + L.need([s['kind'] for s in witness['steps']] == + ['boundary_basis']*6 + ['coupled_handoff']*9, 'Fixed fifteen changes') + word, evidence = deepcopy(base), [] + for step in witness['steps']: + word = boundary_basis(word, step) if step['kind'] == 'boundary_basis' else handoff(word, step) + check = L.replay(word) + evidence.append(dict(kind=step['kind'], public=word['public'], + events=len(word['program']), paid=check['paid'], helpers=check['helpers'])) + restore_copy_opcodes(word) + L.replay(word) + return word, evidence diff --git a/research/p104-helper-subspace-splits/inputs/PR5605-construct.py b/research/p104-helper-subspace-splits/inputs/PR5605-construct.py new file mode 100644 index 0000000000..31f9b76c9b --- /dev/null +++ b/research/p104-helper-subspace-splits/inputs/PR5605-construct.py @@ -0,0 +1,60 @@ +"""Reconstruct the shared587 relay from the frozen PR5580 word. + +Prepared for flyingviper with substantial OpenAI Codex assistance and +independent agents. Source word: Ali Romman and the retained P104 lineage. +Apache-2.0. +""" +from copy import deepcopy + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def construct(base): + old = base['program'] + need(len(old) == 25140, 'Pinned PR5580 event count') + expected = { + 13413: ['ADD',159,738,'-1',565], + 13414: ['MOVE',738,565,564,True], + 13415: ['ADD',203,738,'2',564], + 13416: ['MOVE',148,467,596,False], + 13417: ['MOVE',738,564,596,True], + 13418: ['ADD',148,738,'2',596], + 13420: ['MOVE',738,596,597,True], + 14010: ['ADD',165,21,'-1/2',652], + 14017: ['MOVE',148,596,655,False], + 14633: ['MOVE',587,3,597,False], + 14634: ['ADD',587,734,'-4',597], + 14635: ['MOVE',587,597,773,False], + } + need(all(old[i] == e for i,e in expected.items()), 'Pinned changed source events') + affected = {123: '1/2',148: '-1/2',175: '-1/2',182: '-1/2',203: '1/2',223: '-1/2'} + # Q = I-uN, N=e587-4e734. Supports are disjoint, so these ADDs + # implement the exact nilpotent inverse without implementation feedback. + from fractions import Fraction as Q + out = [['ADD',r,s,str(-Q(u)*v),3] + for r,u in sorted(affected.items()) for s,v in ((587,Q(1)),(734,Q(-4)))] + remove = {13414,13415,13416,13417,13418,13420,14633,14634} + for i,e in enumerate(old): + if i == 24461: + # Undo the shared residual while all six targets and three + # unmodified sources coexist at the full frame. + for r,sign in ((21,-1),(47,-1),(434,1),(435,1),(436,1),(437,1)): + out += [['ADD',r,133,str(sign),127], + ['ADD',r,587,str(Q(sign,2)),127], + ['ADD',r,734,str(-2*sign),127]] + if i not in remove: + out.append(['MOVE',587,652,773,False] if i == 14635 else + ['MOVE',148,467,655,False] if i == 14017 else deepcopy(e)) + if i == 13413: + out.append(['MOVE',738,565,597,True]) + if i == 13610: + out.extend(deepcopy([old[14633],old[14634]])) + if i == 14010: + out.extend([['MOVE',587,597,652,False],['ADD',21,587,'1',652]]) + word=deepcopy(base) + word['program']=out + need(len(out) == 25167, 'Exact reconstructed event count') + return word diff --git a/research/p104-helper-subspace-splits/inputs/PR5606-construct.py b/research/p104-helper-subspace-splits/inputs/PR5606-construct.py new file mode 100644 index 0000000000..e2c1473be0 --- /dev/null +++ b/research/p104-helper-subspace-splits/inputs/PR5606-construct.py @@ -0,0 +1,39 @@ +"""Remove two queries from PR5599's independent helper split. + +Scratch-net with substantial OpenAI Codex assistance. Apache-2.0. +Ali Romman's fifteen independent splits and source word remain credited. +""" +from copy import deepcopy + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def construct(source): + w = deepcopy(source) + need(w['public'] == 750 and len(w['program']) == 25502, 'Exact source shape') + need(w['initial'][573] == 3 and w['final'][573] == 603, 'Rank-two prefix helper') + need(w['frames'][3] == [] and len(w['frames'][603]) == 2, 'Prefix target rank') + replacements = { + 13670: (['MOVE',573,3,595,False], + [['CLEAR',573,3],['INIT',573,595], + ['COPY',573,572,'1',595],['ADD',573,732,'-2',595]]), + 13691: (['MOVE',573,595,603,False], + [['CLEAR',573,595],['INIT',573,603], + ['COPY',573,572,'1',603],['ADD',573,710,'2',603]])} + out = [['INIT',573,3]] + for i,event in enumerate(source['program']): + if i in replacements: + old,new = replacements[i] + need(event == old,'Pinned paid site '+str(i)) + out.extend(deepcopy(new)) + else: + out.append(deepcopy(event)) + out.append(['CLEAR',573,603]) + w.update(schema='p104-prepared-split-reuse/1',program=out, + retired_public=[573],fields=758, + independent_public=[r for r in range(750) if r != 573], + owned_roles=[573]+list(range(750,758))) + return w diff --git a/research/p104-helper-subspace-splits/inputs/PR5612-delayed.py b/research/p104-helper-subspace-splits/inputs/PR5612-delayed.py new file mode 100644 index 0000000000..afd1bd8e08 --- /dev/null +++ b/research/p104-helper-subspace-splits/inputs/PR5612-delayed.py @@ -0,0 +1,61 @@ +"""Explicit shared-component preparation and cleanup, with exact source pins. + +Prepared for flyingviper with substantial OpenAI Codex assistance and independent +agent derivations. Apache-2.0. The source word retains the P104 authorship in +PR5580. PR5605 supplies the shared587 relay; the optional commuting parent +also includes Pierre-Loic Doulcet's PR5565 cascade. No search is performed. +""" +from copy import deepcopy +from hashlib import sha256 +import json + +SOURCES={ + '95078b95bae0c56927f6daaa4430457cc43862c24a9db3b015bb1366e3381055': + ('PR5605',25167,'56425e27d8f115a6d5ad80ae207947172fbe65aab6712b633ebbd26f18a98f96'), + '3539111e4b2b5b1316746058bf25d973c4f0b9d91ed577a4d004975eb67320db': + ('PR5605 with the explicit PR5565 commuting cascade',25160, + 'd920c1c5dc31aedf9ed8ca5174adf7c9364993f9a003be1f2a033d23186636a3'), +} + +def digest(word): + return sha256(json.dumps(word,sort_keys=True,separators=(',',':')).encode()).hexdigest() + +def need(ok,why): + if not ok:raise ValueError(why) + +def construct(source): + pin=digest(source) + need(pin in SOURCES,'Exact frozen source word') + _,events,expected=SOURCES[pin] + need(source['public']==735 and len(source['program'])==events,'Source inventory') + need(all(source['initial'][r]==3 for r in [159,222,696,700,734]),'Zero-frame boundary roles') + need(all(source['final'][r]==127 for r in [133,696,697,698,700,703]),'Full-frame cleanup roles') + original=source['program'] + removed=[['MOVE',696,3,1031,False],['ADD',696,699,'-1',1031], + ['ADD',696,701,'1',1031],['ADD',696,702,'1',1031], + ['MOVE',738,591,565,True],['ADD',159,738,'-1',565]] + late_move=['MOVE',738,565,597,True] + zero_marker=['ADD',222,696,'1/2',3] + line_marker=['ADD',734,738,'1',597] + cleanup_marker=['ADD',133,288,'1/2',127] + need(all(original.count(e)==1 for e in removed+[late_move,zero_marker,line_marker,cleanup_marker]), + 'Unique literal edit markers') + program=[['ADD',r,s,str(c),3]for r,c in [(159,-1),(222,1)]for s in [696,700]] + for event in original: + if event==cleanup_marker: + for r,c in [(697,'-1/2'),(698,'1/2'),(703,'-1/2')]: + program.extend([['ADD',r,696,c,127],['ADD',r,700,c,127]]) + program.extend([['SCALE',700,'1/2',127],['ADD',700,696,'-1/2',127],['ADD',696,133,'1/2',127]]) + if event not in removed: + program.append(['MOVE',738,591,597,True] if event==late_move else deepcopy(event)) + if event==zero_marker: + program.extend([['ADD',696,700,'1',3],['ADD',696,734,'-1',3]]) + if event==line_marker: + program.extend([ + ['MOVE',696,3,597,False],['ADD',696,734,'1',597], + ['MOVE',696,597,1031,False],['ADD',696,699,'-1',1031],['ADD',696,700,'-1',1031], + ['ADD',703,696,'1',1031],['ADD',703,700,'1',1031],['ADD',703,699,'1',1031], + ['SCALE',700,'2',1031],['ADD',700,696,'1',1031],['ADD',700,699,'1',1031]]) + word=deepcopy(source);word['program']=program + need(len(program)==events+20 and digest(word)==expected,'Exact constructed payload') + return word diff --git a/research/p104-helper-subspace-splits/local.py b/research/p104-helper-subspace-splits/local.py index e6e28bacda..e72cb02dba 100644 --- a/research/p104-helper-subspace-splits/local.py +++ b/research/p104-helper-subspace-splits/local.py @@ -49,17 +49,19 @@ def span(basis): def replay(w): public = w['public'] + owned = w.get('owned_fields', 8) + need(type(owned) is int and 8 <= owned <= 9, 'Owned inventory bound') need(type(public) is int and 735 <= public <= 750, 'Public inventory bound') need(len(w['initial']) == len(w['final']) == public, 'Public boundary size') need(len(w['program']) < 26000, 'Fixed operation bound') frames = [span(x) for x in w['frames']] - rows = [{r:Q(1)} for r in range(public+8)] - current = list(w['initial']) + [None]*8 + rows = [{r:Q(1)} for r in range(public+owned)] + current = list(w['initial']) + [None]*owned paid, scalar, live_owned, peak = Counter(), 0, set(), 0 lifetimes = 0 for e in w['program']: op, r = e[:2] - need(0 <= r < public+8, 'Role index') + need(0 <= r < public+owned, 'Role index') if op == 'MOVE': _, r, a, b, private = e need(current[r] == a and (r in live_owned) == private, 'Transport source and ownership') @@ -92,7 +94,7 @@ def replay(w): scalar += 2*(abs(n.bit_length()-d.bit_length()) + int(q < 0)) else: s = e[2] - need(s != r and 0 <= s < public+8 and current[s] == f, 'Common scalar chart') + need(s != r and 0 <= s < public+owned and current[s] == f, 'Common scalar chart') if op == 'COPY': need(r in live_owned and not rows[r], 'COPY into cleared owned field') rows[r] = {k:q*x for k,x in rows[s].items()} @@ -100,7 +102,7 @@ def replay(w): need(op == 'ADD', 'Scalar opcode') add(rows[r], rows[s], q) scalar += 2*(3+n.bit_length()-1+n.bit_count()+d.bit_length()-1) - need(not live_owned and peak == 1 and current[:public] == w['final'], 'All public and owned exits') + need(not live_owned and 0 < peak <= 2 and current[:public] == w['final'], 'All public and owned exits') live = set(w['live']) for r,row in enumerate(rows): expected = {r:Q(1)} if r < public else {} @@ -110,14 +112,14 @@ def replay(w): main = live | {r+112 for r in live} helpers = Counter(len(w['frames'][w['final'][r]])-len(w['frames'][w['initial'][r]]) for r in range(public) if r not in main) need(len(live) == len(w['ports']) == 104 and len(main) == 208 and min(helpers) > 0, 'Independent productive inputs') - return {'paid':dict(paid), 'helpers':dict(helpers), 'public_inputs':public, 'owned_lifetimes':lifetimes, - 'peak_owned_fields':peak, 'real_scalar_allowance':scalar, 'endpoint_coefficients':(public+8)*(public+8), + return {'paid':dict(paid), 'helpers':dict(helpers), 'public_inputs':public, 'owned_fields':owned, 'owned_lifetimes':lifetimes, + 'peak_owned_fields':peak, 'real_scalar_allowance':scalar, 'endpoint_coefficients':(public+owned)*(public+owned), 'paid_rank_mass':sum(r*count for r,count in paid.items())} def reverse_columns(w): """Check the transpose with dense dyadic rows and the reverse chronology.""" public = w['public'] - n = public+8 + n = public+w.get('owned_fields', 8) rows = [[int(i == j) for j in range(n)] for i in range(n)] exponents = [0]*n for e in reversed(w['program']): diff --git a/research/p104-helper-subspace-splits/pricing.py b/research/p104-helper-subspace-splits/pricing.py index 0b54ad3f16..430934914b 100644 --- a/research/p104-helper-subspace-splits/pricing.py +++ b/research/p104-helper-subspace-splits/pricing.py @@ -6,6 +6,10 @@ Successor choices were prepared for thu-nmrc with OpenAI Codex assistance. Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance. The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565. +The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601. +Five fixed boundary relations are from Ali Romman's PR5602. +The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from +Scratch-net's PR5606. Their costs and target debit are included. Ali Romman's complete caller/price proof and all predecessor credit are retained. Apache-2.0. """ @@ -13,8 +17,8 @@ from fractions import Fraction as Q import local as L -KAPPA, TESTED = Q('.00310045'), Q('.0031004505') -PREVIOUS = Q('.00308520') +KAPPA, TESTED = Q('.00310440546'), Q('.003104405465') +PREVIOUS = Q('.00308595') def encode(x): @@ -63,7 +67,7 @@ def assemble(local, native, word, physical): second_p[8*(j+1)] += 208 L.need((targets,paid) == (second_t,second_p), 'Independent full invoice') L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks') - L.need(sum(targets.values()) == 13048 and sum(paid.values()) == 66726, 'Complete field and call counts') + L.need(sum(targets.values()) == 12958 and sum(paid.values()) == 66546, 'Complete field and call counts') L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus') return targets,paid,counts @@ -103,7 +107,7 @@ def margin(k): alpha = E.divide(paid,target) gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target)) - reserve,decay = Q(1,10**10),Q(39,40) + reserve,decay = Q(1,10**12),Q(39,40) L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios') L.need(decay**128 < Q(1,16), 'Both tail decay blocks') normalized = 1/(1+v*reserve)+Q(4,2**32) @@ -151,7 +155,7 @@ def wins(j): L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') bad=outer_module.ledger(dict(params,bit_saving=Q('.0027'))) L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected') - return encode({'kappa':KAPPA,'kappa_decimal':'.00310045','previous_open_pr5565':PREVIOUS,'gain':KAPPA-PREVIOUS, + return encode({'kappa':KAPPA,'kappa_decimal':'.00310440546','previous_open_pr5601':PREVIOUS,'gain':KAPPA-PREVIOUS, 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper], 'raw_headroom':[lower-KAPPA,upper-KAPPA], 'raw_ceiling':{'interval':[Q(0),cap],'derivative_upper':derivative_upper},'margin_at_previous':E.display(margin(PREVIOUS)), @@ -162,7 +166,7 @@ def wins(j): 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H), 'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False}, 'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes, - 'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':1, + 'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':local['peak_owned_fields'], 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.', 'local_paid_rank_mass':local['paid_rank_mass'], 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'}, diff --git a/research/p104-helper-subspace-splits/search.py b/research/p104-helper-subspace-splits/search.py index 1bf5329658..f3a214e479 100644 --- a/research/p104-helper-subspace-splits/search.py +++ b/research/p104-helper-subspace-splits/search.py @@ -56,8 +56,9 @@ def candidates(word, group, entry, exit_frame): if not valid: return [] public = word['public'] + owned = word.get('owned_fields', 8) snapshots, at = defaultdict(list), defaultdict(set) - rows = [{r:Q(1)} if r < public else {} for r in range(public+8)] + rows = [{r:Q(1)} if r < public else {} for r in range(public+owned)] for r,f in enumerate(word['initial']): at[f].add(r) for index,event in enumerate(word['program']): @@ -84,7 +85,7 @@ def candidates(word, group, entry, exit_frame): rows[r] = {k:v*Q(event[-2]) for k,v in rows[r].items()} else: add(rows[r], rows[event[2]], Q(event[-2])) - columns = [{r:Q(1)} if r < public else {} for r in range(public+8)] + columns = [{r:Q(1)} if r < public else {} for r in range(public+owned)] hits = [] for index in range(len(word['program'])-1, -1, -1): for frame,roles,prefix_basis in snapshots.get(index, []): diff --git a/research/p104-helper-subspace-splits/verify.py b/research/p104-helper-subspace-splits/verify.py index 547751915a..8c44fb5456 100644 --- a/research/p104-helper-subspace-splits/verify.py +++ b/research/p104-helper-subspace-splits/verify.py @@ -56,30 +56,53 @@ def run(): import construct as R import pricing as P C = L.load(ROOT/'research/p104-productive-controller/caller.py', 'subspace_p104_caller') - predecessor = L.replay(L.read(HERE/'inputs/PR5580-WORD.json.gz')) - source = L.read(HERE/'inputs/PR5565-WORD.json.gz') + predecessor_word = L.read(HERE/'inputs/PR5580-WORD.json.gz') + predecessor = L.replay(predecessor_word) + cascade = L.replay(L.read(HERE/'inputs/PR5565-WORD.json.gz')) + source = L.read(HERE/'inputs/PR5601-WORD.json.gz') witnesses = L.read(HERE/'SPLITS.json') - need(len(witnesses) == 13, 'Thirteen explicit independent splits') + need(len(witnesses) == 9, 'Nine explicit independent splits') baseline = L.replay(source) source_delta = {} - for name, expected in (('paid', {1:-8, 3:-1, 4:-2, 5:4}), - ('helpers', {8:-1, 9:1})): - delta = Counter(baseline[name]) - delta.subtract(predecessor[name]) - source_delta[name] = {r:n for r,n in delta.items() if n} - need(source_delta[name] == expected, 'Exact published PR5565 '+name+' change') - word, cuts = R.construct(source, witnesses) - local = L.replay(word) - need((local['public_inputs'], local['owned_lifetimes'], local['peak_owned_fields']) == (748, 8, 1), - 'Complete public and owned inventory') - need(local['helpers'] == {1:2, 2:5, 4:89, 5:11, 7:5, 8:16, 9:412}, 'Exact helper histogram') - delta = Counter(local['helpers']) + for label, before, after, expected in ( + ('PR5565', predecessor, cascade, + {'paid':{1:-8, 3:-1, 4:-2, 5:4}, 'helpers':{8:-1, 9:1}}), + ('PR5601', cascade, baseline, + {'paid':{2:-2, 3:2, 4:-2, 5:1}, 'helpers':{4:1, 5:-1}})): + source_delta[label] = {} + for name, profile in expected.items(): + delta = Counter(after[name]) + delta.subtract(before[name]) + source_delta[label][name] = {r:n for r,n in delta.items() if n} + need(source_delta[label][name] == profile, 'Exact published '+label+' '+name+' change') + source, relay_receipt = R.merge_relay(predecessor_word, source) + relay_local = L.replay(source) + relay_delta = Counter(relay_local['paid']) + relay_delta.subtract(baseline['paid']) + need({r:n for r,n in relay_delta.items() if n} == {1:-1,2:-1,3:-1,4:1,5:-1,7:1}, 'Exact combined relay paid delta') + need(relay_local['helpers'] == baseline['helpers'], 'The relay retains every independent target') + boundaries = L.read(HERE/'BOUNDARIES.json') + boundary_word, boundary_receipts = R.boundary_changes( + source, boundaries, L.read(HERE/'inputs/PR5602-WITNESS.json')) + baseline = L.replay(boundary_word) + split_word, cuts = R.construct(boundary_word, witnesses) + split_local = L.replay(split_word) + delta = Counter(split_local['helpers']) delta.subtract(baseline['helpers']) delta = {r:n for r,n in delta.items() if n} - need(delta == {1:2, 2:5, 4:6, 5:6, 7:5, 8:2, 9:-13}, 'All split credits and removed targets') - need(local['paid'] == baseline['paid'], 'Same complete local paid histogram') + need(delta == {1:2, 2:5, 4:2, 5:2, 7:5, 8:2, 9:-9}, 'All split credits and removed targets') + need(split_local['paid'] == baseline['paid'], 'Same paid histogram after independent splits') + preparation = L.read(HERE/'PREPARATION.json') + word, prepared_receipt = R.prepare_helper(split_word, preparation) + local = L.replay(word) + need((local['public_inputs'], local['owned_fields'], local['owned_lifetimes'], local['peak_owned_fields']) == (743,9,11,2), + 'Complete independent input, owned role, lifetime and peak counts') + need(local['helpers'] == {1:2,2:4,4:91,5:6,7:5,8:16,9:411}, 'Exact final helper histogram with H2 debited') + prepared_paid = Counter(split_local['paid']) + prepared_paid[1] -= 2 + need(local['paid'] == prepared_paid, 'Both replaced rank-one Gaussian calls are removed') columns = L.reverse_columns(word) - print('PASS 13 prefix/suffix cuts, every independent row and dense reverse columns', flush=True) + print('PASS shared and delayed relays, 5 boundaries, 9 splits, 2 prepared queries, all rows and columns', flush=True) native = L.native(word) controller = C.construct() need(controller == L.read(ROOT/'research/p104-productive-controller/CONTROLLER.json'), 'Same complete caller') @@ -90,28 +113,40 @@ def run(): bad = deepcopy(witnesses[0]) key = next(iter(bad['a'])) bad['a'][key] = str(L.Q(bad['a'][key])+1) - controls['contaminated_prefix'] = rejected(lambda: R.check_cut(source, bad)) + controls['contaminated_prefix'] = rejected(lambda: R.check_cut(boundary_word, bad)) bad = deepcopy(witnesses[0]) key = next(iter(bad['b'])) bad['b'][key] = str(L.Q(bad['b'][key])+1) - controls['contaminated_suffix'] = rejected(lambda: R.check_cut(source, bad)) + controls['contaminated_suffix'] = rejected(lambda: R.check_cut(boundary_word, bad)) + bad = deepcopy(boundaries) + bad[0]['witness']['cut'] += 1 + controls['wrong_boundary_event'] = rejected(lambda: R.boundary_changes( + source, bad, L.read(HERE/'inputs/PR5602-WITNESS.json'))) + bad = deepcopy(preparation) + bad['replacements'][0]['suppliers'][1][1] = '-1' + controls['false_preparation_identity'] = rejected(lambda: R.prepare_helper(split_word, bad)) bad = deepcopy(word) - bad['program'].pop(0) + bad['program'].pop(next(i for i,e in enumerate(bad['program']) if e[0] in ('ADD','SCALE'))) controls['missing_input_basis'] = rejected(lambda: L.replay(bad)) bad = deepcopy(word) - bad['program'].pop() + bad['program'].pop(max(i for i,e in enumerate(bad['program']) if e[0] in ('ADD','SCALE'))) controls['missing_output_basis'] = rejected(lambda: L.replay(bad)) bad = deepcopy(word) - bad['final'][648] = 127 + bad['final'][259] = 127 controls['unearned_whole_target'] = rejected(lambda: L.replay(bad)) bad = deepcopy(local) bad['helpers'][1] += 1 controls['extra_helper_credit'] = rejected(lambda: P.assemble(bad, native, controller, physical)) bad = deepcopy(local) + bad['helpers'][2] += 1 + controls['unremoved_prepared_target'] = rejected(lambda: P.assemble(bad, native, controller, physical)) + bad = deepcopy(local) bad['paid'][1] -= 1 controls['unpaid_gaussian'] = rejected(lambda: P.assemble(bad, native, controller, physical)) - result = {'status':'PASS_P104_HELPER_SUBSPACE_KAPPA_00310045', + result = {'status':'PASS_P104_HELPER_SUBSPACE_KAPPA_00310440546', 'authenticated_inputs':pins, 'splits':cuts, 'local_helper_delta':delta, + 'boundaries':boundary_receipts, + 'relay':relay_receipt, 'preparation':prepared_receipt, 'published_source_delta':source_delta, 'local':local, 'separate_columns':columns, 'native':native, 'physical_caller':physical, 'complete_cost':costs, 'negative_controls':controls,