diff --git a/research/p104-copy-block-composition/.gitattributes b/research/p104-copy-block-composition/.gitattributes new file mode 100644 index 0000000000..7467454cb8 --- /dev/null +++ b/research/p104-copy-block-composition/.gitattributes @@ -0,0 +1 @@ +source/** -text diff --git a/research/p104-copy-block-composition/COMPATIBILITY.json b/research/p104-copy-block-composition/COMPATIBILITY.json new file mode 100644 index 0000000000..4ad6dd403e --- /dev/null +++ b/research/p104-copy-block-composition/COMPATIBILITY.json @@ -0,0 +1,428 @@ +{ + "all_copy_events": [ + [ + "COPY", + 791, + 173, + "1", + 559 + ], + [ + "COPY", + 770, + 791, + "1", + 549 + ], + [ + "COPY", + 771, + 151, + "1", + 543 + ], + [ + "COPY", + 772, + 146, + "1", + 531 + ], + [ + "COPY", + 773, + 133, + "1", + 591 + ], + [ + "COPY", + 781, + 256, + "1", + 518 + ], + [ + "COPY", + 785, + 781, + "1", + 240 + ], + [ + "COPY", + 774, + 785, + "1", + 394 + ], + [ + "COPY", + 786, + 774, + "1", + 394 + ], + [ + "COPY", + 780, + 92, + "1", + 267 + ], + [ + "COPY", + 783, + 780, + "1", + 1091 + ], + [ + "COPY", + 775, + 783, + "1", + 260 + ], + [ + "COPY", + 784, + 775, + "1", + 260 + ], + [ + "COPY", + 782, + 9, + "1", + 517 + ], + [ + "COPY", + 787, + 782, + "1", + 243 + ], + [ + "COPY", + 776, + 787, + "1", + 431 + ], + [ + "COPY", + 788, + 776, + "1", + 431 + ], + [ + "COPY", + 779, + 240, + "1", + 477 + ], + [ + "COPY", + 789, + 779, + "1", + 1090 + ], + [ + "COPY", + 777, + 789, + "1", + 470 + ], + [ + "COPY", + 790, + 777, + "1", + 470 + ], + [ + "COPY", + 778, + 572, + "1", + 595 + ], + [ + "COPY", + 778, + 572, + "1", + 603 + ] + ], + "edits": [ + { + "edit": 0, + "fields": [ + 41, + 42, + 106, + 400, + 401, + 403, + 405, + 410, + 741 + ], + "matrix": [ + [ + "2", + "2", + "-2", + "1", + "1", + "1", + "1", + "-2", + "0" + ], + [ + "-2", + "-2", + "-2", + "1", + "-1", + "-1", + "1", + "-2", + "0" + ], + [ + "2", + "-2", + "-2", + "1", + "-1", + "1", + "-1", + "2", + "0" + ], + [ + "2", + "-2", + "-2", + "-1", + "1", + "-1", + "1", + "2", + "0" + ], + [ + "0", + "0", + "-2", + "1", + "0", + "1", + "0", + "-2", + "2" + ], + [ + "0", + "1", + "1", + "0", + "0", + "-1/2", + "0", + "-1", + "-1" + ], + [ + "0", + "0", + "1", + "0", + "0", + "-1/2", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "-1/2", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "2", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ] + ] + }, + { + "edit": 1, + "fields": [], + "matrix": [] + }, + { + "edit": 2, + "fields": [], + "matrix": [] + }, + { + "edit": 3, + "fields": [], + "matrix": [] + }, + { + "edit": 4, + "fields": [ + 65, + 240 + ], + "matrix": [ + [ + "1", + "0" + ], + [ + "1", + "1" + ] + ] + }, + { + "edit": 5, + "fields": [], + "matrix": [] + }, + { + "edit": 6, + "fields": [], + "matrix": [] + }, + { + "edit": 7, + "fields": [], + "matrix": [] + } + ], + "proof": "Disjoint equal R22 scalar transfers and no internal COPY preserve all external COPY values. The second block changes only scalar frames and preserves every scalar coefficient and order. Native frames and phases are checked by the complete verifier.", + "retained_copies": [ + [ + "COPY", + 791, + 173, + "1", + 559 + ], + [ + "COPY", + 781, + 256, + "1", + 518 + ], + [ + "COPY", + 785, + 781, + "1", + 240 + ], + [ + "COPY", + 786, + 774, + "1", + 394 + ], + [ + "COPY", + 780, + 92, + "1", + 267 + ], + [ + "COPY", + 783, + 780, + "1", + 1091 + ], + [ + "COPY", + 784, + 775, + "1", + 260 + ], + [ + "COPY", + 782, + 9, + "1", + 517 + ], + [ + "COPY", + 787, + 782, + "1", + 243 + ], + [ + "COPY", + 788, + 776, + "1", + 431 + ], + [ + "COPY", + 779, + 240, + "1", + 477 + ], + [ + "COPY", + 789, + 779, + "1", + 1090 + ], + [ + "COPY", + 790, + 777, + "1", + 470 + ] + ], + "second_block_contacts": 102, + "second_block_scalar_transfer_sha256": "edc0b6e91a17faad1b897b93e50bba1b4d71fb5b6ae48a1d63c10363a6a947e9", + "status": "PASS_R22_SCALAR_TRANSFERS_AND_ALL_13_COPY_VALUES", + "word_sha256": "8abcf56336a57c131427320e1ef9abecfb6da56e58ea8be6b050cc54ccbdfad6", + "wrong_scalar_coefficient_rejected": true +} diff --git a/research/p104-copy-block-composition/HUNKS.json b/research/p104-copy-block-composition/HUNKS.json new file mode 100644 index 0000000000..58ec88bf7d --- /dev/null +++ b/research/p104-copy-block-composition/HUNKS.json @@ -0,0 +1,453 @@ +{ + "R22": [ + { + "new_length": 109, + "new_sha256": "95524ed650a1d02ee91bb7cc3f2c2397013e3ac7eb14f30af1dff69a4ba4e817", + "old_length": 104, + "old_sha256": "07fafff4aa8ab73e21f94d16d5ead03436a1b7082724d4701e6ae57ed2708db8", + "source_index": 12294 + }, + { + "new_length": 0, + "new_sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "old_length": 1, + "old_sha256": "3b73f9dda1c5192e0119160f176c0726576179355f9212784384e1dffbba0ff1", + "source_index": 12891 + }, + { + "new_length": 0, + "new_sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "old_length": 1, + "old_sha256": "1e108b07bf83bcf8767f9c38aa7138a2bee915fda7102269ef848687dba4df23", + "source_index": 12904 + }, + { + "new_length": 0, + "new_sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "old_length": 1, + "old_sha256": "4057536a6573a8c742d64c13cf51c72880a268e79e647b4ed51ec893623da843", + "source_index": 12917 + }, + { + "new_length": 2, + "new_sha256": "dec7ae33bd16a7689d63603e99e1a6905ce8189ad8a0c90a51861e538149c6b8", + "old_length": 1, + "old_sha256": "f8b8cb5204d77ca92dd94b5aead7d152fb3f06c8dc32bc610a0e965c336cf9a5", + "source_index": 12929 + }, + { + "new_length": 1, + "new_sha256": "6a08793621bbb1365ce443626351a2f1c822f44d04b91d1f5610a542fef9311c", + "old_length": 2, + "old_sha256": "b52f1d67a86fe5b83eaf06dc62784c16345f8ff67eb548edbbb06352b877608d", + "source_index": 20916 + }, + { + "new_length": 0, + "new_sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "old_length": 1, + "old_sha256": "b2ee2d4096c2aa7d2c3b6afa1a598d8c03607a022a4a6f2a80f5de4be9a07d41", + "source_index": 20961 + }, + { + "new_length": 1, + "new_sha256": "ec9e9b74527a2f12f2b98335911b826d23454a63f2b5899d2108ac2750fea71d", + "old_length": 1, + "old_sha256": "7d52c5525a5f9b4c63d53acee91b7c969ff3deb3a8a563e0421477afccaddbb4", + "source_index": 22280 + } + ], + "second_block": { + "basis": [ + 11, + 21, + 38, + 448 + ], + "changed_scalar_source_indices": [ + 9932, + 9933, + 9934, + 9935, + 9936, + 9938, + 9940, + 9941, + 9943, + 9945, + 9947, + 9948, + 9949, + 9950, + 9952, + 9953, + 9954, + 9955, + 9956, + 9957, + 9958, + 9959, + 9960, + 9961, + 9962, + 9963, + 9964, + 9965, + 9966, + 9967, + 9968, + 9969, + 9970, + 9971, + 9972, + 9973, + 9974, + 9975, + 9976, + 9977, + 9978, + 9979, + 9980, + 9981, + 9982, + 9983, + 9984, + 9985, + 9986, + 9987, + 9988, + 9989, + 9990, + 9991, + 9992, + 9993, + 9994, + 9995, + 9996, + 9997, + 9998, + 9999, + 10000, + 10001, + 10002, + 10003, + 10004, + 10005, + 10006, + 10007, + 10008, + 10009, + 10010, + 10011, + 10012, + 10013, + 10014, + 10015, + 10016, + 10017, + 10018, + 10019, + 10020, + 10021, + 10022, + 10023, + 10024, + 10025, + 10026, + 10027, + 12842, + 12843, + 12844, + 12845, + 12846, + 12847, + 12848, + 12849, + 12850, + 12851, + 12852, + 12853 + ], + "native_changes": [ + { + "old": [ + "MOVE", + 57, + 266, + 267, + false + ], + "replacement": [ + "MOVE", + 57, + 266, + 1092, + false + ], + "source_index": 9930 + }, + { + "old": [ + "MOVE", + 92, + 265, + 267, + false + ], + "replacement": [ + "MOVE", + 92, + 265, + 1092, + false + ], + "source_index": 9931 + }, + { + "old": [ + "MOVE", + 224, + 260, + 267, + false + ], + "replacement": [ + "MOVE", + 224, + 260, + 1092, + false + ], + "source_index": 9937 + }, + { + "old": [ + "MOVE", + 225, + 262, + 267, + false + ], + "replacement": [ + "MOVE", + 225, + 262, + 1092, + false + ], + "source_index": 9939 + }, + { + "old": [ + "MOVE", + 81, + 264, + 267, + false + ], + "replacement": [ + "MOVE", + 81, + 264, + 1092, + false + ], + "source_index": 9942 + }, + { + "old": [ + "MOVE", + 227, + 261, + 267, + false + ], + "replacement": [ + "MOVE", + 227, + 261, + 1092, + false + ], + "source_index": 9944 + }, + { + "old": [ + "MOVE", + 229, + 259, + 267, + false + ], + "replacement": [ + "MOVE", + 229, + 259, + 1092, + false + ], + "source_index": 9946 + }, + { + "old": [ + "MOVE", + 234, + 263, + 267, + false + ], + "replacement": [ + "MOVE", + 234, + 263, + 1092, + false + ], + "source_index": 9951 + }, + { + "inserted": [ + "MOVE", + 92, + 1092, + 267, + false + ], + "source_index": 12855 + }, + { + "old": [ + "MOVE", + 57, + 267, + 127, + false + ], + "replacement": [ + "MOVE", + 57, + 1092, + 127, + false + ], + "source_index": 12866 + }, + { + "old": [ + "MOVE", + 81, + 267, + 127, + false + ], + "replacement": [ + "MOVE", + 81, + 1092, + 127, + false + ], + "source_index": 12887 + }, + { + "old": [ + "MOVE", + 224, + 267, + 127, + false + ], + "replacement": [ + "MOVE", + 224, + 1092, + 127, + false + ], + "source_index": 12899 + }, + { + "old": [ + "MOVE", + 227, + 267, + 127, + false + ], + "replacement": [ + "MOVE", + 227, + 1092, + 127, + false + ], + "source_index": 18112 + }, + { + "old": [ + "MOVE", + 229, + 267, + 127, + false + ], + "replacement": [ + "MOVE", + 229, + 1092, + 127, + false + ], + "source_index": 18113 + }, + { + "old": [ + "MOVE", + 742, + 267, + 127, + false + ], + "replacement": [ + "MOVE", + 742, + 1092, + 127, + false + ], + "source_index": 18434 + }, + { + "old": [ + "MOVE", + 234, + 267, + 127, + false + ], + "replacement": [ + "MOVE", + 234, + 1092, + 127, + false + ], + "source_index": 18435 + } + ], + "new_frame": 1092, + "roles": [ + 57, + 81, + 92, + 224, + 225, + 227, + 229, + 234, + 742 + ], + "scalar_transfer_sha256": "edc0b6e91a17faad1b897b93e50bba1b4d71fb5b6ae48a1d63c10363a6a947e9", + "source_head": "4b30391e633ba0c7c674f03586ae97d443e9bc9c" + } +} diff --git a/research/p104-copy-block-composition/NOTICE b/research/p104-copy-block-composition/NOTICE new file mode 100644 index 0000000000..8595c5cdf6 --- /dev/null +++ b/research/p104-copy-block-composition/NOTICE @@ -0,0 +1,9 @@ +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. diff --git a/research/p104-copy-block-composition/ORIGINAL-SOURCES.json b/research/p104-copy-block-composition/ORIGINAL-SOURCES.json new file mode 100644 index 0000000000..4e43a81c17 --- /dev/null +++ b/research/p104-copy-block-composition/ORIGINAL-SOURCES.json @@ -0,0 +1,16 @@ +[ + { + "path": "research/p104-block-reframe-r22/EDITS.json", + "local_path": "source/R22-EDITS.json", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/EDITS.json", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2" + }, + { + "path": "research/p104-block-reframe-r22/NOTICE", + "local_path": "source/R22-NOTICE", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/NOTICE", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0" + } +] diff --git a/research/p104-copy-block-composition/PRICING-EDITS.json b/research/p104-copy-block-composition/PRICING-EDITS.json new file mode 100644 index 0000000000..228f8c9f05 --- /dev/null +++ b/research/p104-copy-block-composition/PRICING-EDITS.json @@ -0,0 +1,18 @@ +[ + [ + "Q('.00312265044'), Q('.003122650445')", + "Q('0.00312289583377'), Q('0.00312289583877')" + ], + [ + "PREVIOUS = Q('.00312192127')", + "PREVIOUS = Q('.00312265044')" + ], + [ + "'kappa_decimal':'0.00312265044','previous_pr5774'", + "'kappa_decimal':'0.00312289583377','previous_pr5786'" + ], + [ + "sum(paid.values()) == 66906", + "sum(paid.values()) == 66942" + ] +] diff --git a/research/p104-copy-block-composition/README.md b/research/p104-copy-block-composition/README.md new file mode 100644 index 0000000000..4b8e21240f --- /dev/null +++ b/research/p104-copy-block-composition/README.md @@ -0,0 +1,121 @@ +# Complete hubs, retained copies and two-block composition + +The released PR5786 asynchronous hubs and PR5774 retained native copies compose +with the original R22 block and the second block in PR5796. The complete +conditional saving is **kappa .00312289583377**, an increase of +**.00000024539377** over PR5786's .00312265044. This is a small complete gain. +The selected frontier is unchanged and all five framework assumptions remain. +No large uniform word or rounded multiplier is materialized. + +The first published checkpoint of this same package, PR5795 at +582c6334f474b5ea576b518a9497ae9961c620ac, had kappa .00312277313. PR5796 released +the requested second block afterward. This update includes it in the same PR; +it is not counted as an additional contribution. Both block mechanisms, the +thirteen retained copies and three asynchronous hubs retain their source credit. + +## Exact joins and copy values + +The immediate source is PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +It retains PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. The original R22 +edits are PR5739 at b93d749a0a895d260e87887170af5162bda461a4. All eight literal +R22 runs occur exactly once and do not overlap. Helpers 741 and 405 have their +expected chart-477 endpoints. Existing chart 1090 has exactly the required +basis [265,194,164,75]. Its equality is checked before reuse. + +The second block is PR5796 at 4b30391e633ba0c7c674f03586ae97d443e9bc9c. Both +released scalar runs match exactly: 90 and 12 operations on roles +57,81,92,224,225,227,229,234,742. They move from chart 267 to basis +[11,21,38,448]. Helper 742 starts there and helper 225 ends there. A new chart +1092 preserves every existing chart, including a different basis at 1091. + +The second source constructor rebuilds all native paths. This composition +instead binds its exact scalar plan and changes only the adjacent native +edges that must meet those changed contacts or final boundaries. Earlier edges +of a query chain retain their destination and order. A missing boundary edge +is inserted, and an identity edge is removed. HUNKS.json records all 16 native +edits on the nine affected roles. Every unrelated native query stays in order. +All 102 scalar coefficients and their order remain unchanged. This avoids +transferring unrelated source rewrites into the retained-copy/hub word. + +Some scalar operations inside the original R22 block are reordered. +compatibility.py computes the exact rational transfer of each old/new R22 edit. +The matrices agree: the largest is 9-by-9, the other scalar matrix is 2-by-2, +and the remaining edits contain only native moves. No R22 edit contains a +COPY, INIT or CLEAR. The second block changes only scalar frames, so its +logical transfer and order are identical. These two facts preserve the logical +state at every external COPY for arbitrary inputs. All 23 COPY events remain +byte-equal, including the thirteen retained native copies. Native validity and +absolute phases are checked separately by the full replay. + +## Complete changed invoice and fixed-contract optimum + +The word has 770 arbitrary public inputs and 25 owned labels, for 795 columns. +It retains 27 owned lifetimes, peak 13 live owned fields and scalar allowance +224990. The local profiles are: + +| Kind | Exact profile | +| --- | --- | +| Paid | 2237 H1 + 452 H2 + 498 H3 + 100 H4 + 157 H5 + 7 H6 + 8 H7 | +| Helpers | 24 H1 + 5 H2 + 4 H3 + 107 H4 + 10 H5 + 7 H7 + 20 H8 + 385 H9 | + +Relative to PR5786, the paid change is `2H1+2H4-2H5`, and the productive +change is `-2H1+2H4+2H5-2H8`. The complete caller has 18 local invocations, +15 query shears, 3120 whole idle jobs, **13444 productive fields and 66942 paid +calls**. Rank-mass surplus is 760. Every copy, query, adapter, normalizer, owned +lifetime, scalar operation, route and idle stays charged. The price source has +only four explicit literal changes, authenticated by PRICING-EDITS.json. + +Both rational moment engines pass. The raw crossing is strictly inside +`(.00312289583975,.00312289583976)`. The claim leaves between 5.98e-12 and +5.99e-12 below that ceiling. The tested saving is .00312289583877. Completion +16/17, offset 1/7, decay 125/128, the finite compiler, 54 strict outer rows and +four functional conditions pass. The complete invoices are compared; source +kappa values are not added together. + +The fixed reserve is 1e-12 and the tested-to-published gap is 5e-12. On a 1e-14 +grid, .00312289583877 is the largest tested saving under that contract. +The next tested point, .00312289583878, fails the reserve. Exact intervals +certify both signs. A negative derivative bound for +`(1-reserve)*target_moment - paid_moment` throughout [0,.0034] excludes every +larger grid point in the retained BIT range. Thus .00312289583377 is the largest +published grid point with this fixed bill, reserve and gap. Different compiler +parameters, words or BIT caps remain outside this optimum. + +PR5772 supplies the original fixed R22 canonical-chart optimum. It does not +prove a global optimum over joint block, retained-copy or asynchronous contracts. +The active forward/nonnested-copy and whole-target temporal-cut searches remain +separate. A new compatible released artifact needs a fresh scope check and full +replay. PR5800's independent first-hub audit is complementary evidence, not +admission of the later hubs or this entire composition. + +## Verification and provenance + +Run `python3.12 -B scripts/research_package.py --package +research/p104-copy-block-composition`. The package registers normal and optimized +full replay and compatibility checks. The full replay checks all 632025 scalar +coefficients, separate transpose columns, 2926 distinct native maps and absolute +phases, 208 main adapters, 1124 helper normalizers and the complete physical +caller. Twelve changed-word/caller/invoice controls and the native phase control +reject. Nine actual frozen-source corruptions reject before imports. +VALIDATION.md states the exact registered, committed and export checks. + +The complete 19-file PR5786 export and all nested source manifests are checked +before import. The second plan, both source words, constructor, proof and notice +are frozen byte-exact. Original source heads, Git blobs and SHA256 hashes remain +in SOURCES.json, with copies retained in this branch's own history. Clean replay +needs no unmerged source branch or network. Full-history ancestry checking is +unavailable in the shallow checkout. Hosted CI and independent scientific +acceptance are separate from author checks. + +## Open next questions + +1. Can a changed source or caller contract improve the complete signed moment + beyond both released blocks? Check live claims and pay every new boundary. +2. Can an independent reviewer accept the native paths, copy lifetimes, both + block interfaces, complete invoice and inherited assumptions? + +Ali Romman with substantial OpenAI Codex assistance; no subagents. Apache-2.0. +Credit Joel Pulikkan/GamingPuzzled PR5739/5756, the second-block author PR5796, +PR5786/5774/5751, flyingviper PR5718, Cinna Davis, Jacob Alan Sussman, zxv, +Cao Yifan and every retained P104/native/BIT predecessor in NOTICE. No merge, +closure or selected-frontier change is performed. diff --git a/research/p104-copy-block-composition/RESULT.json b/research/p104-copy-block-composition/RESULT.json new file mode 100644 index 0000000000..b62ff80f7d --- /dev/null +++ b/research/p104-copy-block-composition/RESULT.json @@ -0,0 +1,407 @@ +{ + "canonical_word_sha256": "8abcf56336a57c131427320e1ef9abecfb6da56e58ea8be6b050cc54ccbdfad6", + "complete_cost": { + "compiler": { + "H": 80511200000000000, + "N": "2^80511200000000000", + "eta": { + "lower": "0.000000122157751376846755107871", + "upper": "0.000000122157751376846755107872" + }, + "gap": "1/1400000000000", + "integer_test_exponent": 57508, + "logarithm_power": 1024, + "theta": "63/64", + "uniform_saving": "2186027086639/700000000000000", + "word_materialized": false + }, + "full_forward_calls": 18, + "gain": "24539377/100000000000000", + "kappa": "312289583377/100000000000000", + "kappa_decimal": "0.00312289583377", + "margin_at_previous": { + "lower": "0.059322931952150954993250308954", + "upper": "0.059322931952150954993250308955" + }, + "negative_controls": { + "old_BIT": "Rejected by outer inequalities", + "old_cutoff": "Rejected by completion-tail ratio greater than one", + "source_completion": "Rejected at cutoff17, floor18 and decay39/40", + "source_offset": "Rejected at cutoff16 with tail offset1/5" + }, + "nonrecursive": { + "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.", + "local_paid_rank_mass": 5918, + "local_routes": 5315000, + "local_scalar": 224990, + "peak_owned_fields": 13, + "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." + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "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": "3060437919892413972914861/980000000000000000000000000", + "fused_gaussian": "3060437919888041918744583/980000000000000000000000000", + "global_coordinate_router": "2186027085639/700000000000000", + "group_bit_router": "3060437920588041918743083/980000000000000000000000000", + "group_scans": "699999999999/700000000000", + "main_transform": "3060437919192413972914861/980000000000000000000000000", + "microbox_face_corrections": "26950000000001/350000000000", + "polynomial_products": "1399999999999/1400000000000", + "sparse_union_movement": "401185437919892413972914861/980000000000000000000000000" + }, + "parameters": { + "a": "2186027085639/700000000000000", + "b": "2186027086139/700000000000000", + "beta": "1399999999997/1400000000000", + "bit_saving": "17/5000", + "cap_xi": "891185437919192413972914861/980000000000000000000000000", + "complex_uniform_saving": "2186027086639/700000000000000", + "d": "1/1400000000000", + "epsilon": "1399999999999/1400000000000", + "kappa": "312289583377/100000000000000", + "lambda_": "99687710416373/100000000000000", + "lambda_prime": "697813972914861/700000000000000", + "layout": "1/1400000000000", + "q": "2186027085139/700000000000000", + "r0": "1/14000000000000", + "stop": "1/1400000000000", + "tested_saving": "312289583877/100000000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "193972914361/700000000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000", + "actual_logarithmic_group_guard": "88814562081857586027085139/490000000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000", + "boundary_algebraic_matrix_above_kappa": "2797813972914861/980000000000000000000000000", + "cap_above_band": "401185437919192413972914861/980000000000000000000000000", + "cap_below_cell": "88814562080107586027085139/980000000000000000000000000", + "cap_below_phase_cell_power": "1068814562080807586027085139/980000000000000000000000000", + "complex_above_effective": "1/1400000000000", + "complex_below_one_over_32": "19688972913861/700000000000000", + "complex_endpoint": "1/700000000000", + "epsilon_below_one": "1/1400000000000", + "epsilon_positive": "1399999999999/1400000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "2793441918744583/980000000000000000000000000", + "gaussian_above_main": "347813972914861/490000000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000", + "global_gamma_power_slack": "9/14000000000000", + "group_below_dimension": "1/700000000000", + "group_bit_router_above_kappa": "3493441918743083/980000000000000000000000000", + "group_gauge_power_slack": "88814562081822586027085139/490000000000000000000000000", + "group_key_fits_record": "1/700000000000", + "group_positive": "1399999999997/1400000000000", + "group_scans_above_kappa": "697813972915361/700000000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "695962707285418148631/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": "1397813972913861/980000000000000000000000000", + "leaf_saving_above_effective": "697813972913861/980000000000000000000000000", + "main_transform_above_kappa": "2097813972914861/980000000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000", + "microbox_face_corrections_above_kappa": "53897813972918361/700000000000000", + "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": "697813972915861/700000000000000", + "positive_layout_slack": "1/1400000000000", + "q_below_effective": "1/1400000000000", + "q_below_internal": "1/1400000000000", + "q_below_leaf": "1397813972913861/980000000000000000000000000", + "q_positive": "2186027085139/700000000000000", + "short_record_fallback": "697813972913861/700000000000000", + "source_axis_superpolynomial": "1/1400000000000", + "sparse_union_movement_above_kappa": "398125000002797813972914861/980000000000000000000000000", + "stop_below_one": "1399999999999/1400000000000", + "stop_positive": "1/1400000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000" + } + }, + "paid": { + "1": 41826, + "16": 416, + "2": 8136, + "24": 416, + "3": 8964, + "32": 416, + "4": 1800, + "40": 416, + "48": 416, + "5": 2826, + "56": 416, + "6": 126, + "64": 416, + "7": 144, + "72": 208 + }, + "paid_calls": 66942, + "previous_pr5786": "78066261/25000000000", + "productive_fields": 13444, + "query_shears": 15, + "rank_mass_surplus": 760, + "raw_ceiling": { + "derivative_upper": "-736326727887036550899906945108199168313980781105248689549538091/3138550867693340381917894711603833208051177722232017256448", + "interval": [ + "0", + "17/5000" + ] + }, + "raw_headroom": [ + "299/50000000000000", + "599/100000000000000" + ], + "raw_root_interval": [ + "12491583359/4000000000000", + "39036197997/12500000000000" + ], + "relative_gain_percent": "24539377/3122650440", + "strictification": { + "alpha": { + "lower": "0.999999999998999448926125827795", + "upper": "0.999999999998999448926125827796" + }, + "cutoff": 16, + "delta": { + "lower": "0.953058648967453908262482127906", + "upper": "0.953058648967453908262482127907" + }, + "floor": 17, + "gamma": { + "lower": "0.975674725092814328686215830022", + "upper": "0.975674725092814328686215830023" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "125/128", + "tail_offset": "1/7", + "tested": "312289583877/100000000000000" + }, + "targets": { + "1": 432, + "145": 208, + "17": 416, + "2": 90, + "25": 416, + "3": 72, + "33": 416, + "4": 1926, + "41": 416, + "49": 416, + "5": 180, + "57": 416, + "65": 416, + "7": 126, + "73": 208, + "8": 360, + "9": 6930 + }, + "whole_idle_jobs": 3120 + }, + "delta": { + "paid": { + "1": 2, + "4": 2, + "5": -2 + }, + "targets": { + "1": -2, + "4": 2, + "5": 2, + "8": -2 + } + }, + "fixed_contract_grid_optimum": { + "accepted_margin": [ + "10279605771440686187010491858134281322330850975616152400267/78463771692333509547947367790095830201279443055800431411200000000000", + "205592115428813723740209837162685626446671380434823015689987/1569275433846670190958947355801916604025588861116008628224000000000000" + ], + "cap": "17/5000", + "derivative_upper": "-368163363942239358572386384911715142113789598010819813436313769419973819361/1569275433846670190958947355801916604025588861116008628224000000000000", + "grid": "1/100000000000000", + "largest_published_grid": "312289583377/100000000000000", + "largest_tested_grid": "312289583877/100000000000000", + "next_tested_grid": "156144791939/50000000000000", + "rejected_margin": [ + "-358797203217612551430642127181895118833985159382146619381767/156927543384667019095894735580191660402558886111600862822400000000000", + "-7175944064352251028612842543637902376679594478077932452265351/3138550867693340381917894711603833208051177722232017256448000000000000" + ], + "reserve": "1/1000000000000", + "scope": "Maximum on the 1e-14 grid for this exact profile, fixed reserve and tested gap. Different compiler parameters, words and BIT caps remain outside this claim.", + "tested_gap": "1/200000000000" + }, + "instructions": 25975, + "limits": [ + "Five inherited framework assumptions remain.", + "Independent scientific acceptance is pending.", + "The large uniform word and rounded multiplier are not materialized.", + "The selected frontier is unchanged." + ], + "local": { + "endpoint_coefficients": 632025, + "helpers": { + "1": 24, + "2": 5, + "3": 4, + "4": 107, + "5": 10, + "7": 7, + "8": 20, + "9": 385 + }, + "owned_fields": 25, + "owned_lifetimes": 27, + "paid": { + "1": 2237, + "2": 452, + "3": 498, + "4": 100, + "5": 157, + "6": 7, + "7": 8 + }, + "paid_rank_mass": 5918, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 224990 + }, + "native": { + "distinct_maps": 2926, + "helper_normalizers": 1124, + "helpers": { + "1": 24, + "2": 5, + "3": 4, + "4": 107, + "5": 10, + "7": 7, + "8": 20, + "9": 385 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "f36bcdfd8970dcde8eacc9a6a7e1044d3395085ddd6cf279d4cc99f2dc3fc878", + "wrong_phase_rejected": true + }, + "negative_controls": { + "missing_central_translation": "Rejected by the complete Laurent endpoint", + "omit_R22_input_endpoint": "Scalar destination and coefficient", + "omit_copy_clear": "All public and owned exits", + "omit_paid_R22_query": "Common scalar chart", + "omit_paid_copy_query": "Common scalar chart", + "omit_query_from_invoice": "Complete field and call counts", + "omit_second_block_input": "Scalar destination and coefficient", + "omit_second_block_output": "All public and owned exits", + "omit_second_block_query": "Scalar destination and coefficient", + "retain_obsolete_helper_credit": "Every productive helper has a native target", + "retain_old_R22_target": "All public and owned exits", + "wrong_copy_value": "All public and owned rows" + }, + "physical_caller": { + "central_square_columns": 53248, + "full_calls": 18, + "main_targets": { + "145": 208, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 416, + "72": 208 + }, + "wrapper_sites": [ + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31 + ] + }, + "separate_columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 632025, + "columns": 795 + }, + "source_commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25", + "source_local": { + "endpoint_coefficients": 632025, + "helpers": { + "1": 26, + "2": 5, + "3": 4, + "4": 105, + "5": 8, + "7": 7, + "8": 22, + "9": 385 + }, + "owned_fields": 25, + "owned_lifetimes": 27, + "paid": { + "1": 2235, + "2": 452, + "3": 498, + "4": 98, + "5": 159, + "6": 7, + "7": 8 + }, + "paid_rank_mass": 5918, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 224990 + }, + "status": "PASS_P104_COMPOSED_BLOCKS_KAPPA_00312289583377" +} diff --git a/research/p104-copy-block-composition/SOURCE-CONTROLS.json b/research/p104-copy-block-composition/SOURCE-CONTROLS.json new file mode 100644 index 0000000000..73bd89eb95 --- /dev/null +++ b/research/p104-copy-block-composition/SOURCE-CONTROLS.json @@ -0,0 +1,38 @@ +[ + { + "path": "source/R22-EDITS.json", + "middle_byte_xor1_rejected": true + }, + { + "path": "source/R22-NOTICE", + "middle_byte_xor1_rejected": true + }, + { + "path": "source/SECOND-PLAN.json", + "middle_byte_xor1_rejected": true + }, + { + "path": "source/SECOND-NOTICE", + "middle_byte_xor1_rejected": true + }, + { + "path": "source/SECOND-PROOF.md", + "middle_byte_xor1_rejected": true + }, + { + "path": "source/SECOND-WORD.json.gz", + "middle_byte_xor1_rejected": true + }, + { + "path": "source/SECOND-OLD-WORD.json.gz", + "middle_byte_xor1_rejected": true + }, + { + "path": "source/SECOND-CONSTRUCT.py", + "middle_byte_xor1_rejected": true + }, + { + "path": "source/pr5786-export.tar", + "middle_byte_xor1_rejected": true + } +] diff --git a/research/p104-copy-block-composition/SOURCES.json b/research/p104-copy-block-composition/SOURCES.json new file mode 100644 index 0000000000..8c50973cd5 --- /dev/null +++ b/research/p104-copy-block-composition/SOURCES.json @@ -0,0 +1,565 @@ +{ + "schema_version": 1, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/p104-copy-block-composition/source/R22-EDITS.json", + "usage": "provenance", + "pin": "head:388b5216712d72f29ebad4d26756fe8fe441f66c:research/p104-copy-block-composition/source/R22-EDITS.json", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea" + }, + { + "path": "research/p104-copy-block-composition/source/R22-NOTICE", + "usage": "provenance", + "pin": "head:388b5216712d72f29ebad4d26756fe8fe441f66c:research/p104-copy-block-composition/source/R22-NOTICE", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077" + }, + { + "path": "research/p104-copy-block-composition/source/pr5774-export.tar", + "usage": "provenance", + "pin": "head:388b5216712d72f29ebad4d26756fe8fe441f66c:research/p104-copy-block-composition/source/pr5774-export.tar", + "git_blob": "f34972476e76121c7cbb0e86478eaa86969c6efd", + "sha256": "e47cd61d6542497287f5a69820484e92f7116aaf76663969fe59a1d85fffe497" + }, + { + "path": "research/p104-copy-block-composition/source/pr5786-export.tar", + "usage": "provenance", + "pin": "head:d39791e4d177aec7d194e737c7d6b2fee7786222:research/p104-copy-block-composition/source/pr5786-export.tar", + "git_blob": "450c1490f3641025665dfd1e43d0ed066880ed00", + "sha256": "9c788f45c96fa6d593a82df13f809ef72016fa5d60109627c037c8641f2bf8a0" + }, + { + "path": "research/p104-copy-block-composition/source/SECOND-PLAN.json", + "usage": "provenance", + "pin": "head:59e96b277c628027079bc7a712d60fcf86fd187b:research/p104-copy-block-composition/source/SECOND-PLAN.json", + "git_blob": "47fa8c405314f1511b50dbf3722509e5dcb1357b", + "sha256": "de9c6609f1d10f24943488d6f7c2a395257ec63ee66e7d5f79f74a8aa2598c8d" + }, + { + "path": "research/p104-copy-block-composition/source/SECOND-NOTICE", + "usage": "provenance", + "pin": "head:59e96b277c628027079bc7a712d60fcf86fd187b:research/p104-copy-block-composition/source/SECOND-NOTICE", + "git_blob": "d07f993ba2fd88a8768e02159553402ee630636c", + "sha256": "8191af71810fc3314dc526cebfd70d4af56e022ecbcd5a24a2ffa0c95785c3fe" + }, + { + "path": "research/p104-copy-block-composition/source/SECOND-PROOF.md", + "usage": "provenance", + "pin": "head:59e96b277c628027079bc7a712d60fcf86fd187b:research/p104-copy-block-composition/source/SECOND-PROOF.md", + "git_blob": "d8daa51f7d493f4c7769ee482c3eab7733a1204d", + "sha256": "6c9962b6a54e2fed94912cc7e18eb5a0f35b2e67f98c667e2285affb0714cc0d" + }, + { + "path": "research/p104-copy-block-composition/source/SECOND-WORD.json.gz", + "usage": "provenance", + "pin": "head:59e96b277c628027079bc7a712d60fcf86fd187b:research/p104-copy-block-composition/source/SECOND-WORD.json.gz", + "git_blob": "b2e351e1abe29954a11f77d30218c7b55b0a4a83", + "sha256": "7c68c9ef9f17e3a67c5c9794a097a183ae469dd2c81cb0b3a59f102077d8c591" + }, + { + "path": "research/p104-copy-block-composition/source/SECOND-OLD-WORD.json.gz", + "usage": "provenance", + "pin": "head:59e96b277c628027079bc7a712d60fcf86fd187b:research/p104-copy-block-composition/source/SECOND-OLD-WORD.json.gz", + "git_blob": "156ff6d62780383467d195dce3728b7a434190b1", + "sha256": "a767dc298dee729d73389cd9240922e28024452d76442931396fb8307763752c" + }, + { + "path": "research/p104-copy-block-composition/source/SECOND-CONSTRUCT.py", + "usage": "provenance", + "pin": "head:59e96b277c628027079bc7a712d60fcf86fd187b:research/p104-copy-block-composition/source/SECOND-CONSTRUCT.py", + "git_blob": "a27613d278dc2a6b94ef258eb24b025a7c55d740", + "sha256": "d1011ed72b8c43498b4670f874af77c88e0b7ee547d8cb8c1189d90e484f5bcd" + } + ], + "direct_sources": [ + { + "path": "research/p104-block-reframe-r22/EDITS.json", + "local_path": "source/R22-EDITS.json", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/EDITS.json", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2" + }, + { + "path": "research/p104-block-reframe-r22/NOTICE", + "local_path": "source/R22-NOTICE", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/NOTICE", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0" + }, + { + "local_path": "source/SECOND-PLAN.json", + "commit": "4b30391e633ba0c7c674f03586ae97d443e9bc9c", + "path": "research/p104-second-low-rank-block/PLAN.json", + "sha256": "de9c6609f1d10f24943488d6f7c2a395257ec63ee66e7d5f79f74a8aa2598c8d", + "git_blob": "47fa8c405314f1511b50dbf3722509e5dcb1357b" + }, + { + "local_path": "source/SECOND-NOTICE", + "commit": "4b30391e633ba0c7c674f03586ae97d443e9bc9c", + "path": "research/p104-second-low-rank-block/NOTICE", + "sha256": "8191af71810fc3314dc526cebfd70d4af56e022ecbcd5a24a2ffa0c95785c3fe", + "git_blob": "d07f993ba2fd88a8768e02159553402ee630636c" + }, + { + "local_path": "source/SECOND-PROOF.md", + "commit": "4b30391e633ba0c7c674f03586ae97d443e9bc9c", + "path": "research/p104-second-low-rank-block/PROOF.md", + "sha256": "6c9962b6a54e2fed94912cc7e18eb5a0f35b2e67f98c667e2285affb0714cc0d", + "git_blob": "d8daa51f7d493f4c7769ee482c3eab7733a1204d" + }, + { + "local_path": "source/SECOND-WORD.json.gz", + "commit": "4b30391e633ba0c7c674f03586ae97d443e9bc9c", + "path": "research/p104-second-low-rank-block/WORD.json.gz", + "sha256": "7c68c9ef9f17e3a67c5c9794a097a183ae469dd2c81cb0b3a59f102077d8c591", + "git_blob": "b2e351e1abe29954a11f77d30218c7b55b0a4a83" + }, + { + "local_path": "source/SECOND-OLD-WORD.json.gz", + "commit": "4b30391e633ba0c7c674f03586ae97d443e9bc9c", + "path": "research/p104-second-low-rank-block/inputs/pr5756-WORD.json.gz", + "sha256": "a767dc298dee729d73389cd9240922e28024452d76442931396fb8307763752c", + "git_blob": "156ff6d62780383467d195dce3728b7a434190b1" + }, + { + "local_path": "source/SECOND-CONSTRUCT.py", + "commit": "4b30391e633ba0c7c674f03586ae97d443e9bc9c", + "path": "research/p104-second-low-rank-block/construct.py", + "sha256": "d1011ed72b8c43498b4670f874af77c88e0b7ee547d8cb8c1189d90e484f5bcd", + "git_blob": "a27613d278dc2a6b94ef258eb24b025a7c55d740" + } + ], + "archived_files": [ + { + "path": "research/p104-asynchronous-helper-hubs/LOCAL-EDITS.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/LOCAL-EDITS.json", + "sha256": "1118183d04913fd5c525a7aa85d727b6d9d36992b9d8490c5a866434b2754cec" + }, + { + "path": "research/p104-asynchronous-helper-hubs/NOTICE", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/NOTICE", + "sha256": "2feedebb4a059025670699f807baa90818f0088267e8549f773de3e0ea296158" + }, + { + "path": "research/p104-asynchronous-helper-hubs/PLAN.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/PLAN.json", + "sha256": "2c4878f78dc393339f8cccf24441d9bfb50257784459c2f253ebcb27c964211c" + }, + { + "path": "research/p104-asynchronous-helper-hubs/PRICING-EDITS.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/PRICING-EDITS.json", + "sha256": "25efa817a0474631afc3a1c09611cf50ca30314e66901f1dff802946915a04fa" + }, + { + "path": "research/p104-asynchronous-helper-hubs/PROOF.md", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/PROOF.md", + "sha256": "0a2b7c13fadecf18a33320eb6b159757e5516e5e9c7b52a03db2e9f32f25f36a" + }, + { + "path": "research/p104-asynchronous-helper-hubs/README.md", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/README.md", + "sha256": "742fd06e72b1f977ab9bb5e9ac0dfafc87cbc343a2e0f1c86e4eb77509e4746e" + }, + { + "path": "research/p104-asynchronous-helper-hubs/RESULT.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/RESULT.json", + "sha256": "eabb5f4ece0a4fc3ada4ea1796dc413eddb0683541fe03dd48f0f53cba1e2ea6" + }, + { + "path": "research/p104-asynchronous-helper-hubs/SOURCES.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/SOURCES.json", + "sha256": "3a70129e30648c647401ac1ce269bc65792f0f7d6b5649313ea78d20625b62ae" + }, + { + "path": "research/p104-asynchronous-helper-hubs/TASK.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/TASK.json", + "sha256": "040a7af88daac30d5beca4f7db7410e5f987d46742828ba41fd42882081c6f72" + }, + { + "path": "research/p104-asynchronous-helper-hubs/VALIDATION.md", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/VALIDATION.md", + "sha256": "685af1e45b1a19c7bb6189321b290a49a183a4d4b8c53904319366fdc9aa5570" + }, + { + "path": "research/p104-asynchronous-helper-hubs/VERIFY.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/VERIFY.json", + "sha256": "eee6981e3c3243dd69d19c68042e6087dc97780016a6aa56a74fb438af1f9fd5" + }, + { + "path": "research/p104-asynchronous-helper-hubs/WITNESS.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/WITNESS.json", + "sha256": "351a08afe2d427a552ed3d758f20f12429f8f4a4ca65fd2eacbe6d07a1a4cf5f" + }, + { + "path": "research/p104-asynchronous-helper-hubs/WORD.json.gz", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/WORD.json.gz", + "sha256": "35fbd3049ab7a731ed245944257e8fdad1eaa4c3baca71761bca7bf5f95f1243" + }, + { + "path": "research/p104-asynchronous-helper-hubs/construct.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/construct.py", + "sha256": "c1ded96afc454aa7f94d99f2a08c57f4eac731bc931ca034ec3b0040e1776fa7" + }, + { + "path": "research/p104-asynchronous-helper-hubs/inputs/pr5774-source.tar", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/inputs/pr5774-source.tar", + "sha256": "e47cd61d6542497287f5a69820484e92f7116aaf76663969fe59a1d85fffe497" + }, + { + "path": "research/p104-asynchronous-helper-hubs/local.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/local.py", + "sha256": "4d6db6dae893fc4e7e31148d2a8144d7a1a2afbba4b48f4532b0a1f1a9804f9e" + }, + { + "path": "research/p104-asynchronous-helper-hubs/pricing.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/pricing.py", + "sha256": "55fe9194ed9de830623f69472be808a043f129cedd2ba0c97ec49f6ae41df2a1" + }, + { + "path": "research/p104-asynchronous-helper-hubs/sources.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/sources.py", + "sha256": "fee3e7fd1c1aa4980b593b22de2d55a3e66f8dc8c7e7f5735f45bd67491768b0" + }, + { + "path": "research/p104-asynchronous-helper-hubs/verify.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/verify.py", + "sha256": "520176dd2663695b7da89e67a007de50052244650bf462dc2fe08ed85d4e63b2" + } + ], + "source_export": { + "local_path": "source/pr5786-export.tar", + "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25", + "package": "research/p104-asynchronous-helper-hubs", + "files": 19, + "sha256": "9c788f45c96fa6d593a82df13f809ef72016fa5d60109627c037c8641f2bf8a0", + "git_blob": "450c1490f3641025665dfd1e43d0ed066880ed00" + }, + "original_git_sources": [ + { + "path": "research/p104-block-reframe-r22/EDITS.json", + "local_path": "source/R22-EDITS.json", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/EDITS.json", + "sha256": "1545d726fed269dd7d6fa59ff6744211a105aff5be99c5acf6b0e72c4977b3ea", + "git_blob": "54f7b233d7bf97df2ac8a6167348db0f04ad0ab2" + }, + { + "path": "research/p104-block-reframe-r22/NOTICE", + "local_path": "source/R22-NOTICE", + "pin": "head:b93d749a0a895d260e87887170af5162bda461a4:research/p104-block-reframe-r22/NOTICE", + "sha256": "a252225cb4d9c61fc94b5b7f638600393a859e47750cfea7688c75b1f6610077", + "git_blob": "36c1b859be8f5c1325811e633ac51149e1cd7bc0" + }, + { + "path": "research/p104-retained-native-copy/LOCAL-EDITS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/LOCAL-EDITS.json", + "sha256": "9ef49a2f123519c7c2b750ca6afdbe6dc1a9e99f29aff81bfcb593d758714388" + }, + { + "path": "research/p104-retained-native-copy/NOTICE", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/NOTICE", + "sha256": "eccf96753b037fd1f9037487d9a77c62abf117100c24a28a5d0b25d9e1f25176" + }, + { + "path": "research/p104-retained-native-copy/PLAN.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PLAN.json", + "sha256": "1476064d57afcabfd43deb0b2b61ce30bb89b603df72645f60dacf00b72fcdbe" + }, + { + "path": "research/p104-retained-native-copy/PRICING-EDITS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PRICING-EDITS.json", + "sha256": "ea4f275bc47ed3c1e54c598ad1ed2e0d6b3260c444f5a142238c6b88a4700acb" + }, + { + "path": "research/p104-retained-native-copy/PROOF.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PROOF.md", + "sha256": "f7af2ed85c8ce88bc4707a4171503108c4d7083c165fe5929108bf976baaa446" + }, + { + "path": "research/p104-retained-native-copy/README.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/README.md", + "sha256": "1626aadf77c59ba511b6c39bf27f31f78567d6d2ba9c62e04c8f995ba1c73515" + }, + { + "path": "research/p104-retained-native-copy/RESULT.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/RESULT.json", + "sha256": "a47576bd8f65fb2e4bb250043ccf209d880a704ca3c80c0ff45c0255b3959761" + }, + { + "path": "research/p104-retained-native-copy/SOURCES.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/SOURCES.json", + "sha256": "453097edc44d6055ffd4a5a17612f413179d7454923fc09927d500675a7bacdb" + }, + { + "path": "research/p104-retained-native-copy/TASK.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/TASK.json", + "sha256": "61556a4e57a17757160f7f809a116ce692839e4ff1f5ce83cdcd382981df0268" + }, + { + "path": "research/p104-retained-native-copy/VALIDATION.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/VALIDATION.md", + "sha256": "62f05bea3a6cb5152ad0ec11365c75ded233f61184f335085cb81abe870b6a94" + }, + { + "path": "research/p104-retained-native-copy/VERIFY.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/VERIFY.json", + "sha256": "146fd66ef488919e8779b15ef126ad82ac6ac6b256961e81d62c585823e95f77" + }, + { + "path": "research/p104-retained-native-copy/WITNESS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/WITNESS.json", + "sha256": "4c165c2416f162bba3386de2bc617fd44164df942b91b221eb43216916cd70ab" + }, + { + "path": "research/p104-retained-native-copy/WORD.json.gz", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/WORD.json.gz", + "sha256": "7c393444fa5b9a6941471d02047beb2aa8285e5614bb052fb85458b69236a38a" + }, + { + "path": "research/p104-retained-native-copy/construct.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/construct.py", + "sha256": "b29d9fdda07320f0c17c0d6eda1831a78ee69c895c57aeab60be730f0e1f08e1" + }, + { + "path": "research/p104-retained-native-copy/inputs/pr5751-source.tar", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/inputs/pr5751-source.tar", + "sha256": "5a3046462b06c108e2853898c9daf4b466bc46f47e5f77983515b6e5e7ed5023" + }, + { + "path": "research/p104-retained-native-copy/local.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/local.py", + "sha256": "0a3664cd5f077e020a62903f093fff6a1617a84a048137bf812af67be9d1b1c8" + }, + { + "path": "research/p104-retained-native-copy/pricing.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/pricing.py", + "sha256": "0f6f0e33bf78ba35873d4ed103bb089542b84b10388c7a5f4a546c15bb7e4493" + }, + { + "path": "research/p104-retained-native-copy/sources.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/sources.py", + "sha256": "fc6f5ebda612e839d61c0a059c10c10ba93787855b9e6077a9ba46200a275988" + }, + { + "path": "research/p104-retained-native-copy/verify.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/verify.py", + "sha256": "9c6e6727c332526ba53cd93a084f6733fdb773f0130eb7fa969fd39c0e500ca7" + }, + { + "path": "research/p104-asynchronous-helper-hubs/LOCAL-EDITS.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/LOCAL-EDITS.json", + "sha256": "1118183d04913fd5c525a7aa85d727b6d9d36992b9d8490c5a866434b2754cec" + }, + { + "path": "research/p104-asynchronous-helper-hubs/NOTICE", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/NOTICE", + "sha256": "2feedebb4a059025670699f807baa90818f0088267e8549f773de3e0ea296158" + }, + { + "path": "research/p104-asynchronous-helper-hubs/PLAN.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/PLAN.json", + "sha256": "2c4878f78dc393339f8cccf24441d9bfb50257784459c2f253ebcb27c964211c" + }, + { + "path": "research/p104-asynchronous-helper-hubs/PRICING-EDITS.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/PRICING-EDITS.json", + "sha256": "25efa817a0474631afc3a1c09611cf50ca30314e66901f1dff802946915a04fa" + }, + { + "path": "research/p104-asynchronous-helper-hubs/PROOF.md", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/PROOF.md", + "sha256": "0a2b7c13fadecf18a33320eb6b159757e5516e5e9c7b52a03db2e9f32f25f36a" + }, + { + "path": "research/p104-asynchronous-helper-hubs/README.md", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/README.md", + "sha256": "742fd06e72b1f977ab9bb5e9ac0dfafc87cbc343a2e0f1c86e4eb77509e4746e" + }, + { + "path": "research/p104-asynchronous-helper-hubs/RESULT.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/RESULT.json", + "sha256": "eabb5f4ece0a4fc3ada4ea1796dc413eddb0683541fe03dd48f0f53cba1e2ea6" + }, + { + "path": "research/p104-asynchronous-helper-hubs/SOURCES.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/SOURCES.json", + "sha256": "3a70129e30648c647401ac1ce269bc65792f0f7d6b5649313ea78d20625b62ae" + }, + { + "path": "research/p104-asynchronous-helper-hubs/TASK.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/TASK.json", + "sha256": "040a7af88daac30d5beca4f7db7410e5f987d46742828ba41fd42882081c6f72" + }, + { + "path": "research/p104-asynchronous-helper-hubs/VALIDATION.md", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/VALIDATION.md", + "sha256": "685af1e45b1a19c7bb6189321b290a49a183a4d4b8c53904319366fdc9aa5570" + }, + { + "path": "research/p104-asynchronous-helper-hubs/VERIFY.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/VERIFY.json", + "sha256": "eee6981e3c3243dd69d19c68042e6087dc97780016a6aa56a74fb438af1f9fd5" + }, + { + "path": "research/p104-asynchronous-helper-hubs/WITNESS.json", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/WITNESS.json", + "sha256": "351a08afe2d427a552ed3d758f20f12429f8f4a4ca65fd2eacbe6d07a1a4cf5f" + }, + { + "path": "research/p104-asynchronous-helper-hubs/WORD.json.gz", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/WORD.json.gz", + "sha256": "35fbd3049ab7a731ed245944257e8fdad1eaa4c3baca71761bca7bf5f95f1243" + }, + { + "path": "research/p104-asynchronous-helper-hubs/construct.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/construct.py", + "sha256": "c1ded96afc454aa7f94d99f2a08c57f4eac731bc931ca034ec3b0040e1776fa7" + }, + { + "path": "research/p104-asynchronous-helper-hubs/inputs/pr5774-source.tar", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/inputs/pr5774-source.tar", + "sha256": "e47cd61d6542497287f5a69820484e92f7116aaf76663969fe59a1d85fffe497" + }, + { + "path": "research/p104-asynchronous-helper-hubs/local.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/local.py", + "sha256": "4d6db6dae893fc4e7e31148d2a8144d7a1a2afbba4b48f4532b0a1f1a9804f9e" + }, + { + "path": "research/p104-asynchronous-helper-hubs/pricing.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/pricing.py", + "sha256": "55fe9194ed9de830623f69472be808a043f129cedd2ba0c97ec49f6ae41df2a1" + }, + { + "path": "research/p104-asynchronous-helper-hubs/sources.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/sources.py", + "sha256": "fee3e7fd1c1aa4980b593b22de2d55a3e66f8dc8c7e7f5735f45bd67491768b0" + }, + { + "path": "research/p104-asynchronous-helper-hubs/verify.py", + "pin": "head:6b936acd68a7e0f9062037900f0fe9bc4b6fdd25:research/p104-asynchronous-helper-hubs/verify.py", + "sha256": "520176dd2663695b7da89e67a007de50052244650bf462dc2fe08ed85d4e63b2" + } + ], + "source_retention_head": "388b5216712d72f29ebad4d26756fe8fe441f66c", + "previous_source_export": { + "local_path": "source/pr5774-export.tar", + "commit": "7d6ec0cdef31d0c37b7d2563e709979caa0d5eae", + "package": "research/p104-retained-native-copy", + "files": 19, + "sha256": "e47cd61d6542497287f5a69820484e92f7116aaf76663969fe59a1d85fffe497", + "git_blob": "f34972476e76121c7cbb0e86478eaa86969c6efd" + }, + "previous_archived_files": [ + { + "path": "research/p104-retained-native-copy/LOCAL-EDITS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/LOCAL-EDITS.json", + "sha256": "9ef49a2f123519c7c2b750ca6afdbe6dc1a9e99f29aff81bfcb593d758714388" + }, + { + "path": "research/p104-retained-native-copy/NOTICE", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/NOTICE", + "sha256": "eccf96753b037fd1f9037487d9a77c62abf117100c24a28a5d0b25d9e1f25176" + }, + { + "path": "research/p104-retained-native-copy/PLAN.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PLAN.json", + "sha256": "1476064d57afcabfd43deb0b2b61ce30bb89b603df72645f60dacf00b72fcdbe" + }, + { + "path": "research/p104-retained-native-copy/PRICING-EDITS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PRICING-EDITS.json", + "sha256": "ea4f275bc47ed3c1e54c598ad1ed2e0d6b3260c444f5a142238c6b88a4700acb" + }, + { + "path": "research/p104-retained-native-copy/PROOF.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/PROOF.md", + "sha256": "f7af2ed85c8ce88bc4707a4171503108c4d7083c165fe5929108bf976baaa446" + }, + { + "path": "research/p104-retained-native-copy/README.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/README.md", + "sha256": "1626aadf77c59ba511b6c39bf27f31f78567d6d2ba9c62e04c8f995ba1c73515" + }, + { + "path": "research/p104-retained-native-copy/RESULT.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/RESULT.json", + "sha256": "a47576bd8f65fb2e4bb250043ccf209d880a704ca3c80c0ff45c0255b3959761" + }, + { + "path": "research/p104-retained-native-copy/SOURCES.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/SOURCES.json", + "sha256": "453097edc44d6055ffd4a5a17612f413179d7454923fc09927d500675a7bacdb" + }, + { + "path": "research/p104-retained-native-copy/TASK.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/TASK.json", + "sha256": "61556a4e57a17757160f7f809a116ce692839e4ff1f5ce83cdcd382981df0268" + }, + { + "path": "research/p104-retained-native-copy/VALIDATION.md", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/VALIDATION.md", + "sha256": "62f05bea3a6cb5152ad0ec11365c75ded233f61184f335085cb81abe870b6a94" + }, + { + "path": "research/p104-retained-native-copy/VERIFY.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/VERIFY.json", + "sha256": "146fd66ef488919e8779b15ef126ad82ac6ac6b256961e81d62c585823e95f77" + }, + { + "path": "research/p104-retained-native-copy/WITNESS.json", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/WITNESS.json", + "sha256": "4c165c2416f162bba3386de2bc617fd44164df942b91b221eb43216916cd70ab" + }, + { + "path": "research/p104-retained-native-copy/WORD.json.gz", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/WORD.json.gz", + "sha256": "7c393444fa5b9a6941471d02047beb2aa8285e5614bb052fb85458b69236a38a" + }, + { + "path": "research/p104-retained-native-copy/construct.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/construct.py", + "sha256": "b29d9fdda07320f0c17c0d6eda1831a78ee69c895c57aeab60be730f0e1f08e1" + }, + { + "path": "research/p104-retained-native-copy/inputs/pr5751-source.tar", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/inputs/pr5751-source.tar", + "sha256": "5a3046462b06c108e2853898c9daf4b466bc46f47e5f77983515b6e5e7ed5023" + }, + { + "path": "research/p104-retained-native-copy/local.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/local.py", + "sha256": "0a3664cd5f077e020a62903f093fff6a1617a84a048137bf812af67be9d1b1c8" + }, + { + "path": "research/p104-retained-native-copy/pricing.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/pricing.py", + "sha256": "0f6f0e33bf78ba35873d4ed103bb089542b84b10388c7a5f4a546c15bb7e4493" + }, + { + "path": "research/p104-retained-native-copy/sources.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/sources.py", + "sha256": "fc6f5ebda612e839d61c0a059c10c10ba93787855b9e6077a9ba46200a275988" + }, + { + "path": "research/p104-retained-native-copy/verify.py", + "pin": "head:7d6ec0cdef31d0c37b7d2563e709979caa0d5eae:research/p104-retained-native-copy/verify.py", + "sha256": "9c6e6727c332526ba53cd93a084f6733fdb773f0130eb7fa969fd39c0e500ca7" + } + ], + "new_source_retention_head": "d39791e4d177aec7d194e737c7d6b2fee7786222", + "second_source_retention_head": "59e96b277c628027079bc7a712d60fcf86fd187b" +} diff --git a/research/p104-copy-block-composition/TASK.json b/research/p104-copy-block-composition/TASK.json new file mode 100644 index 0000000000..45bf39d648 --- /dev/null +++ b/research/p104-copy-block-composition/TASK.json @@ -0,0 +1,123 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 8, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Compose the exact released PR5786 hubs, PR5774 retained copies, PR5739 R22 block and PR5796 second block; replay and price the full conditional caller, and maximize the published 1e-14 grid under the fixed reserve and tested gap.", + "scope_change_reason": "PR5774 supplies the stronger released word and explicitly excludes the original R22 block. All eight exact R22 runs and both helper endpoints match. Chart1090 already has the same basis. The source constructions are credited; the new contribution is their verified complete composition. PR5786 published the stronger released hub word before submission. Its complete export and price contract replace PR5774 as the immediate source. All eight R22 runs and both helper endpoints still match. The verified earlier PR5774 composition remains at8f4a012d9 as a checkpoint, not a separate contribution. PR5796 released the requested second block after publication of this package. It is incorporated into the same PR5795, not counted as an extra contribution. Only the sixteen required native path edits on its nine roles are changed; all unrelated native paths remain. The exact source and overlap checks were refreshed.", + "bottleneck_link": "The compatible composition changes the full signed paid/target invoice and must retain arbitrary inputs, native phases, owned copies, compiler closure and the outer transfer.", + "budget_minutes": 120, + "stop_rule": "Publish the strongest compatible released-source composition that passes the full replay, or record an exact interface or price failure. Do not take active unpublished block, hub or global-frame construction work.", + "outcome": "completed", + "evidence": "WORD.json.gz, HUNKS.json, RESULT.json and registered normal/optimized full replay.", + "author": "Ali Romman with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for integration, verification and proof. No subagents or independent human acceptance.", + "open_questions": [ + { + "question": "Can a changed contract improve the complete signed invoice beyond both released rank-four blocks?", + "why_it_matters": "The fixed block and fixed compiler-grid optima do not cover new caller words.", + "first_step": "Read the live retained-copy, asynchronous target and variable-projector claims; use only a released exact source and reprice the complete caller.", + "blocked_by": "Active scopes and independent physical/native/compiler obligations remain." + }, + { + "question": "Can an independent reviewer accept both source constructions and the complete composed caller?", + "why_it_matters": "Author checks and archive publication do not select a frontier.", + "first_step": "Replay the read-only export and audit the retained-copy lifetimes, both R22 helper endpoints and full invoice.", + "blocked_by": "Independent scientific review and the five inherited framework assumptions remain." + } + ] +} diff --git a/research/p104-copy-block-composition/VALIDATION.md b/research/p104-copy-block-composition/VALIDATION.md new file mode 100644 index 0000000000..b0ba7c9289 --- /dev/null +++ b/research/p104-copy-block-composition/VALIDATION.md @@ -0,0 +1,57 @@ +# Validation record + +CPython 3.12.14 on macOS arm64, standard library only, no subagents. +Canonical main is de5ec2e7a6074068452f45b1a191b5c72832df4a, priority revision 8. +The immediate source is PR5786 at6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c. All frozen +source bytes, including both source closures and the added block plan/words, +are authenticated before source import or interpretation. + +The final two-block primary replay passed in143.90 seconds. All four registered +commands then passed in247.49 seconds: normal and optimized full replay, then +normal and optimized scalar-transfer compatibility checks. These cover all795 +input columns and632025 coefficients, separate transpose,27 owned lifetimes, +peak13 live owned fields,2926 distinct native maps with absolute phases, +208 main adapters,1124 helper normalizers and the complete physical caller. +Both rational moment engines, completion, compiler,54 strict outer rows and +four functional conditions pass. Twelve word/caller/invoice controls and the +native phase control reject. The compatibility check covers every original R22 +transfer and all102 frame-only second-block contacts; a wrong coefficient rejects. +Nine actual direct-source/archive byte corruptions reject before imports. + +The conditional saving is .00312289583377. The raw ceiling lies strictly inside +(.00312289583975,.00312289583976). An exact fixed-reserve derivative bound and +opposite signs at adjacent tested values certify the maximum published point on +the1e-14 grid, for reserve1e-12 and tested gap5e-12. This is a fixed-contract +result. The next tested point .00312289583878 fails the reserve. No global +optimum over different compiler choices, source words or BIT caps is claimed. + +``` +python3.12 -B scripts/research_package.py --package research/p104-copy-block-composition +python3 -B scripts/research_package.py --package research/p104-copy-block-composition --check-only +git diff --check +``` + +The earlier PR5786 plus original-R22 checkpoint is retained at +582c6334f474b5ea576b518a9497ae9961c620ac, with kappa .00312277313. Its four +registered commands passed in438.77 seconds; its sealed full/compatibility +replays passed in128.83/.19 seconds with24 files unchanged. The still earlier +PR5774 composition is retained at8f4a012d9171971837fef8949b1eedb60beacc64, +kappa .00312204390, with registered normal/optimized full replay in288.13 seconds. +These are superseded checkpoints of the same contribution. The second block was +released after the first publication and is added to the same PR5795. + +All five framework assumptions remain. No large uniform word or rounded +multiplier is materialized. Hosted CI and independent scientific acceptance +remain pending. Full-history ancestry checking is unavailable in the shallow +checkout; no automatic history expansion ran. The selected frontier is unchanged. + +Final two-block scientific checkpoint: +ca740c341b4e2ce1d7d95c5c08c9fd06491f1068. Committed bytes, executable modes and +the official30-file export pass. A separate export has no Git directory and +uses read-only files/directories. With empty PATH, Python3.12 runs both scripts +under `-I -O -W error -B`: the complete verifier passed in76.00 seconds and the +compatibility verifier in.24 seconds. All31 files, including the export +manifest, retained their bytes and modes. Only this validation record changes +after the scientific checkpoint. Final committed bytes and publication export +are checked again. No timing comparison or speedup is inferred from these runs. diff --git a/research/p104-copy-block-composition/VERIFY.json b/research/p104-copy-block-composition/VERIFY.json new file mode 100644 index 0000000000..47d97824e7 --- /dev/null +++ b/research/p104-copy-block-composition/VERIFY.json @@ -0,0 +1,47 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Both released block/source joins, all795 scalar inputs, transpose, owned lifetimes, every native phase, full physical caller, two moment engines, compiler, outer predicates and rejection controls." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 590, + "checks": "Both released block/source joins, all795 scalar inputs, transpose, owned lifetimes, every native phase, full physical caller, two moment engines, compiler, outer predicates and rejection controls." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/compatibility.py" + ], + "timeout_seconds": 10, + "checks": "Every exact R22 scalar transfer and all102 frame-only second-block contacts, all13 retained COPY values, source joins and a wrong-coefficient control." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/compatibility.py" + ], + "timeout_seconds": 10, + "checks": "Every exact R22 scalar transfer and all102 frame-only second-block contacts, all13 retained COPY values, source joins and a wrong-coefficient control." + } + ] +} diff --git a/research/p104-copy-block-composition/WORD.json.gz b/research/p104-copy-block-composition/WORD.json.gz new file mode 100644 index 0000000000..ac2f8e41ca Binary files /dev/null and b/research/p104-copy-block-composition/WORD.json.gz differ diff --git a/research/p104-copy-block-composition/compatibility.py b/research/p104-copy-block-composition/compatibility.py new file mode 100644 index 0000000000..7ddb372017 --- /dev/null +++ b/research/p104-copy-block-composition/compatibility.py @@ -0,0 +1,86 @@ +"""Check every R22 scalar transfer and preservation of retained copy values. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The R22 edit list and retained-copy construction keep their original credit. +""" +import argparse +from copy import deepcopy +from fractions import Fraction as Q +import gzip +import json +from pathlib import Path +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.dont_write_bytecode = True +from sources import sources, need +from construct import construct, digest + + +def matrix(events, fields): + rows = {r: [Q(x == r) for x in fields] for r in fields} + for event in events: + if event[0] == 'ADD': + _, dst, src, value, frame = event + rows[dst] = [x+Q(value)*y for x, y in zip(rows[dst], rows[src])] + elif event[0] == 'SCALE': + _, dst, value, frame = event + rows[dst] = [Q(value)*x for x in rows[dst]] + else: + need(event[0] == 'MOVE', 'No COPY or lifetime boundary inside an edit') + return [[str(x) for x in rows[r]] for r in fields] + + +def run(): + with sources() as (parent, root): + source = json.loads(gzip.decompress((parent/'WORD.json.gz').read_bytes())) + word, spots = construct(source) + retained = json.loads(gzip.decompress((HERE/'WORD.json.gz').read_bytes())) + need(word == retained, 'Exact composed word') + need(spots == json.loads((HERE/'HUNKS.json').read_bytes()), 'Exact literal edit positions') + edits = json.loads((HERE/'source/R22-EDITS.json').read_bytes()) + witnesses = [] + for i, (old, new) in enumerate(edits['program']): + fields = sorted({r for e in old+new if e[0] in ('ADD', 'SCALE') + for r in (e[1:3] if e[0] == 'ADD' else [e[1]])}) + a, b = matrix(old, fields), matrix(new, fields) + need(a == b, 'Same exact scalar transfer for source edit '+str(i)) + witnesses.append(dict(edit=i, fields=fields, matrix=a)) + bad = deepcopy(edits['program'][0][1]) + first = next(e for e in bad if e[0] == 'ADD') + first[3] = str(Q(first[3])+1) + need(matrix(bad, witnesses[0]['fields']) != witnesses[0]['matrix'], + 'Reject one wrong scalar coefficient in the first edit') + old_events = [e for e in source['program'] if e[0] in ('INIT', 'COPY', 'CLEAR')] + new_events = [e for e in word['program'] if e[0] in ('INIT', 'COPY', 'CLEAR')] + need(old_events == new_events, 'Every copied source and lifetime event remains in order') + copies = [e for e in old_events if e[0] == 'COPY' and source['public']+9 <= e[1] < source['public']+22] + need(len(copies) == 13, 'All thirteen retained native copies') + return dict(status='PASS_R22_SCALAR_TRANSFERS_AND_ALL_13_COPY_VALUES', + word_sha256=digest(word), edits=witnesses, retained_copies=copies, + all_copy_events=[e for e in old_events if e[0] == 'COPY'], + second_block_scalar_transfer_sha256=spots['second_block']['scalar_transfer_sha256'], + second_block_contacts=len(spots['second_block']['changed_scalar_source_indices']), + proof='Disjoint equal R22 scalar transfers and no internal COPY preserve all external COPY values. The second block changes only scalar frames and preserves every scalar coefficient and order. Native frames and phases are checked by the complete verifier.', + wrong_scalar_coefficient_rejected=True) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + with tempfile.TemporaryDirectory(prefix='copy-block-compatibility-') as cache: + sys.pycache_prefix = cache + result = run() + path = HERE/'COMPATIBILITY.json' + if args.write: + path.write_text(json.dumps(result, sort_keys=True, indent=2)+'\n') + else: + need(json.loads(path.read_bytes()) == result, 'Exact compatibility certificate') + print(result['status']) + + +if __name__ == '__main__': + main() diff --git a/research/p104-copy-block-composition/construct.py b/research/p104-copy-block-composition/construct.py new file mode 100644 index 0000000000..bf2cc660ad --- /dev/null +++ b/research/p104-copy-block-composition/construct.py @@ -0,0 +1,49 @@ +"""Compose Joel Pulikkan's exact R22 block with the released native copies. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The two source constructions retain their authorship and notices. +""" +from copy import deepcopy +from hashlib import sha256 +import json +from pathlib import Path +from sources import need + +HERE = Path(__file__).resolve().parent + + +def digest(value): + return sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +def construct(source): + edits = json.loads((HERE/'source/R22-EDITS.json').read_bytes()) + word = deepcopy(source) + need(len(word['frames']) == 1092 and len(edits['frames']) == 1, + 'Exact source chart inventories') + need(word['frames'][1090] == edits['frames'][0], 'Existing chart has the exact R22 basis') + for kind in ('initial', 'final'): + for label, (old, new) in edits[kind].items(): + need(word[kind][int(label)] == old and new == 1090, 'Exact helper endpoint join') + word[kind][int(label)] = new + program, spots = word['program'], [] + for index, (old, new) in enumerate(edits['program']): + hits = [i for i in range(len(program)-len(old)+1) if program[i:i+len(old)] == old] + need(len(hits) == 1, 'One exact R22 source run: '+str(index)) + spots.append((hits[0], old, new)) + spots.sort() + need(len(spots) == 8, 'All eight source edits') + for (i, old, _), (j, _, _) in zip(spots, spots[1:]): + need(i+len(old) <= j, 'Disjoint source runs') + for i, old, new in reversed(spots): + program[i:i+len(old)] = deepcopy(new) + preserve = lambda w: [e for e in w['program'] if e[0] in ('INIT', 'COPY', 'CLEAR')] + need(preserve(word) == preserve(source), 'Every owned lifetime and COPY event is retained in order') + need(word['owned_fields'] == source['owned_fields'] == 25, 'No extra owned label') + word['schema'] = 'p104-copy-block-composition/1' + witness = [dict(source_index=i, old_length=len(old), new_length=len(new), + old_sha256=digest(old), new_sha256=digest(new)) for i, old, new in spots] + from second_block import extend + word, second = extend(word) + need(preserve(word) == preserve(source), 'Both blocks retain every owned lifetime and COPY event') + return word, dict(R22=witness, second_block=second) diff --git a/research/p104-copy-block-composition/pricing.py b/research/p104-copy-block-composition/pricing.py new file mode 100644 index 0000000000..ff8da1e459 --- /dev/null +++ b/research/p104-copy-block-composition/pricing.py @@ -0,0 +1,184 @@ +"""Complete mixed-target price, compiler and outer transfer. + +The interval and compiler bounds follow zxv and Cao Yifan. The productive +recursion is by Jacob Alan Sussman. The controller is by Cinna Davis. +Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes. +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. +The paid A2 change is from zxv PR5643. The three helper relations are from +Ali Romman PR5644. The four-gate change is by Ali Romman with Codex assistance. +The four interior basis changes are by Ali Romman with Codex assistance. +Paid intermediate meetings: Ali Romman with substantial OpenAI Codex assistance. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +import local as L + +KAPPA, TESTED = Q('0.00312289583377'), Q('0.00312289583877') +PREVIOUS = Q('.00312265044') + + +def encode(x): + if isinstance(x,Q): + return str(x) + if isinstance(x,dict): + return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)): + return [encode(v) for v in x] + return x + + +def assemble(local, native, word, physical): + paid, targets = Counter(), Counter() + counts = Counter() + L.need(local['helpers'] == native['helpers'], 'Every productive helper has a native target') + for e in word['physical_events']: + counts[e[0]] += 1 + if e[0] == 'LOCAL': + L.need(e[3] is False, 'Every source invocation is forward') + paid.update(local['paid']) + targets.update(local['helpers']) + elif e[0] == 'QUERY_SHEAR': + paid[1] += 104 + elif e[0] == 'IDLE': + paid[8*len(e[2])] += 208 + main = Counter() + idle = Counter({8*len(e[2]):0 for e in word['physical_events'] if e[0] == 'IDLE'}) + for e in word['physical_events']: + if e[0] == 'IDLE': + idle[8*len(e[2])] += 208 + L.need(idle == physical['whole_idle_jobs'], 'Every whole idle has a native Gaussian and full rank') + for term in word['diagonal']: + main[1+8*sum(term[1:])] += 104 + L.need(main == physical['main_targets'], 'Every main target has its full native phase') + targets.update(main) + L.need(counts['LOCAL'] == 18 and counts['QUERY_SHEAR'] == counts['IDLE'] == 15, 'Complete call census') + # Recount by the two path lengths, without using emitted main diagonals. + second_t = Counter({r:18*n for r,n in local['helpers'].items()}) + second_p = Counter({r:18*n for r,n in local['paid'].items()}) + second_t[145] += 208 + second_p[1] += 15*104 + for length in (7,8): + for j in range(1,length+1): + second_t[1+8*(j+1)] += 208 + 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()) == 13444 and sum(paid.values()) == 66942, '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 + + +def run(local,native,word,physical): + T,P,counts = assemble(local,native,word,physical) + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals') + other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals') + def margin(k): + a,b = E.moment(T,1-k), E.moment(P,1-k) + return a[0]-b[1],a[1]-b[0] + lo,hi,grid = 0,10**12,10**14 + while hi-lo > 1: + m=(lo+hi)//2 + if margin(Q(m,grid))[0] > 0: + lo=m + else: + hi=m + lower,upper = Q(lo,grid),Q(hi,grid) + signed = Counter(T) + signed.subtract(P) + cap = Q('.0034') + derivative_upper = Q(0) + for rank, count in signed.items(): + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap') + L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure') + L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim') + t,u,v,c,b = 1-TESTED,Q(1,7),1024,16,17 + target,paid = E.moment(T,t),E.moment(P,t) + tl,th = other.moment(T,TESTED) + pl,ph = other.moment(P,TESTED) + L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines') + 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**12),Q(125,128) + 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) + L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges') + theta,power = Q(63,64),1024 + eta = E.scale(E.power(145,-v*TESTED),t) + L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity') + L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range') + gap = (TESTED-KAPPA)/7 + L.need(gap.numerator == 1, 'Exact compiler integer grid') + step = gap.denominator + def wins(j): + return (step*j+1)**power < 2**j + left,right=1,2 + while not wins(right): + left,right=right,2*right + while right-left > 1: + m=(left+right)//2 + if wins(m): + right=m + else: + left=m + H=step*right + L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection') + local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000 + L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded') + boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right')) + raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary) + raw += 32*104*(26+1000) + L.need(raw < 10**9, 'Complete nonrecursive raw bound') + bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom = Q(bit['atom']) + ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599') + admitted=Q(bit['admitted']) + L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock') + outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory') + L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict') + wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target)) + L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory') + old_completion = E.divide((Q(sum(T.values())*18),)*2,E.mul(E.power(17,TESTED),target)) + L.need(old_completion[0] > Q(39,40), 'PR5718 completion-tail bound fails with the new target count') + old_offset = E.divide(E.moment(P,t+Q(1,5)),E.mul(E.power(16,Q(1,5)),target)) + L.need(old_offset[0] > decay, 'The old tail offset fails at the new cutoff') + 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':'0.00312289583377','previous_pr5786':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)), + 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()), + 'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120, + 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + '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':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.'}, + 'ordinary_BIT':bit,'outer':outer, + 'negative_controls':{'source_completion':'Rejected at cutoff17, floor18 and decay39/40', + 'source_offset':'Rejected at cutoff16 with tail offset1/5', + 'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}}) diff --git a/research/p104-copy-block-composition/second_block.py b/research/p104-copy-block-composition/second_block.py new file mode 100644 index 0000000000..822bbd2cff --- /dev/null +++ b/research/p104-copy-block-composition/second_block.py @@ -0,0 +1,122 @@ +"""Bind the released second block while preserving unrelated native paths. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The second block and Joel Pulikkan's R22 mechanism retain their source credit. +""" +from copy import deepcopy +from hashlib import sha256 +import gzip +import json +from pathlib import Path +from sources import need + +HERE = Path(__file__).resolve().parent + + +def encoded(value): + return json.dumps(value, separators=(',', ':')) + + +def extend(source): + plan = json.loads((HERE/'source/SECOND-PLAN.json').read_bytes()) + old = json.loads(gzip.decompress((HERE/'source/SECOND-OLD-WORD.json.gz').read_bytes())) + published = json.loads(gzip.decompress((HERE/'source/SECOND-WORD.json.gz').read_bytes())) + old_scalar = [e for e in old['program'] if e[0] != 'MOVE'] + published_scalar = [e for e in published['program'] if e[0] != 'MOVE'] + need([e[:-1] for e in old_scalar] == [e[:-1] for e in published_scalar], + 'The published block preserves all scalar coefficients and order') + need(published['frames'] == old['frames'] + [plan['basis']], 'Exact released block chart') + word = deepcopy(source) + need(plan['basis'] not in word['frames'], 'The second chart has no exact existing copy') + chart = len(word['frames']) + word['frames'].append(plan['basis']) + scalar = [(i, e) for i, e in enumerate(word['program']) if e[0] != 'MOVE'] + keys = [encoded(e) for _, e in scalar] + changed = [] + roles = set() + for run in plan['runs']: + block = old_scalar[run['first_scalar']:run['first_scalar']+run['length']] + need(sha256(encoded(block).encode()).hexdigest() == run['old_sha256'], 'Exact released scalar block') + block_keys = [encoded(e) for e in block] + hits = [i for i in range(len(keys)-len(block)+1) if keys[i:i+len(block)] == block_keys] + need(len(hits) == 1, 'One literal second-block scalar run') + for j in range(hits[0], hits[0]+len(block)): + i, event = scalar[j] + need(i not in changed and event[0] in ('ADD', 'SCALE') and event[-1] == plan['old_frame'], + 'Disjoint scalar operation on the declared old chart') + changed.append(i) + roles.update(event[1:3] if event[0] == 'ADD' else event[1:2]) + event[-1] = chart + need(len(changed) == 102 and sorted(roles) == plan['roles'], 'All and only released contacts') + for kind, role in [('initial', plan['initial_helper']), ('final', plan['final_helper'])]: + need(word[kind][role] == plan['old_frame'], 'Exact second-block helper endpoint') + word[kind][role] = chart + + # Change the last old native edge before a changed contact or final boundary. + # Earlier edges in a query chain retain their destination and their order. + following = {r: ('final', a, b) for r, (a, b) in enumerate(zip(source['final'], word['final']))} + destinations = {} + for i in reversed(range(len(source['program']))): + before, after = source['program'][i], word['program'][i] + op, role = before[:2] + if op == 'MOVE': + next_use = following.get(role) + if next_use and next_use[0] in ('scalar', 'final') and before[3] == next_use[1]: + destinations[i] = next_use[2] + following[role] = ('move', before[2], before[2]) + else: + operands = before[1:3] if op in ('ADD', 'COPY') else before[1:2] + for r in operands: + following[r] = ('barrier' if op == 'INIT' else 'scalar', before[-1], after[-1]) + current = word['initial'] + [None]*word['owned_fields'] + active, program, native_changes = set(), [], [] + + def move(role, frame, where): + need(current[role] is not None, 'Only a live field can move') + if current[role] != frame: + event = ['MOVE', role, current[role], frame, role in active] + program.append(event) + native_changes.append(dict(source_index=where, inserted=event)) + current[role] = frame + + for i, event in enumerate(word['program']): + op, role = event[:2] + if op == 'MOVE': + need(event[4] == (role in active), 'Original owned-query flag') + frame = destinations.get(i, event[3]) + replacement = ['MOVE', role, current[role], frame, role in active] + need(current[role] is not None, 'Original query has a live source') + if current[role] != frame: + program.append(replacement) + if replacement != event or current[role] == frame: + native_changes.append(dict(source_index=i, old=event, + replacement=None if current[role] == frame else replacement)) + current[role] = frame + elif op == 'INIT': + need(role not in active, 'New owned lifetime') + active.add(role) + current[role] = event[-1] + program.append(event) + else: + move(role, event[-1], i) + if op in ('ADD', 'COPY'): + move(event[2], event[-1], i) + program.append(event) + if op == 'CLEAR': + need(role in active, 'Owned lifetime closes') + active.remove(role) + current[role] = None + for role, frame in enumerate(word['final']): + move(role, frame, len(source['program'])) + need(not active, 'All owned lifetimes close') + word['program'] = program + unchanged = lambda w: [e for e in w['program'] if e[0] == 'MOVE' and e[1] not in roles] + need(unchanged(word) == unchanged(source), 'Every unrelated native query stays in order') + before = [e[:-1] for e in source['program'] if e[0] != 'MOVE'] + after = [e[:-1] for e in word['program'] if e[0] != 'MOVE'] + need(before == after, 'Every scalar coefficient, order and copy value is unchanged') + word['schema'] = 'p104-copy-block-composition/2' + return word, dict(source_head='4b30391e633ba0c7c674f03586ae97d443e9bc9c', + changed_scalar_source_indices=changed, roles=sorted(roles), basis=plan['basis'], + new_frame=chart, native_changes=native_changes, + scalar_transfer_sha256=sha256(encoded(before).encode()).hexdigest()) diff --git a/research/p104-copy-block-composition/source/R22-EDITS.json b/research/p104-copy-block-composition/source/R22-EDITS.json new file mode 100644 index 0000000000..54f7b233d7 --- /dev/null +++ b/research/p104-copy-block-composition/source/R22-EDITS.json @@ -0,0 +1 @@ +{"frames":[[265,194,164,75]],"initial":{"741":[477,1090]},"final":{"405":[477,1090]},"program":[[[["MOVE",42,476,477,false],["MOVE",41,475,477,false],["ADD",42,41,"1",477],["ADD",41,42,"-1",477],["ADD",42,41,"1",477],["SCALE",41,"-1",477],["SCALE",41,"-2",477],["MOVE",400,470,477,false],["ADD",400,41,"-1",477],["MOVE",401,472,477,false],["ADD",401,41,"-1",477],["SCALE",42,"-2",477],["MOVE",106,474,477,false],["ADD",106,42,"1/2",477],["MOVE",403,471,477,false],["ADD",403,42,"-1",477],["MOVE",405,469,477,false],["ADD",405,106,"1",477],["ADD",106,405,"-1",477],["ADD",405,106,"1",477],["SCALE",106,"-1",477],["ADD",41,405,"-2",477],["ADD",405,42,"-1",477],["ADD",405,403,"-1/2",477],["ADD",741,403,"1/2",477],["ADD",741,42,"1",477],["ADD",41,741,"2",477],["MOVE",410,473,477,false],["ADD",410,400,"1",477],["ADD",400,410,"-1",477],["ADD",410,400,"1",477],["SCALE",400,"-1",477],["SCALE",400,"-2",477],["ADD",403,401,"1",477],["ADD",401,403,"-1",477],["ADD",403,401,"1",477],["SCALE",401,"-1",477],["ADD",42,401,"1",477],["ADD",741,401,"1/2",477],["ADD",41,403,"1",477],["ADD",400,403,"1",477],["ADD",410,403,"-2",477],["ADD",410,741,"1",477],["ADD",741,410,"-1",477],["ADD",410,741,"1",477],["SCALE",741,"-1",477],["SCALE",741,"-1/2",477],["ADD",41,741,"-1",477],["ADD",400,741,"-1",477],["ADD",403,741,"-1",477],["ADD",42,410,"-1",477],["ADD",106,410,"-1",477],["ADD",401,410,"-1",477],["ADD",741,410,"1",477],["ADD",403,410,"1",477],["ADD",401,410,"-1",477],["SCALE",410,"2",477],["ADD",403,741,"1",477],["ADD",106,741,"1",477],["ADD",42,741,"-1",477],["ADD",410,741,"1",477],["ADD",741,410,"-1",477],["ADD",410,741,"1",477],["SCALE",741,"-1",477],["ADD",410,403,"-1/2",477],["ADD",741,403,"-1",477],["ADD",401,403,"1",477],["ADD",400,403,"1/2",477],["ADD",106,403,"-1/2",477],["ADD",42,403,"1/2",477],["ADD",41,403,"-1/2",477],["SCALE",403,"-1/2",477],["ADD",741,401,"1",477],["ADD",403,401,"1/2",477],["ADD",400,401,"-1/2",477],["ADD",106,401,"1/2",477],["ADD",42,401,"1/2",477],["ADD",41,401,"1/2",477],["SCALE",401,"-2",477],["ADD",106,400,"1",477],["ADD",42,400,"1",477],["ADD",41,400,"-1",477],["SCALE",400,"2",477],["ADD",401,400,"1",477],["ADD",400,401,"-1",477],["ADD",401,400,"1",477],["SCALE",400,"-1",477],["ADD",403,106,"1/2",477],["ADD",401,106,"-1",477],["ADD",41,106,"1",477],["SCALE",106,"-2",477],["ADD",403,42,"1/2",477],["ADD",401,42,"-1",477],["ADD",41,42,"1",477],["SCALE",42,"-2",477],["ADD",400,42,"1",477],["ADD",42,400,"-1",477],["ADD",400,42,"1",477],["SCALE",42,"-1",477],["ADD",403,41,"-1/2",477],["ADD",401,41,"1",477],["ADD",400,41,"1",477],["ADD",106,41,"1",477],["ADD",42,41,"1",477]],[["MOVE",42,476,1090,false],["MOVE",41,475,1090,false],["ADD",42,41,"1",1090],["ADD",41,42,"-1",1090],["ADD",42,41,"1",1090],["SCALE",41,"-1",1090],["SCALE",41,"-2",1090],["MOVE",400,470,1090,false],["ADD",400,41,"-1",1090],["MOVE",401,472,1090,false],["ADD",401,41,"-1",1090],["SCALE",42,"-2",1090],["MOVE",106,474,1090,false],["ADD",106,42,"1/2",1090],["MOVE",403,471,1090,false],["ADD",403,42,"-1",1090],["MOVE",405,469,1090,false],["ADD",405,106,"1",1090],["ADD",106,405,"-1",1090],["ADD",405,106,"1",1090],["SCALE",106,"-1",1090],["ADD",41,405,"-2",1090],["ADD",405,42,"-1",1090],["ADD",405,403,"-1/2",1090],["ADD",741,403,"1/2",1090],["ADD",741,42,"1",1090],["ADD",41,741,"2",1090],["MOVE",410,473,1090,false],["ADD",410,400,"1",1090],["ADD",400,410,"-1",1090],["ADD",410,400,"1",1090],["SCALE",400,"-1",1090],["SCALE",400,"-2",1090],["ADD",403,401,"1",1090],["ADD",401,403,"-1",1090],["ADD",403,401,"1",1090],["SCALE",401,"-1",1090],["ADD",42,401,"1",1090],["ADD",741,401,"1/2",1090],["ADD",41,403,"1",1090],["ADD",400,403,"1",1090],["ADD",410,403,"-2",1090],["ADD",410,741,"1",1090],["ADD",741,410,"-1",1090],["ADD",410,741,"1",1090],["SCALE",741,"-1",1090],["SCALE",741,"-1/2",1090],["ADD",41,741,"-1",1090],["ADD",400,741,"-1",1090],["ADD",403,741,"-1",1090],["ADD",42,410,"-1",1090],["ADD",106,410,"-1",1090],["ADD",401,410,"-1",1090],["ADD",741,410,"1",1090],["ADD",403,410,"1",1090],["ADD",401,410,"-1",1090],["SCALE",410,"2",1090],["ADD",403,741,"1",1090],["ADD",106,741,"1",1090],["ADD",42,741,"-1",1090],["ADD",410,741,"1",1090],["ADD",741,410,"-1",1090],["ADD",410,741,"1",1090],["SCALE",741,"-1",1090],["ADD",410,403,"-1/2",1090],["ADD",741,403,"-1",1090],["ADD",401,403,"1",1090],["ADD",400,403,"1/2",1090],["ADD",106,403,"-1/2",1090],["ADD",42,403,"1/2",1090],["ADD",41,403,"-1/2",1090],["SCALE",403,"-1/2",1090],["ADD",741,401,"1",1090],["ADD",403,401,"1/2",1090],["ADD",400,401,"-1/2",1090],["ADD",106,401,"1/2",1090],["ADD",42,401,"1/2",1090],["ADD",41,401,"1/2",1090],["SCALE",401,"-2",1090],["ADD",106,400,"1",1090],["ADD",42,400,"1",1090],["ADD",41,400,"-1",1090],["SCALE",400,"2",1090],["ADD",401,400,"1",1090],["ADD",400,401,"-1",1090],["ADD",401,400,"1",1090],["SCALE",400,"-1",1090],["ADD",41,106,"1",1090],["ADD",403,42,"1/2",1090],["MOVE",403,1090,127,false],["MOVE",106,1090,127,false],["ADD",403,106,"1/2",127],["ADD",401,42,"-1",1090],["MOVE",401,1090,127,false],["ADD",401,106,"-1",127],["SCALE",106,"-2",127],["ADD",41,42,"1",1090],["SCALE",42,"-2",1090],["ADD",400,42,"1",1090],["ADD",42,400,"-1",1090],["ADD",400,42,"1",1090],["MOVE",42,1090,127,false],["SCALE",42,"-1",127],["ADD",400,41,"1",1090],["MOVE",41,1090,127,false],["ADD",403,41,"-1/2",127],["ADD",401,41,"1",127],["ADD",106,41,"1",127],["ADD",42,41,"1",127]]],[[["MOVE",41,477,127,false]],[]],[[["MOVE",42,477,127,false]],[]],[[["MOVE",106,477,127,false]],[]],[[["ADD",240,65,"1",477]],[["ADD",240,65,"1",477],["MOVE",400,1090,477,false]]],[[["MOVE",401,477,127,false],["MOVE",410,477,127,false]],[["MOVE",410,1090,127,false]]],[[["MOVE",403,477,127,false]],[]],[[["MOVE",741,477,127,false]],[["MOVE",741,1090,127,false]]]]} \ No newline at end of file diff --git a/research/p104-copy-block-composition/source/R22-NOTICE b/research/p104-copy-block-composition/source/R22-NOTICE new file mode 100644 index 0000000000..36c1b859be --- /dev/null +++ b/research/p104-copy-block-composition/source/R22-NOTICE @@ -0,0 +1,44 @@ +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +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: 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. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained 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 its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. diff --git a/research/p104-copy-block-composition/source/SECOND-CONSTRUCT.py b/research/p104-copy-block-composition/source/SECOND-CONSTRUCT.py new file mode 100644 index 0000000000..a27613d278 --- /dev/null +++ b/research/p104-copy-block-composition/source/SECOND-CONSTRUCT.py @@ -0,0 +1,68 @@ +"""Reframe two exact scalar runs and rebuild every native path. + +The R22 mechanism is by Joel Pulikkan (GamingPuzzled). +This second block is by Ali Romman with OpenAI Codex assistance. Apache-2.0. +""" +from copy import deepcopy +from hashlib import sha256 +import json +from sources import need + + +def construct(source, plan): + word = deepcopy(source) + old = plan['old_frame'] + new = len(word['frames']) + word['frames'].append(plan['basis']) + scalar = [e for e in word['program'] if e[0] != 'MOVE'] + changed, roles = [], set() + for run in plan['runs']: + start, length = run['first_scalar'], run['length'] + block = scalar[start:start+length] + need(len(block) == length, 'Complete scalar run') + raw = json.dumps(block, separators=(',', ':')).encode() + need(sha256(raw).hexdigest() == run['old_sha256'], 'Exact source scalar run') + for i, event in enumerate(block, start): + need(event[0] in ('ADD', 'SCALE') and event[-1] == old, + 'Public scalar operation on the old chart') + need(i not in changed, 'Disjoint scalar runs') + changed.append(i) + roles.update(event[1:3] if event[0] == 'ADD' else event[1:2]) + event[-1] = new + need(len(changed) == 102 and sorted(roles) == plan['roles'], 'Exact changed contact block') + for key, helper in (('initial', plan['initial_helper']), ('final', plan['final_helper'])): + need(word[key][helper] == old, 'Exact old helper boundary') + word[key][helper] = new + + current = word['initial']+[None]*word['owned_fields'] + active, program = set(), [] + + def move(role, frame): + if current[role] != frame: + need(current[role] is not None, 'Transport of a live field') + program.append(['MOVE', role, current[role], frame, role in active]) + current[role] = frame + + for event in scalar: + op, role, frame = event[0], event[1], event[-1] + if op == 'INIT': + need(role not in active, 'New owned lifetime') + active.add(role) + current[role] = frame + elif op == 'CLEAR': + move(role, frame) + active.remove(role) + current[role] = None + else: + move(role, frame) + if op in ('ADD', 'COPY'): + move(event[2], frame) + program.append(event) + for role, frame in enumerate(word['final']): + move(role, frame) + need(not active, 'All owned lifetimes close') + word['program'] = program + word['schema'] = 'p104-second-rank4-block/1' + return word, {'changed_scalar_indices': changed, 'roles': sorted(roles), + 'old_frame': old, 'new_frame': new, 'basis': plan['basis'], + 'initial_helper': plan['initial_helper'], 'final_helper': plan['final_helper']} diff --git a/research/p104-copy-block-composition/source/SECOND-NOTICE b/research/p104-copy-block-composition/source/SECOND-NOTICE new file mode 100644 index 0000000000..d07f993ba2 --- /dev/null +++ b/research/p104-copy-block-composition/source/SECOND-NOTICE @@ -0,0 +1,63 @@ +Second rank-four contact block on the complete PR5756 word. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. These are author-side checks. + +Joel Pulikkan (GamingPuzzled), with Claude Opus 5.5 assistance, supplied the +R22 reframe mechanism and the different block in PR5739/5756. +This package adds a different 102-operation block; it does not claim that mechanism. + +The source PR5756 notice follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +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: 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. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained 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 its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. diff --git a/research/p104-copy-block-composition/source/SECOND-OLD-WORD.json.gz b/research/p104-copy-block-composition/source/SECOND-OLD-WORD.json.gz new file mode 100644 index 0000000000..156ff6d627 Binary files /dev/null and b/research/p104-copy-block-composition/source/SECOND-OLD-WORD.json.gz differ diff --git a/research/p104-copy-block-composition/source/SECOND-PLAN.json b/research/p104-copy-block-composition/source/SECOND-PLAN.json new file mode 100644 index 0000000000..47fa8c4053 --- /dev/null +++ b/research/p104-copy-block-composition/source/SECOND-PLAN.json @@ -0,0 +1,34 @@ +{ + "basis": [ + 11, + 21, + 38, + 448 + ], + "old_frame": 267, + "roles": [ + 57, + 81, + 92, + 224, + 225, + 227, + 229, + 234, + 742 + ], + "initial_helper": 742, + "final_helper": 225, + "runs": [ + { + "first_scalar": 9858, + "length": 90, + "old_sha256": "2c4d8332eed5d21830748b694d88a830f98f50773e7faddfb65b654800d0e296" + }, + { + "first_scalar": 11957, + "length": 12, + "old_sha256": "bcb7d071dbe4b830053892decd7c8b6aef5a26b06a06e010148882871cf07ee2" + } + ] +} diff --git a/research/p104-copy-block-composition/source/SECOND-PROOF.md b/research/p104-copy-block-composition/source/SECOND-PROOF.md new file mode 100644 index 0000000000..d8daa51f7d --- /dev/null +++ b/research/p104-copy-block-composition/source/SECOND-PROOF.md @@ -0,0 +1,91 @@ +# Proof and full cost + +## Exact local change + +Let C(F) be the retained native chart map for binary subspace F. A MOVE from F +to G implements `C(G) C(F)^-1`. The source checker factors each map into its +recursive calls and ordinary operations. It checks the signed Pauli action +and the exact global phase. The frame induction then applies at every positive +tensor width. A scalar instruction acts on registers in one common chart. +Changing that chart preserves its abstract scalar action. + +The constructor uses the two exact runs in PLAN.json. It keeps their scalar +instructions unchanged and assigns the rank-four chart. It rebuilds all MOVE +instructions from the complete scalar sequence. The only changed public +boundary charts belong to helpers 742 and 225. The source contract permits +these free helper endpoints and charges their resulting target transforms. +No main endpoint changes. No helper input is assumed to be zero. + +`verify.py` checks every scalar coefficient on all 767 public inputs and nine +owned coordinates. It separately checks every transpose column in reverse +chronological order. The native replay checks all maps and phases, every main +adapter and every helper normalizer. Thus this check includes the boundary +cost, not just the interior rank-four operations. + +The local paid profile is: + +```text +rank: 1 2 3 4 5 6 7 +count: 2221 454 492 94 173 6 15 +``` + +The local productive helper profile is: + +```text +rank: 1 2 4 5 7 8 9 +count: 23 5 93 8 6 36 388 +``` + +Compared with the frozen source, the paid delta is `H1+H4-H5` and the helper +delta is `-H1+H4+H5-H8`. Paid rank mass stays 5,987. The scalar allowance stays +224,138. There are eleven owned lifetimes and at most two live owned fields. + +## Physical caller and complete price + +The unchanged productive controller makes eighteen full local calls. It also +pays fifteen thin queries, each of cost `104 H1`, and fifteen whole idles. +The idle ranks are `8L`: two instances of each L from two through eight and +one instance of L=9. Each instance costs 208 such jobs. + +Its main productive targets are `208 H145` and the fifteen idles with rank +increased by one. The full target profile is this main profile plus eighteen +copies of the local helper profile. The full paid profile is eighteen copies +of the local paid profile plus all thin queries and all whole idles. +The physical replay checks each contact and each central-square column. +The full profiles appear literally in RESULT.json. They contain 13,390 targets +and 66,870 paid calls, with rank-mass surplus 760. + +For a saving k, set `t=1-k`. The raw condition compares the complete moments +`sum(T[r] r^t)` and `sum(P[r] r^t)`. Both exact rational interval engines give +a positive margin at the tested saving `0.003113259895`. They put the raw zero +in `(0.00311325991155, 0.00311325991156)`. The retained derivative bound is +negative throughout `[0,0.0034]`, which gives the fixed-profile ceiling. +The old complete source profile has a strictly negative upper margin at the +new claimed kappa. This proves a new profile gain, not extra decimal places +from the old profile. + +The completion proof uses cutoff 16, floor 17, tail offset 1/7, decay 125/128, +power 1024 and reserve 1e-12. It bounds the whole tail, productive stock and +normalized paid cost. The compiler checks all 54 strict inequalities and +four functional conditions. It includes ordinary scalar operations, +COPY/CLEAR, restoration, native adapters, thin queries, idles and routes. +The inherited BIT saving is 0.0034. The complex cost binds the resulting +conditional multiplication saving `0.00311325989`. + +`PRICING-EDITS.json` declares all edits to the archived PR #5751 pricing code: +the claim and tested value, previous claim, full paid-call count, result label +and attribution. The verifier requires those exact edits. It does not weaken +any mathematical price predicate. + +## Failure controls and limits + +The replay rejects an old helper entry, an old block chart, a missing native +MOVE, a wrong scalar coefficient, an unpaid query, an extra target credit, +a damaged source byte and a missing central translation. The native checker +also rejects the wrong global phase. Explicit exceptions preserve these checks +under Python `-O`. + +The finite receipts and inherited frame induction remain conditional on the +five framework assumptions listed in README.md. They do not materialize a +uniform word or rounded multiplier. These are author checks. Independent +review and any selected-frontier admission are separate obligations. diff --git a/research/p104-copy-block-composition/source/SECOND-WORD.json.gz b/research/p104-copy-block-composition/source/SECOND-WORD.json.gz new file mode 100644 index 0000000000..b2e351e1ab Binary files /dev/null and b/research/p104-copy-block-composition/source/SECOND-WORD.json.gz differ diff --git a/research/p104-copy-block-composition/source/pr5774-export.tar b/research/p104-copy-block-composition/source/pr5774-export.tar new file mode 100644 index 0000000000..f34972476e Binary files /dev/null and b/research/p104-copy-block-composition/source/pr5774-export.tar differ diff --git a/research/p104-copy-block-composition/source/pr5786-export.tar b/research/p104-copy-block-composition/source/pr5786-export.tar new file mode 100644 index 0000000000..450c1490f3 Binary files /dev/null and b/research/p104-copy-block-composition/source/pr5786-export.tar differ diff --git a/research/p104-copy-block-composition/sources.py b/research/p104-copy-block-composition/sources.py new file mode 100644 index 0000000000..c6fc4ca279 --- /dev/null +++ b/research/p104-copy-block-composition/sources.py @@ -0,0 +1,73 @@ +"""Authenticate the retained PR5786 export before any source import. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +Rebound to the public PR5786 checkpoint by Ali Romman with substantial OpenAI Codex assistance. +The archive checks follow the repository exporter and flyingviper's PR5613. +""" +from contextlib import contextmanager +from hashlib import sha1, sha256 +from pathlib import Path, PurePosixPath +import importlib.util +import io +import json +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +@contextmanager +def sources(): + pins = json.loads((HERE/'SOURCES.json').read_bytes()) + for row in pins['direct_sources']: + payload = (HERE/row['local_path']).read_bytes() + need(sha256(payload).hexdigest() == row['sha256'], 'Exact direct source SHA256') + need(sha1(b'blob '+str(len(payload)).encode()+b'\0'+payload).hexdigest() == row['git_blob'], + 'Exact direct source Git blob') + pin = pins['source_export'] + raw = (HERE/pin['local_path']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'], 'Exact predecessor archive SHA256') + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], + 'Exact retained archive Git blob') + with tempfile.TemporaryDirectory(prefix='p104-paid-main-source-') as directory: + root, names = Path(directory), set() + with tarfile.open(fileobj=io.BytesIO(raw), mode='r:*') as bundle: + for member in bundle.getmembers(): + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts + and '\\' not in member.name and ':' not in member.name, + 'Regular relative source path') + need(member.name not in names, 'Unique source path') + names.add(member.name) + target = root.joinpath(*path.parts) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(bundle.extractfile(member).read()) + manifest = json.loads((root/'.research-export.json').read_bytes()) + need(manifest['commit'] == pin['commit'] and manifest['package'] == pin['package'] + and len(manifest['files']) == pin['files'], 'Exact source commit and inventory') + need(names == {'.research-export.json'} | {r['path'] for r in manifest['files']}, + 'No missing or additional source payload') + origins = {row['path']: row for row in pins['archived_files']} + for row in manifest['files']: + origin = origins[row['path']] + need(origin['pin'] == 'head:'+pin['commit']+':'+row['path'] + and origin['sha256'] == row['sha256'], + 'Export payload has an exact source pin') + payload = (root/row['path']).read_bytes() + need(len(payload) == row['size'] and sha256(payload).hexdigest() == row['sha256'], + 'Authenticated payload: '+row['path']) + yield root/pin['package'], root diff --git a/research/p104-copy-block-composition/verify.py b/research/p104-copy-block-composition/verify.py new file mode 100644 index 0000000000..c6ae871982 --- /dev/null +++ b/research/p104-copy-block-composition/verify.py @@ -0,0 +1,182 @@ +"""Replay the complete retained-copy and R22 composition. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +All source construction, native, caller and compiler credit remains in NOTICE. +""" +import argparse +from collections import Counter +from contextlib import ExitStack +from copy import deepcopy +from fractions import Fraction as Q +import gzip +import json +from pathlib import Path +import sys +import tempfile + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from sources import sources, load, need +from construct import construct, digest + + +def declared_price(parent): + text = (parent/'pricing.py').read_text() + for before, after in json.loads((HERE/'PRICING-EDITS.json').read_bytes()): + need(text.count(before) == 1, 'One declared price edit') + text = text.replace(before, after) + need(text == (HERE/'pricing.py').read_text(), 'Only declared price changes') + + +def reject(action): + try: + action() + except ValueError as error: + return str(error) + raise ValueError('Invalid composition accepted') + + +def delta(before, after): + values = Counter(after) + values.subtract(before) + return {r: n for r, n in values.items() if n} + + +def controls(source, word, L): + out = {} + bad = deepcopy(word) + bad['initial'][741] = source['initial'][741] + out['omit_R22_input_endpoint'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + bad['final'][405] = source['final'][405] + out['retain_old_R22_target'] = reject(lambda: L.replay(bad)) + move = next(i for i, e in enumerate(word['program']) + if e[0] == 'MOVE' and e[1] == 41 and e[3] == 1090) + bad = deepcopy(word) + del bad['program'][move] + out['omit_paid_R22_query'] = reject(lambda: L.replay(bad)) + first_cache = word['public'] + 9 + move = next(i for i, e in enumerate(word['program']) if e[0] == 'MOVE' and e[1] >= first_cache) + copy = next(i for i, e in enumerate(word['program']) if e[0] == 'COPY' and e[1] >= first_cache) + clear = next(i for i, e in enumerate(word['program']) if e[0] == 'CLEAR' and e[1] >= first_cache) + bad = deepcopy(word) + del bad['program'][move] + out['omit_paid_copy_query'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + bad['program'][copy][-2] = '2' + out['wrong_copy_value'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + del bad['program'][clear] + out['omit_copy_clear'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + bad['initial'][742] = source['initial'][742] + out['omit_second_block_input'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + bad['final'][225] = source['final'][225] + out['omit_second_block_output'] = reject(lambda: L.replay(bad)) + bad = deepcopy(word) + move = next(i for i, e in enumerate(bad['program']) if e[0] == 'MOVE' and e[3] == 1092) + del bad['program'][move] + out['omit_second_block_query'] = reject(lambda: L.replay(bad)) + return out + + +def fixed_grid(price, L): + E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py', 'composed_grid_intervals') + targets = {int(k): v for k, v in price['targets'].items()} + paid = {int(k): v for k, v in price['paid'].items()} + reserve, step, gap, cap = Q(1, 10**12), Q(1, 10**14), Q(5, 10**12), Q('.0034') + claim, tested = Q(price['kappa']), Q(price['strictification']['tested']) + need((tested/step).denominator == 1 and tested-claim == gap, 'Fixed published/tested grid') + def margin(c): + t, p = E.moment(targets, 1-c), E.moment(paid, 1-c) + return ((1-reserve)*t[0]-p[1], (1-reserve)*t[1]-p[0]) + positive, negative = margin(tested), margin(tested+step) + need(positive[0] > 0 and negative[1] < 0, 'The next tested grid point fails the fixed reserve') + derivative_upper = Q(0) + for rank in set(targets) | set(paid): + count = (1-reserve)*targets.get(rank, 0)-paid.get(rank, 0) + logarithm = E.log_bounds(rank) + low = E.mul(E.power(rank, 1-cap), logarithm)[0] + high = rank*logarithm[1] + derivative_upper -= count*(low if count >= 0 else high) + need(derivative_upper < 0, 'Fixed-reserve margin decreases on the entire retained BIT interval') + return dict(grid=step, tested_gap=gap, reserve=reserve, cap=cap, + largest_published_grid=claim, largest_tested_grid=tested, next_tested_grid=tested+step, + accepted_margin=positive, rejected_margin=negative, derivative_upper=derivative_upper, + scope='Maximum on the 1e-14 grid for this exact profile, fixed reserve and tested gap. Different compiler parameters, words and BIT caps remain outside this claim.') + + +def run(): + with ExitStack() as stack: + parent, _ = stack.enter_context(sources()) + cursor = parent + for depth in range(7): + cursor, root = stack.enter_context(load(cursor/'sources.py', 'copy_block_source_'+str(depth)).sources()) + declared_price(parent) + L = load(parent/'local.py', 'local') + L.ROOT = root + source, old = L.read(parent/'WORD.json.gz'), L.read(parent/'RESULT.json') + need(digest(source) == old['canonical_word_sha256'], 'Exact published retained-copy word') + baseline = L.replay(source) + need(json.loads(json.dumps(baseline)) == old['local'], 'Exact source local receipt') + word, witness = construct(source) + local = L.replay(word) + transpose = L.reverse_columns(word) + need((local['public_inputs'], local['owned_fields'], local['owned_lifetimes'], local['peak_owned_fields']) + == (770, 25, 27, 13), 'Complete arbitrary-input and storage inventory') + need(local['real_scalar_allowance'] == baseline['real_scalar_allowance'], 'No extra scalar allowance') + change = dict(paid=delta(baseline['paid'], local['paid']), targets=delta(baseline['helpers'], local['helpers'])) + need(change == {'paid': {1: 2, 4: 2, 5: -2}, 'targets': {1: -2, 4: 2, 5: 2, 8: -2}}, + 'Exact changed paid and target profiles') + negative = controls(source, word, L) + print('PASS composition, all795 scalar inputs, transpose and owned lifetimes', flush=True) + native = L.native(word) + C = load(root/'research/p104-productive-controller/caller.py', 'copy_block_caller') + caller = C.construct() + need(caller == L.read(root/'research/p104-productive-controller/CONTROLLER.json'), 'Exact source physical caller') + physical = C.physical(caller, word) + print('PASS every native phase and complete physical caller', flush=True) + P = load(HERE/'pricing.py', 'copy_block_price') + price = P.run(local, native, caller, physical) + grid = fixed_grid(price, L) + need(price['previous_pr5786'] == old['complete_cost']['kappa'], 'Exact predecessor claim') + negative.update(C.controls(caller)) + bad = deepcopy(local) + bad['paid'][1] -= 1 + negative['omit_query_from_invoice'] = reject(lambda: P.assemble(bad, native, caller, physical)) + bad = deepcopy(local) + bad['helpers'][8] += 1 + negative['retain_obsolete_helper_credit'] = reject(lambda: P.assemble(bad, native, caller, physical)) + result = dict(status='PASS_P104_COMPOSED_BLOCKS_KAPPA_00312289583377', + source_commit='6b936acd68a7e0f9062037900f0fe9bc4b6fdd25', + canonical_word_sha256=digest(word), instructions=len(word['program']), + source_local=baseline, local=local, delta=change, separate_columns=transpose, + native=native, physical_caller=physical, complete_cost=price, negative_controls=negative, + fixed_contract_grid_optimum=grid, + limits=['Five inherited framework assumptions remain.', 'Independent scientific acceptance is pending.', + 'The large uniform word and rounded multiplier are not materialized.', 'The selected frontier is unchanged.']) + return P.encode(result), witness, word + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + with tempfile.TemporaryDirectory(prefix='copy-block-bytecode-') as cache: + sys.pycache_prefix = cache + result, witness, word = run() + for name, value in (('RESULT.json', result), ('HUNKS.json', witness), ('WORD.json.gz', word)): + path = HERE/name + if args.write: + raw = (json.dumps(value, sort_keys=True, indent=2)+'\n').encode() + path.write_bytes(gzip.compress(raw, mtime=0) if name.endswith('.gz') else raw) + else: + raw = path.read_bytes() + need(json.loads(gzip.decompress(raw) if name.endswith('.gz') else raw) == value, 'Exact retained output: '+name) + print(result['status']) + + +if __name__ == '__main__': + main()