diff --git a/research/staged-644-660-owner-successor/ADAPTATIONS.json b/research/staged-644-660-owner-successor/ADAPTATIONS.json new file mode 100644 index 0000000000..23f7da33c0 --- /dev/null +++ b/research/staged-644-660-owner-successor/ADAPTATIONS.json @@ -0,0 +1,20 @@ +{ + "changes": [ + "explicit source/literal/native/predecessor/output paths", + "complete decompressed predecessor payload equality replaces regenerated gzip container equality" + ], + "fixed_inventory_dual": { + "adapted_sha256": "639820c9ccf72b88ae16768055ec5500a66004784f57a2fa5f218bf4d2e4ee05", + "changes": [ + "Retain complete Cartesian pattern enumeration, exact basis solve, every reduced-cost sign and all three root enclosures.", + "Remove local budget/owner/outer receipt comparisons; all mathematical quantities are recomputed.", + "Resolve authenticated PR3531 source from explicit predecessor archive argument.", + "Replace every assertion with explicit ValueError, preserving conditions under optimized Python." + ], + "original_sha256": "7c055c464ef5d422e976d1f61a26953681db0be94e94cfa12c46038063b041d7", + "source": "conditional-review/review_budget.py (separate local mathematical review)" + }, + "independent_owner_adapted_sha256": "8d02dff267938cdb373aa617a411d8e67700e130609d2714e98ccf814e32eaef", + "independent_owner_source_sha256": "778887542c162f4b665b8ed70b583f69e557a968befa68acf7d4cabb35d0f68e", + "unchanged": "All2,717,280-row chronology/family/active-pair/prefix/invoice checks; exact five owner destinations and24-row differential; original five local predicate controls (not whole-journal corruption claims)." +} diff --git a/research/staged-644-660-owner-successor/ARTIFACTS.json b/research/staged-644-660-owner-successor/ARTIFACTS.json new file mode 100644 index 0000000000..520d85b7c3 --- /dev/null +++ b/research/staged-644-660-owner-successor/ARTIFACTS.json @@ -0,0 +1,17 @@ +{ + "ADAPTATIONS.json": "8d19ca6b4ca5a55ce6253fbde0fb41e761c63d32af555b046472861facce49a4", + "CLAIM.json": "aa4f56010fd4c1e620c742a091932ef3af05cca13886915c1c44f30e9f961aab", + "JOURNAL.json": "8a13c2d03ca4cf1bdadabda373e8b02f3b620a5d02b6ae232ccff4a659f2966f", + "apply_journal.py": "a63a0a6fc4f1e7bfff72c92a4bad69cfa99778a5e1c7a7d2b0cccc39dac621af", + "check.py": "c6f9d552a63fdd8e27f4bc44515dc19220e4eecc9634b9955744accdcd724287", + "check_budget.py": "639820c9ccf72b88ae16768055ec5500a66004784f57a2fa5f218bf4d2e4ee05", + "check_release_binding.py": "1cef4fefeca83fa04eb7758d2a3304d62e4026cba2b240277413ceaec5237661", + "evidence/ACTUAL-RELEASE.tar.gz": "46f61dfd4f38d184bddc7aa1737eadfc834f30199edf5ae8761516fd10f0a17b", + "evidence/MANIFEST.json": "8b6dcb4667b923c14afba91510ab48dcaa3661c455f80d60d37fd01cfc342ad1", + "independent_owners.py": "8d02dff267938cdb373aa617a411d8e67700e130609d2714e98ccf814e32eaef", + "predecessor.py": "0b80a7c56f291c676fd1fc5b852716287f006278a2019220146bf658e013c33a", + "reproduce.py": "84bebf6ca3484474056a50a98790fe948e27361887ece249ea6f5bf50f2b9730", + "vendor/PR3605-MANIFEST.json": "9ad414a6dca4cff40b376ac8c3d6a039a85f19e6611ea4e649af354b74e0928e", + "vendor/PR3605-SOURCES.tar.gz": "c00e3d494295e2d069c7abb210676ca0ff0ff95f68d467c8552960fe78a4fed6", + "verify.py": "91110e50c6a201dfc5d1510819d8a5e8f015500390489727d73d0251d1b7f545" +} diff --git a/research/staged-644-660-owner-successor/CLAIM.json b/research/staged-644-660-owner-successor/CLAIM.json new file mode 100644 index 0000000000..f82fff3586 --- /dev/null +++ b/research/staged-644-660-owner-successor/CLAIM.json @@ -0,0 +1,40 @@ +{ + "actual_chart_count": 8758, + "actual_controller_controls": 25, + "charged_prefix_bits": 2048, + "complex_lower": "0.001730006690311348872326", + "complex_upper": "0.001730006690311348872327", + "exact_gain_over_PR3605": "140772507025321/1000000000000000000000000", + "final_review_sha256": "b462df012121d234437541e0873d32fb9c5f881374438a61899a32b6cd009cda", + "generated_package_manifest_sha256": "d6aa8f2c029beb040f3c65df5906cf2c748b881245cb2d50ef0435321dc787de", + "histogram": { + "1": 16417892, + "2": 4835160, + "3": 1540174, + "4": 679320, + "48": 283185, + "5": 143993, + "7": 3, + "8": 53280 + }, + "idle": { + "1": 174152, + "3": 48334, + "48": 283185, + "5": 10793, + "7": 3 + }, + "kappa": "17300066903113488723259999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017300066903113488723259999999999999999999998999999999999999999999999", + "live": 663040, + "physical": 663549, + "predecessor_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "prefix_bits": 1479, + "release_receipt_sha256": "ee5e3f2d4d75fd7596f736e03c680b65441f032d1346dccbec4678b6975e40d7", + "reserved_prefix_bits": 1512, + "roles": 2717280, + "row_coefficient": 19551, + "scope": "No finite release binding gap found in this scope. Publication checks and maintainer adoption remain separate. All inherited all-size/compiler/uniform coefficient and stock/physical hosting/SCALAR-COPY-CLEAR/zero-allocation/internal rounding/tape/bootstrap time/PR559/recovery/analytic/BIT H1-H5 hypotheses remain conditional; no unconditional or formal-kernel theorem.", + "source_manifest_sha256": "adb145b4f36ca330c34c0dbdb847351dafdc4ca9cd7bb4e1de01ed634d96bfe1", + "status": "CONDITIONAL_RELEASE_BOUND" +} diff --git a/research/staged-644-660-owner-successor/JOURNAL.json b/research/staged-644-660-owner-successor/JOURNAL.json new file mode 100644 index 0000000000..e70921317d --- /dev/null +++ b/research/staged-644-660-owner-successor/JOURNAL.json @@ -0,0 +1,699 @@ +{ + "all_changed_rows": [ + { + "index": 16544, + "new": [ + 40, + 224, + 22, + 6, + 111, + 0 + ], + "old": [ + 40, + 224, + 669, + 2, + 38, + 0 + ] + }, + { + "index": 16545, + "new": [ + 40, + 225, + 25, + 6, + 111, + 0 + ], + "old": [ + 40, + 225, + 669, + 2, + 39, + 0 + ] + }, + { + "index": 16546, + "new": [ + 40, + 226, + 135, + 6, + 26, + 0 + ], + "old": [ + 40, + 226, + 669, + 2, + 40, + 0 + ] + }, + { + "index": 46578, + "new": [ + 114, + 66, + 669, + 2, + 38, + 0 + ], + "old": [ + 114, + 66, + 669, + 2, + 38, + 6 + ] + }, + { + "index": 46579, + "new": [ + 114, + 67, + 669, + 2, + 39, + 0 + ], + "old": [ + 114, + 67, + 669, + 2, + 39, + 6 + ] + }, + { + "index": 46580, + "new": [ + 114, + 68, + 669, + 2, + 40, + 0 + ], + "old": [ + 114, + 68, + 669, + 2, + 40, + 6 + ] + }, + { + "index": 130613, + "new": [ + 320, + 53, + 703, + 12, + 0, + 0 + ], + "old": [ + 320, + 53, + 190, + 4, + 56, + 27 + ] + }, + { + "index": 193721, + "new": [ + 474, + 329, + 22, + 6, + 111, + 6 + ], + "old": [ + 474, + 329, + 22, + 6, + 111, + 0 + ] + }, + { + "index": 418634, + "new": [ + 1026, + 26, + 25, + 6, + 111, + 6 + ], + "old": [ + 1026, + 26, + 25, + 6, + 111, + 0 + ] + }, + { + "index": 644978, + "new": [ + 1580, + 338, + 25, + 6, + 111, + 15 + ], + "old": [ + 1580, + 338, + 25, + 6, + 111, + 9 + ] + }, + { + "index": 708696, + "new": [ + 1737, + 0, + 703, + 12, + 0, + 4 + ], + "old": [ + 1737, + 0, + 703, + 12, + 0, + 0 + ] + }, + { + "index": 709104, + "new": [ + 1738, + 0, + 703, + 12, + 0, + 13 + ], + "old": [ + 1738, + 0, + 703, + 12, + 0, + 9 + ] + }, + { + "index": 709512, + "new": [ + 1739, + 0, + 703, + 12, + 0, + 22 + ], + "old": [ + 1739, + 0, + 703, + 12, + 0, + 18 + ] + }, + { + "index": 766632, + "new": [ + 1879, + 0, + 22, + 6, + 111, + 14 + ], + "old": [ + 1879, + 0, + 22, + 6, + 111, + 8 + ] + }, + { + "index": 881620, + "new": [ + 2160, + 340, + 22, + 6, + 111, + 23 + ], + "old": [ + 2160, + 340, + 22, + 6, + 111, + 17 + ] + }, + { + "index": 959172, + "new": [ + 2350, + 372, + 25, + 6, + 111, + 24 + ], + "old": [ + 2350, + 372, + 25, + 6, + 111, + 18 + ] + }, + { + "index": 1109354, + "new": [ + 2719, + 2, + 703, + 12, + 0, + 31 + ], + "old": [ + 2719, + 2, + 703, + 12, + 0, + 27 + ] + }, + { + "index": 1226569, + "new": [ + 3006, + 121, + 135, + 6, + 26, + 6 + ], + "old": [ + 3006, + 121, + 135, + 6, + 26, + 0 + ] + }, + { + "index": 1226977, + "new": [ + 3007, + 121, + 135, + 6, + 26, + 15 + ], + "old": [ + 3007, + 121, + 135, + 6, + 26, + 9 + ] + }, + { + "index": 1355192, + "new": [ + 3321, + 224, + 18, + 15, + 111, + 0 + ], + "old": [ + 3321, + 224, + 135, + 6, + 26, + 18 + ] + }, + { + "index": 1378632, + "new": [ + 3379, + 0, + 703, + 12, + 0, + 39 + ], + "old": [ + 3379, + 0, + 703, + 12, + 0, + 35 + ] + }, + { + "index": 1689027, + "new": [ + 4139, + 315, + 18, + 15, + 111, + 6 + ], + "old": [ + 4139, + 315, + 18, + 15, + 111, + 0 + ] + }, + { + "index": 1714324, + "new": [ + 4201, + 316, + 18, + 15, + 111, + 14 + ], + "old": [ + 4201, + 316, + 18, + 15, + 111, + 8 + ] + }, + { + "index": 1714756, + "new": [ + 4202, + 340, + 18, + 15, + 111, + 23 + ], + "old": [ + 4202, + 340, + 18, + 15, + 111, + 17 + ] + } + ], + "delta": { + "1": -4, + "4": -1, + "5": 1, + "6": -3, + "7": 3 + }, + "idle": { + "1": 174152, + "3": 48334, + "5": 10793, + "7": 3, + "48": 283185 + }, + "moves": [ + { + "delta": { + "1": -1, + "6": -1, + "7": 1 + }, + "helper": 224, + "index": 16544, + "new": [ + 40, + 224, + 22, + 6, + 111, + 0 + ], + "new_owner": [ + 22, + 6, + 111 + ], + "old": [ + 40, + 224, + 669, + 2, + 38, + 0 + ], + "reason": "admitted direct concentration", + "source_window": [ + -1, + 238 + ], + "target_window": [ + -1, + 3220 + ], + "time": 40, + "width": 6 + }, + { + "delta": { + "1": -1, + "6": -1, + "7": 1 + }, + "helper": 225, + "index": 16545, + "new": [ + 40, + 225, + 25, + 6, + 111, + 0 + ], + "new_owner": [ + 25, + 6, + 111 + ], + "old": [ + 40, + 225, + 669, + 2, + 39, + 0 + ], + "reason": "admitted direct concentration", + "source_window": [ + -1, + 238 + ], + "target_window": [ + -1, + 3700 + ], + "time": 40, + "width": 6 + }, + { + "delta": { + "1": -1, + "4": -1, + "5": 1 + }, + "helper": 53, + "index": 130613, + "new": [ + 320, + 53, + 703, + 12, + 0, + 0 + ], + "new_owner": [ + 703, + 12, + 0 + ], + "old": [ + 320, + 53, + 190, + 4, + 56, + 27 + ], + "reason": "admitted direct concentration", + "source_window": [ + -1, + 1005 + ], + "target_window": [ + 319, + 3419 + ], + "time": 320, + "width": 4 + }, + { + "delta": {}, + "helper": 224, + "index": 1355192, + "new": [ + 3321, + 224, + 18, + 15, + 111, + 0 + ], + "new_owner": [ + 18, + 15, + 111 + ], + "old": [ + 3321, + 224, + 135, + 6, + 26, + 18 + ], + "reason": "cost-neutral width-six vacancy relay", + "source_window": [ + -1, + 3543 + ], + "target_window": [ + 3320, + 5720 + ], + "time": 3321, + "width": 6 + }, + { + "delta": { + "1": -1, + "6": -1, + "7": 1 + }, + "helper": 226, + "index": 16546, + "new": [ + 40, + 226, + 135, + 6, + 26, + 0 + ], + "new_owner": [ + 135, + 6, + 26 + ], + "old": [ + 40, + 226, + 669, + 2, + 40, + 0 + ], + "reason": "strict concentration at relayed vacancy", + "source_window": [ + -1, + 238 + ], + "target_window": [ + -1, + 3543 + ], + "time": 40, + "width": 6 + } + ], + "profile": { + "1": 16417892, + "2": 4835160, + "3": 1540174, + "4": 679320, + "5": 143993, + "7": 3, + "8": 53280, + "48": 283185 + }, + "repack": { + "affected_bins": 8, + "bins": 1208655, + "changed_offsets": 21 + }, + "source_binding": { + "source_fill_sha256": "8a87c77142b135aa0aae56ff00fcd266cf0b36b6d595bca5a38f528de324695f", + "source_payload_sha256": "653085641ff2e9470e25aedfc92861ec34e5cf594d52123e8b28b6f0ec20b9f8", + "source_rows_sha256": "917d6cbe4d85bec9eb75087b7f2ca4170284b3f92832591508964bf3ce76b3e6" + }, + "status": "FIVE_OWNER_MOVES_AND_COMPLETE_CHRONOLOGICAL_OFFSET_REPACK", + "unchanged_time_helper_columns": true +} diff --git a/research/staged-644-660-owner-successor/PROOF.md b/research/staged-644-660-owner-successor/PROOF.md new file mode 100644 index 0000000000..aa7f9810ae --- /dev/null +++ b/research/staged-644-660-owner-successor/PROOF.md @@ -0,0 +1,92 @@ +# Sparse owner witness and fixed-inventory bound + +## Exact changed domain + +The predecessor is PR3605 at 3efbb5de06a49ffeea6684482f2d3fe48cdca3fb. +The five owner destinations in JOURNAL.json are a single nominated construction, +not a purported exhaustive search domain. It moves rows 16544,16545,130613, +1355192 and16546; row 1355192 is the cost-neutral vacancy relay required by the +last move. The complete before/after journal lists all 24 changed rows. Exact +source payload hashing and each row's preimage prohibit an undeclared change. +The independent checker reconstructs every source window and helper width from +pinned PLAN/TEMPLATE and both native frame tables; it checks every literal row +and chronological offset without importing the producer or its optimizer. +Its full predecessor comparison checks unchanged ORDER/DISPATCH/PROVIDERS and +exactly five destinations plus 24 total changed rows. The original journal's +word `admitted` describes local window/family feasibility, not strict release. + +## Complete paid histogram + +For dimension m=73, T=740 and live stock W=896T=663040, define +`M_H(b)=sum_r H_r*(r/73)^(1-b)/W`. The local profile per call remains +`{1:2439,2:726,3:224,4:102,5:20,8:8}` and there are 9T calls. The independent +literal audit derives idle profile +`{1:174152,3:48334,5:10793,7:3,48:283185}`. Adding the local children gives the +complete H in README. Its rank mass is 48,165,120; physical stock is 663549, +including 408 reserved helper rows, eight centres,91 zero buffers and two +coefficient fields. Rank seven now has three paid idle children; rank six is +absent. These are actual invoice changes, not a precision-only improvement. + +The complete histogram delta is +`-4e1-e4+e5-3e6+3e7=(-e1-e4+e5)+3(-e1-e6+e7)`. +Its rank mass is zero. For 00. Thus both absorptions strictly lower the whole +moment throughout 0=T*y.q for every feasible fractional x with right +side Tq. The basis attains equality in this relaxation. Adding the same 9T local +bill and dividing by 73W leaves a normalized moment independent of T. Therefore +every actual packing with the stated fixed data has root strictly below +`.001730096363528623534231`, for every positive integer T. Fractional basis +amounts are allowed even if T is not divisible by four; their integrality at 740 +does not prove a chronological realization. No packing optimum for the real +source-window/family constraints, changed-word cap or formal-kernel proof follows. + +The fraction of the predecessor-to-relaxation gap realized by A lies strictly +between `(CA-C0)/(ceiling_upper-C0)` and `(CA-C0)/(ceiling_lower-C0)`, approximately +0.001567. The attained gain is tiny; a substantially higher κ requires changing +at least one fixed premise and charging every resulting cost. PR3148's earlier +cap used the preceding local inventory and cannot substitute for this new dual. + +## Stronger concurrent candidate + +PR3624 at 515a7c4490aa32ac3ca5014feb6f7da0d6952863 combines a 45-replica base +chronology with 10 copies. Its 405 source groups have capacity totals 45 times +`{8:672,16:448,32:448,48:448}`; its declared six-width inventory and local profile +are exactly those above. Its invoice has live 896*450 and 9*450 copies of the +local bill. Thus the same relaxation contains its declared packing model. +Its root lower bound `.001730047552093344159584` exceeds our five-move witness +but lies below the proved ceiling. This is a source-premise comparison, not a +fresh verification of its 1,652,400 literal roles or its complete release. +The claim here is an independently replayable ceiling with one fully released +feasible witness, not a new current-best endpoint or a real-packing optimum. diff --git a/research/staged-644-660-owner-successor/README.md b/research/staged-644-660-owner-successor/README.md new file mode 100644 index 0000000000..0f46d29b9d --- /dev/null +++ b/research/staged-644-660-owner-successor/README.md @@ -0,0 +1,121 @@ +# An all-T packing ceiling for the staged 644/660 supplier + +This package independently certifies a strict fixed-inventory ceiling +`C < 0.001730096363528623534231` for every positive integer replica count. +The proof covers all 2,551 packing patterns and explicitly relaxes chronology +and physical-family constraints. It does not assert attainability or bound +changed supplier constructions. + +A completed five-owner witness provides a concrete lower endpoint, but it is +**not the best reported candidate**. During final overlap review, +[PR3624](https://github.com/CrocSwap/integer-mult-bounds/pull/3624) at +`515a7c4490aa32ac3ca5014feb6f7da0d6952863` reported the higher +`C=.001730047552093344159584` using T450 and physical stock 403709. +Its pinned certificate and invoice retain the exact capacities, inventory, +local profile and live-stock scaling covered by this dual. Its reported full +release and hosted CI are distinct from our source-premise inspection; we have +not rerun its complete admission. Its portable fresh-native cold tail remains +unexecuted according to that source. The independently reproducible all-T +ceiling is the primary contribution here. + +This package changes five whole-helper owner destinations in the exact PR3605 +T740 construction. The complete literal differs in 24 rows, including 21 +chronological offset changes. Both local words, 408 ordered helper roles, +91 private zero buffers, source order and dispatch are unchanged. + +The fresh finite replay regenerates all 2,717,280 predecessor rows from the +compact integer primal, applies the sparse journal, and independently checks +every candidate identity, width, strict-lower/closed-upper source window, +physical family, active data-pair exclusion and chronological prefix. It derives + +``` +H={1:16417892,2:4835160,3:1540174,4:679320, + 5:143993,7:3,8:53280,48:283185}. +C in (0.001730006690311348872326,0.001730006690311348872327). +``` + +The released conditional endpoint is `K=C_lower-10^-46-10^-70`. This is a packing gain +of exactly `1.40772507025321e-10` over PR3605's rational K. The complete original strict release and separate final binding both pass. +The changed global idle operators, controller, invoice and prefix costs were +checked in that release; both unchanged local native providers were explicitly +authenticated reuse. See [CLAIM.json](CLAIM.json), [RELEASE.md](RELEASE.md) and +[STAGE-SCOPE.json](STAGE-SCOPE.json). + +The same replay independently certifies all 2,551 patterns in the applicable +changed-inventory relaxation. Its strict ceiling is +`0.001730096363528623534231` for every positive integer replica count with the +stated inventory, capacities, local bill, dimension and live stock. Candidate A +realizes about 0.1567% of the remaining relaxed gap above PR3605; attainment of +the relaxed ceiling is unknown. This is neither an optimizer claim nor a cap on +changed words or other supplier models. [PROOF.md](PROOF.md) gives the exact +model, sparse-delta proof and all-T scaling argument. + +## Reproduction + +With Python 3.12 and `numpy==2.5.4`, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/staged-644-660-owner-successor +``` + +The single registered command has a 600-second bound. It performs fresh owner +construction, complete independent audit, three exact moment methods, all 63 +modern strict inequalities and 17 controls, all 47 bootstrap inequalities and +four controls, the original four integer-primal controls, six journal controls, +five independent local owner-predicate controls, and the exhaustive dual. +The optimized-parent replay took 85.5 seconds on the author's Mac. +The recorded full-release binding is checked against that fresh arithmetic. +See [VALIDATION.md](VALIDATION.md). + +Direct Git-free replay of a committed export uses: + +```sh +python3.12 -O -B research/staged-644-660-owner-successor/verify.py --repo . --out /tmp/fresh-owner-successor +``` + +The output must be fresh and outside the package. The wrapper retains an +unoptimized child for inherited assertion-based validators and uses a private +bytecode namespace. Complete decompressed literal payloads, not regenerated +gzip streams, are the semantic admission gate. Immutable archived source bytes +retain both SHA256 and original Git blob identities; Git export reads disable +replacement refs. See [VENDOR.json](VENDOR.json) and [ADAPTATIONS.json](ADAPTATIONS.json). + +The long [reproduce.py](reproduce.py) wrapper retains the original source/native +preparation and full admission. It requires the historical Git objects named +in the archived predecessor FETCH.txt. It is separate from the bounded command; +its end-to-end cold tail has not been run. Authenticated source +and native-cache reuse in the completed actual release is explicitly different +from a fresh cold native run. + +## Scope and inherited premises + +This is a finite construction, exhaustive finite verification and written +scaling/concavity proof, not a formal-kernel theorem. Conditional transfer still +requires uniform all-size scalar/COPY/CLEAR/zero-allocation costs, a consistent +whole-call physical hosting and common source-label model, paid mutable-source +access and restoration, all private scratch and continuations, source-bound +native/phase/idle/controller invoices, internal rounding and precision bounds, +a finite-tape realization, retained bootstrap time, the PR559 recurrence and +correction/recovery hypotheses, analytic outer transfer, and the unchanged +joint BIT H1–H5 endpoint. The full profile includes every local and idle child; +physical stock 663549 must not replace live stock 663040 in the moment. + +## Open next questions + +The structured questions in [TASK.json](TASK.json) identify cold reproduction +and the need for a changed cost structure to exceed this narrow ceiling. +Repeated copies of the same complete profile preserve its normalized moment. +No further search or global optimality claim is part of this package. + +## Sources and credit + +Ross Richardson, with substantial OpenAI Codex assistance for construction, +independent AI reviews, packaging and verification; no independent human or +formal-kernel review is claimed. PR3605 at +`3efbb5de06a49ffeea6684482f2d3fe48cdca3fb` supplies the staged words and compact +primal. dcharb78's PR3133 coupled carrier folds and Jeremy Diviney's PR3148 owner/cap work, +the PR3531 positive-binomial engine, and Douglas Colkitt and Charles Bethin's +supplier/admission framework retain their source-specific attribution. Exact +notices are retained inside the minimal source archive. The standalone audit +is adapted from a separate all-row reviewer, not the owner producer. The dual +uses the separately reviewed Cartesian enumeration and positive-binomial proof. diff --git a/research/staged-644-660-owner-successor/RELEASE.md b/research/staged-644-660-owner-successor/RELEASE.md new file mode 100644 index 0000000000..80fd79ed00 --- /dev/null +++ b/research/staged-644-660-owner-successor/RELEASE.md @@ -0,0 +1,67 @@ +# Completed conditional transfer and execution scope + +The exact original `verify_release.py` completed with PASS_RELEASE. Its raw +receipt SHA256 is ee5e3f2d4d75fd7596f736e03c680b65441f032d1346dccbec4678b6975e40d7. +The separate final review authenticated 1,635 unique source/evidence files and +bound the actual literal, full invoice and outer result. Its exact raw SHA256 is +b462df012121d234437541e0873d32fb9c5f881374438a61899a32b6cd009cda. +Selected original scientific receipts are retained byte-for-byte in +[evidence/ACTUAL-RELEASE.tar.gz](evidence/ACTUAL-RELEASE.tar.gz), indexed by +[evidence/MANIFEST.json](evidence/MANIFEST.json). Local paths inside these raw +historical receipts are provenance only; no public replay depends on that run. +The remaining reviewed source/cache closure is generated by the explicit long +recipe, not supplied by stored PASS strings. + +The source 648 manifest is adb145b4f36ca330c34c0dbdb847351dafdc4ca9cd7bb4e1de01ed634d96bfe1; +the generated 652-file package manifest is d6aa8f2c029beb040f3c65df5906cf2c748b881245cb2d50ef0435321dc787de. +Both unchanged current native providers and retained parent/provider evidence +were authenticated reuse. No native job was executed in this successor run. +Fresh stages covered owner reconstruction/lift/rebind, discovery, source reviews, +strict global owners, all 8,758 actual charts including the three new rank-seven +idle children, controller phases/spectators, physical and prefix invoice, +assembly, all rejecting controls and complete original strict release. + +The actual complete profile has live stock 663040 and physical stock 663549. +Actual prefix demand is 1479 bits, sufficient reserve 1512, paid budget 2048. +The physical row coefficient is 19551 below 20161. The complete source/scalar, +coefficient, wrapper and compiler invoice remains paid. Strict source/native +bindings and the unchanged whole-call hosting model feed the same conditional +recurrence with complete H from PROOF.md. Its exact complex lower endpoint is +C=.001730006690311348872326. The unchanged retained BIT endpoint exceeds C; +47 supplier-bootstrap inequalities and 63 modern outer inequalities with 17 +rejecting controls give K=C-10^-46-10^-70, strictly greater than the exact +PR3605 rational K by 140772507025321/10^24. CLAIM.json is authoritative for the +modern headline. Supplier-only balanced K values are distinct intermediate +bounds and must not replace the modern outer result. + +The complete finite release does not prove the all-size hypotheses: uniform +scalar/COPY/CLEAR/zero-allocation costs; common labels and mutable-source access; +whole-call physical hosting with all private scratch, coefficient and continuation +storage; all-size compiler and internal rounding; finite-tape realization; +retained bootstrap time; PR559 recurrence/correction and exact recovery; +analytic outer transfer and joint BIT H1–H5. These are the same conditional +premises as the predecessor, not an unconditional or formal-kernel theorem. + +## Recovered harness boundary + +The first release launch hit a freshness guard because its checkpoint harness +had pre-created the output parent. It failed before mathematical checks. The +failed bytes and diagnosis were preserved. Completed discovery and outer output +were authenticated at their supported boundary, then the identical original +full-release argv was executed successfully, exit 0, in 1352.8 seconds, ending +2026-10-18T10:52:55.586927Z. No mathematical gate or freshness assertion was +patched. The completed official attempt verified empty process cleanup. +RECOVERY-RELEASE and DIAGNOSIS are retained in the evidence archive. Personal +checkpoint configuration remains outside Git. The long portable wrapper is +provided but its whole cold tail has not been executed; that limit is separate +from the completed actual release with authenticated cache reuse. + +## Preserved historical metadata caveats + +The original summary says 15 controller controls; actual strict audit and SPEC +require 25, all checked. Five native coverage groups summarize six +historically executed native stages. Inherited outer branch prose retains old +precision/supplier wording; numeric 24-digit SPEC/B/LEDGER and modern K are +authoritative. Frozen receipts are not cosmetically rewritten. The bounded +verifier authenticates them and compares their actual profile, K, stock, prefix, +charts and controls with freshly recomputed literal/arithmetic results. diff --git a/research/staged-644-660-owner-successor/SOURCES.json b/research/staged-644-660-owner-successor/SOURCES.json new file mode 100644 index 0000000000..37068c4ca9 --- /dev/null +++ b/research/staged-644-660-owner-successor/SOURCES.json @@ -0,0 +1,618 @@ +{ + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "path": "certificates/selected-result.json", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "usage": "provenance" + }, + { + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "path": "docs/research/agent-task-catalog.json", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "usage": "provenance" + }, + { + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "path": "LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "usage": "input" + }, + { + "git_blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2", + "path": "research/adaptive-kernel-demotion/vendor/engines/outer.py", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "usage": "input" + }, + { + "git_blob": "0fc94df8d648bdcb5cb0403567b344a0b56ab4d1", + "path": "research/coupled-carrier-cap740/.gitattributes", + "sha256": "9fe19dd37d5e9fa50f5bfab548cbeb38d300a05a78ea11abe3199b97c30fa563", + "usage": "input" + }, + { + "git_blob": "d14b0e8797c0905240e8c002e965585fdcc5e76f", + "path": "research/coupled-carrier-cap740/BASELINE-PR3143.json", + "sha256": "736e804af3c2f5665e29e79e9d54cda619817edac582c02da8613ee85d07b8ae", + "usage": "input" + }, + { + "git_blob": "aa3d8e87fc139d636cd19eaa4cd375fca2c780cf", + "path": "research/coupled-carrier-cap740/CLAIM.json", + "sha256": "338165d75d87a1a576750ec92772640e641bc91076e91b686d8ec7ad6f9d6d19", + "usage": "input" + }, + { + "git_blob": "f323db0fd94a80f691b1606e813d0738b27058ae", + "path": "research/coupled-carrier-cap740/EXCHANGE.json", + "sha256": "5063791f327d067f37478488c97ce449e5b34cfb61d6309fc6924c5e360fe839", + "usage": "input" + }, + { + "git_blob": "2af89beed10e0974e1900d8d284d5edabb853160", + "path": "research/coupled-carrier-cap740/FETCH.txt", + "sha256": "2d72343c697fb55c87e9c092bc6a6346b5a31e1b311cf8f02e11cdc7d4e916d9", + "usage": "input" + }, + { + "git_blob": "68d4cd12052840483ebd8004d6b14df707aeda31", + "path": "research/coupled-carrier-cap740/MANIFEST.json", + "sha256": "db2e63e8814e3af5cab14e83174ca035e3b74a919d3d9632dbcf8ff031da7931", + "usage": "input" + }, + { + "git_blob": "1b9447f2a301c6db2bf73c9d7b0095eeaede8b7e", + "path": "research/coupled-carrier-cap740/NOTICE", + "sha256": "6a0ba71e24f2705eb353db20ee4e369f70fc9ed1d03571f1516c86b8143b2d3f", + "usage": "input" + }, + { + "git_blob": "f540563133ab194eace19d923dc56d637a7c5e51", + "path": "research/coupled-carrier-cap740/README.md", + "sha256": "1442d0a676e2f7528c5eea000d9abdbddf4649ee8e7a85f03f903f96eaad18a5", + "usage": "input" + }, + { + "git_blob": "e59a0271bb7e0b122b6e2625f65b2c1bc7a181e8", + "path": "research/coupled-carrier-cap740/SOURCE-PINS.json", + "sha256": "8e558e3728f04ff3d5cf2f7e42d8ecffe2689db4f3a128d295f004fcea94b126", + "usage": "input" + }, + { + "git_blob": "fccb14e4ede821a772a067207423a6d5774f44ad", + "path": "research/coupled-carrier-cap740/SOURCES.json", + "sha256": "3e2848315417072d8ad01b2cbc6ebe22b87c832157f0054ed4bd4586b8342b63", + "usage": "input" + }, + { + "git_blob": "6fbe032232516887f3d9a63a6d77a950b5b8d501", + "path": "research/coupled-carrier-cap740/TASK.json", + "sha256": "c2479064dd5f8c9cf59ec86a97216d896a361516ad8a520d312f2edc8eb70956", + "usage": "input" + }, + { + "git_blob": "65c53e56333f662cdb178cee922f4b3e04646627", + "path": "research/coupled-carrier-cap740/VENDOR.json", + "sha256": "b1ca2aa5eda68a671af0c7a8d9c16798fa6024ccc243a70ba28108b65f9172bd", + "usage": "input" + }, + { + "git_blob": "472b6916e6e47d3be3cfb8959bb3391b5c598e29", + "path": "research/coupled-carrier-cap740/VERIFY.json", + "sha256": "28af19a46e30b1bdd6cd72a33d580d9b66d367b01f111657ebb5fad24b6287e6", + "usage": "input" + }, + { + "git_blob": "8e06e8fadd03e943564322f2a75196d9007b5b47", + "path": "research/coupled-carrier-cap740/cap_check.py", + "sha256": "c2a2ea7df9ef2f7c7ae2739435f4ac44f2c912d8e18fc9278c717958f258ee38", + "usage": "input" + }, + { + "git_blob": "deb060b34f6bd0e7a41d02cef6e01b13b99444a1", + "path": "research/coupled-carrier-cap740/common.py", + "sha256": "8786495cbf808d950be1c42e42d0198e950e44167af80063d25fd186aafea534", + "usage": "input" + }, + { + "git_blob": "75321c7582f5212b3aa08aa1459530cf20994d7a", + "path": "research/coupled-carrier-cap740/construct.py", + "sha256": "7aa70e617974d4cfd93d71e5f569f7200778bca3056ea1f592920c42bded6911", + "usage": "input" + }, + { + "git_blob": "24fc28aad72d190e23d27e25b4272cb4b52e4175", + "path": "research/coupled-carrier-cap740/evidence/ADMISSION-RESULT.json", + "sha256": "ac9bd230856de7acd09828433163032ea94bccaec446e454576e43f8d1a54b74", + "usage": "input" + }, + { + "git_blob": "780bf6c5c414a6ee6c207a83225be5bb4572e6a4", + "path": "research/coupled-carrier-cap740/evidence/COMPOSITION-RESULT.json", + "sha256": "ba30bcb0454dcbc21ad8cc06a196d354feda43b330663808940c302540f21a1d", + "usage": "input" + }, + { + "git_blob": "fab43622a92324a8fda0fe9b0502d57d11cea069", + "path": "research/coupled-carrier-cap740/evidence/ENVIRONMENT.json", + "sha256": "7f87ff189cd75ad7cd8fa1abedb1bb4b5d8db071e4ca468c7f2589c11f55388a", + "usage": "input" + }, + { + "git_blob": "006944bcc9d7af119ac44eecb765803fa0712a16", + "path": "research/coupled-carrier-cap740/evidence/FINITE.json", + "sha256": "5e4a46af7d8b6211a181b09fc79606617d57564921d67683269e3e6717ccc8a8", + "usage": "input" + }, + { + "git_blob": "920dbac6618c18b73e6f38f0c086b471dc972a8d", + "path": "research/coupled-carrier-cap740/evidence/INVOICE-PAYLOAD.json", + "sha256": "29a18051af4cf4bd071db50eef9a9905ed0c0dfe27f6b7deacbebecff665b3eb", + "usage": "input" + }, + { + "git_blob": "8be4acd747c9056daeb3da1c3d7c9982e780e8c8", + "path": "research/coupled-carrier-cap740/evidence/MATERIALIZED.json", + "sha256": "40a4a3e05ad345aac2131822aa201c662012040c254af5528fea0c408d098326", + "usage": "input" + }, + { + "git_blob": "a798b17ca16538583fde59a76862f348ae9f95b5", + "path": "research/coupled-carrier-cap740/evidence/NATIVE-RECEIPT.json", + "sha256": "15c975052f81f9a7363669a4ea9d016525063e920f9e596422ce24f66a23b1a2", + "usage": "input" + }, + { + "git_blob": "fcccf671c22049bf1bacb09588b5bbfe97338314", + "path": "research/coupled-carrier-cap740/evidence/NATIVE-base-STEPS.json", + "sha256": "0a89aa9ecf6bc1fc1436699842d17674661cd5e0d7a110d3572e7eb912fedbf6", + "usage": "input" + }, + { + "git_blob": "5608f6792c76ab24de34584a93f2eccd38b2dbb8", + "path": "research/coupled-carrier-cap740/evidence/NATIVE-extra-STEPS.json", + "sha256": "815f9657e04e63815af45bceeaabf549357bac432498cd2d331f607d7b2929ab", + "usage": "input" + }, + { + "git_blob": "b669d0cafecae2eb6e01c802222004104c69b782", + "path": "research/coupled-carrier-cap740/evidence/OUTER-CLAIM.json", + "sha256": "6f3ea6f27ca0a6f1cb925b14b3db323482c71316ab8810b056fdb41ce5490046", + "usage": "input" + }, + { + "git_blob": "a347c2326eee066f77203b9b63cc75325cf9d9a5", + "path": "research/coupled-carrier-cap740/evidence/OVERLAP.json", + "sha256": "c6d551be96d163b91f2d32e59de8df2d89a1dd4626388146df589a530af772d1", + "usage": "input" + }, + { + "git_blob": "08a518a47940d4ec02d561b3723803316029bc98", + "path": "research/coupled-carrier-cap740/evidence/PREFIX-AND-INVOICE.json.gz", + "sha256": "4c46daacf45747db13ab2c5a0d5253e28f8619dc97841ec4f9d455f17cdb04ee", + "usage": "input" + }, + { + "git_blob": "c6f9f26a60e4fa3e459a89062d8f983b80124627", + "path": "research/coupled-carrier-cap740/evidence/RECIPE.json", + "sha256": "a3a4656491c73e11860614b05d9cce809f5fd576648d184aca75b75a4e087faf", + "usage": "input" + }, + { + "git_blob": "38482441fdc9d8f6bba5bac8bdc0589cf0906569", + "path": "research/coupled-carrier-cap740/evidence/RELEASE-RECEIPT.json", + "sha256": "d2536cd5945ddafd4dee9f1ba8c7f24f5ac98d52fad22f9163241663b533d399", + "usage": "input" + }, + { + "git_blob": "37b761d7b4fa160b7ee6eaf7f952174d0b3120c2", + "path": "research/coupled-carrier-cap740/evidence/RETAINED-REUSE-RECEIPT.json", + "sha256": "dd36443f2789ffa6deca7210c76ada781e2b9b7e622a546b366f51a475faff3e", + "usage": "input" + }, + { + "git_blob": "d668d5efb3fa2be7f3f4a15c478c2ed1a7b4ad04", + "path": "research/coupled-carrier-cap740/evidence/RUN.json", + "sha256": "09e013a5ef64c3c23728e93bdc1deb65c3fc902d5bc9b7c61b9c411df6a17793", + "usage": "input" + }, + { + "git_blob": "1b7841af74d0ac0ef4bbe7a658d1df73618cab0f", + "path": "research/coupled-carrier-cap740/evidence/logs/complete-admission.log.txt", + "sha256": "9554cd4188e0893fae82b3e44b992bae4f1409dfa974ffc7de1d57aab256e3e6", + "usage": "input" + }, + { + "git_blob": "ec40dfa5127a83d1169fcd525c87ad768259d889", + "path": "research/coupled-carrier-cap740/evidence/logs/declared-edit-stage.log.txt", + "sha256": "0c33d4323f555c64c0c9cc6cd4d821ed70c7163434a5b265cad51ad68d751b03", + "usage": "input" + }, + { + "git_blob": "62ee7ce8e67860c7feea8a8e629ccb54a38bc5ce", + "path": "research/coupled-carrier-cap740/evidence/logs/derive-closed-adapters.log.txt", + "sha256": "ae9fbbecb3eb64e18eb7e08a99ea6e15c924ec7626e4b09f7997703a474d9273", + "usage": "input" + }, + { + "git_blob": "821f51b91a36582452eb013825a2d8b9d7473a81", + "path": "research/coupled-carrier-cap740/evidence/logs/export-pr2833.log.txt", + "sha256": "7b2179791de25298ed2efd677a5854d12ccae6a15ac0b8c4ee9fa55bad1276ea", + "usage": "input" + }, + { + "git_blob": "2bed900376db47d928ffe64835940c728d3e4094", + "path": "research/coupled-carrier-cap740/evidence/logs/export-pr2894.log.txt", + "sha256": "6bd8df30779863897e48441608240db6a7e3fcbd0754511e44f854f3a5c462a6", + "usage": "input" + }, + { + "git_blob": "ce63b87bf13e5d14ea4de9cdb3f9039416fcf976", + "path": "research/coupled-carrier-cap740/evidence/logs/final-outer.log.txt", + "sha256": "670f60ee3ecc7e2d7fc4b23b468d4cdb8cfab9edaf252cd2410c1cabcb0318dc", + "usage": "input" + }, + { + "git_blob": "5b85524248fde8617764fc0f67eafa7de11bcf48", + "path": "research/coupled-carrier-cap740/evidence/logs/final-source.log.txt", + "sha256": "5840b042911f77ba55c1536f72932775910e53930b4a515416f028c8ffe219b5", + "usage": "input" + }, + { + "git_blob": "257be58c74eb0f54ee80f34af65e64e9f201935a", + "path": "research/coupled-carrier-cap740/evidence/logs/four-kernel-stage.log.txt", + "sha256": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "usage": "input" + }, + { + "git_blob": "e8a1b91290d5d8080bbbcad1895c3a0ba79f6a26", + "path": "research/coupled-carrier-cap740/evidence/logs/fresh-current-native.log.txt", + "sha256": "57a95a5df95aa0574b48d59d71a6e5e84d017172e51b8627d8713c52a7134206", + "usage": "input" + }, + { + "git_blob": "9ca3a425215401648870f3f65397a683c028abfb", + "path": "research/coupled-carrier-cap740/evidence/logs/paired-extension-stage.log.txt", + "sha256": "61cc77beeae833d7473b5c5338b176b150f95f6652a888c0307f080674cfde35", + "usage": "input" + }, + { + "git_blob": "de80347a9094a0741e644d36c1f75487fa664424", + "path": "research/coupled-carrier-cap740/evidence/logs/parent-paired-stage.log.txt", + "sha256": "d80d8494c48816e3acf662db00cc0077a888b82392d736826f73beb1c4248299", + "usage": "input" + }, + { + "git_blob": "fd0283e7dfd22dc4587fab1cce1996d63ce20b94", + "path": "research/coupled-carrier-cap740/evidence/logs/pr3136-local-audit.log.txt", + "sha256": "20ddd986c6be5ecda7758f0fa42a90e0a7224dbb5eedfd4d9c9ee899743b50f5", + "usage": "input" + }, + { + "git_blob": "4fa79b5e482d644cbe1d2c882dbc3296d367db9b", + "path": "research/coupled-carrier-cap740/evidence/logs/preload-stage.log.txt", + "sha256": "2eb7601c48840a39c58eb838886aed00a531349b259f0bbc3ea6421376b8ea3c", + "usage": "input" + }, + { + "git_blob": "5e1171683aef6495ae7cc8120f5e99716126b0b4", + "path": "research/coupled-carrier-cap740/evidence/logs/public-fresh-preflight.log.txt", + "sha256": "2a1a354a82f7a24425452304b3d13d7a40a7db9aeed96c2a41907968195d1e9c", + "usage": "input" + }, + { + "git_blob": "5e1171683aef6495ae7cc8120f5e99716126b0b4", + "path": "research/coupled-carrier-cap740/evidence/logs/public-preflight.log.txt", + "sha256": "2a1a354a82f7a24425452304b3d13d7a40a7db9aeed96c2a41907968195d1e9c", + "usage": "input" + }, + { + "git_blob": "d058b55c96bf06d7e9f888559ef27df5417f354d", + "path": "research/coupled-carrier-cap740/evidence/logs/rank7-overlay-stage.log.txt", + "sha256": "06150c3f42489b14e981b90ac0e594e7e32bfc6ec4a98f3551cf53b6d18acd36", + "usage": "input" + }, + { + "git_blob": "ece945cf77be3881cedf4578084ff98d666ef8ba", + "path": "research/coupled-carrier-cap740/materialize.py", + "sha256": "246c1f694f76faf93c21ba9e46a527d334f6d53a9d882e5fa9d98c859b57b736", + "usage": "input" + }, + { + "git_blob": "8753eb471ea18bee3ccbb653552701602bad7ec4", + "path": "research/coupled-carrier-cap740/reproduce.py", + "sha256": "b8a057998fe8b5819aa429b49734f3f85348c38f0d27e3302853098ddc5b902d", + "usage": "input" + }, + { + "git_blob": "e1d4e7582bedc204ca6da844568febf602af3cc5", + "path": "research/coupled-carrier-cap740/requirements-full.txt", + "sha256": "13f257631f46d3c774495c6b22351899a825afb226410856b2c549535022632f", + "usage": "input" + }, + { + "git_blob": "a8164efa989d6b0cd92ad5ec4acbcd72467a93fb", + "path": "research/coupled-carrier-cap740/run_release.py", + "sha256": "1955dbfed014b34df1401b3bed480eb30eb0d80854285f8b63da0e8d838c899a", + "usage": "input" + }, + { + "git_blob": "9343c069fef7570bdfd654ee882ef46f8c1b6657", + "path": "research/coupled-carrier-cap740/test_allocation.py", + "sha256": "cf3eb0e979828fbb0960d1240c42a95aab79b6ef73e8106cb93d2166513076c2", + "usage": "input" + }, + { + "git_blob": "649aa2be9e21b16001ebd03e4d9c3e8c808363fd", + "path": "research/coupled-carrier-cap740/test_bindings.py", + "sha256": "f334e67e1ccd2b5eb9430e11aa48fffaa11b07aba3e4bc8518f6cd079bb7a6c1", + "usage": "input" + }, + { + "git_blob": "804edbf26529d259e473ec5c79b7755370001cdc", + "path": "research/coupled-carrier-cap740/vendor/PR3133-CAP.json", + "sha256": "e32f3ecd5e6594935583f80f643cf1930e8bc017e3c541025c335395a15cf19c", + "usage": "input" + }, + { + "git_blob": "493d11346de068a2c4307a2dbdd6cf14f8e146fc", + "path": "research/coupled-carrier-cap740/vendor/PR3133-CLAIM.json", + "sha256": "f3435eda62a95bb02fd4870ac97b108b3a6862cbf84a7d22863889fc1d73ec01", + "usage": "input" + }, + { + "git_blob": "24f00912d4ec829c3c8d2a8d086aa135664a124c", + "path": "research/coupled-carrier-cap740/vendor/PR3133-CREDITS.md", + "sha256": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "usage": "input" + }, + { + "git_blob": "92b49b42b8f381d686a9fb8057e74e4b7548cd5c", + "path": "research/coupled-carrier-cap740/vendor/PR3133-FILL.json.gz", + "sha256": "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4", + "usage": "input" + }, + { + "git_blob": "e0900bd015194d3876072ccea00bffba92a43627", + "path": "research/coupled-carrier-cap740/vendor/PR3133-MANIFEST.json", + "sha256": "609209f577c9185b16825dd2e8bb30f0891205fddd2571a8f76c558e3cb1f70e", + "usage": "input" + }, + { + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "path": "research/coupled-carrier-cap740/vendor/PR3133-NOTICE", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "usage": "input" + }, + { + "git_blob": "0b2343675099d0a9fe90da6e1f1e53f50235567e", + "path": "research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json", + "sha256": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd", + "usage": "input" + }, + { + "git_blob": "717067dfce61c530205e8dad7ab3e76376f2c179", + "path": "research/coupled-carrier-cap740/vendor/lift.py", + "sha256": "ae6c1fee78fbdec26976ca74ca89f6aab2528d763c596f6573132cb54d57cd3c", + "usage": "input" + }, + { + "git_blob": "d7839edadfb6d65bf859d5a8ce6b83aa818e940e", + "path": "research/coupled-carrier-cap740/verify.py", + "sha256": "86fbd1ab5fdbc5ea1914a2d873e55d8ea1b4921bfcc2567442cc8141567019be", + "usage": "input" + }, + { + "git_blob": "a3ac9233bed653943708b940d6b2718feb58cd59", + "path": "research/coupled-carrier-cap740/verify_release.py", + "sha256": "30acfd9f5f4488f29f2f8e6854ba35dc06ce1afba97124408eb051b7b145ea27", + "usage": "input" + }, + { + "git_blob": "cb4cc24a4545944627ad595c0c5080196952b9f0", + "path": "research/coupled-carrier-cap740/words/base.json.gz", + "sha256": "300a9b8ad1d554f0e6f84f43f3f5fd870a5b4e5f81ad856900b6e8999684892e", + "usage": "input" + }, + { + "git_blob": "decc8f26d8aab108baf75f0d8b2d1012eb06d076", + "path": "research/coupled-carrier-cap740/words/extra.json.gz", + "sha256": "495d030f1e03b90e954dad3043994f03293d41b9ed220a3beaef849df435d3f0", + "usage": "input" + }, + { + "git_blob": "ffe975e9265dcc1f8edddc054c1798a34c9095a6", + "path": "research/gmx-t74-borrow43-handoff/CLAIM.json", + "sha256": "c3710307b5c12f14a9be1938aab4b4696223416b184802b6ab88663c19330c3d", + "usage": "input" + }, + { + "git_blob": "b317e9b35dbc3bb18a659701b6c286b170822c7a", + "path": "research/gmx-t74-borrow43-handoff/code/assemble.py", + "sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "usage": "input" + }, + { + "git_blob": "b64077b84b04433719a35ea683b52f02e8564cc0", + "path": "research/gmx-t74-borrow43-handoff/outer/check_ledger.py", + "sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "usage": "input" + }, + { + "git_blob": "b838c430efe5c3cc10db81d0a2b16b4ee4cfe3c5", + "path": "research/gmx-t74-borrow43-handoff/outer/independent_check.py", + "sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "usage": "input" + }, + { + "git_blob": "24f00912d4ec829c3c8d2a8d086aa135664a124c", + "path": "research/rank7-coupled-586-588-carrier-fold/CREDITS.md", + "sha256": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "usage": "input" + }, + { + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "path": "research/rank7-coupled-586-588-carrier-fold/NOTICE", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "usage": "input" + }, + { + "git_blob": "cb4cc24a4545944627ad595c0c5080196952b9f0", + "path": "research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-base.json.gz", + "sha256": "300a9b8ad1d554f0e6f84f43f3f5fd870a5b4e5f81ad856900b6e8999684892e", + "usage": "input" + }, + { + "git_blob": "decc8f26d8aab108baf75f0d8b2d1012eb06d076", + "path": "research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-extra.json.gz", + "sha256": "495d030f1e03b90e954dad3043994f03293d41b9ed220a3beaef849df435d3f0", + "usage": "input" + }, + { + "git_blob": "8224873d0497cf0b4c202f31b145fa273553d978", + "path": "research/rank7-coupled-586-588-carrier-fold/vendor/audit_local.py", + "sha256": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "usage": "input" + }, + { + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c", + "usage": "input" + }, + { + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1", + "usage": "input" + }, + { + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "usage": "input" + }, + { + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "usage": "input" + }, + { + "git_blob": "16013201b19054f7e45398ecf10af74c9c6a9114", + "path": "research/rank7-joint-endframes/allocation/vendor/independent_owners.py", + "sha256": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "usage": "input" + }, + { + "git_blob": "bd6dc2eb4e5013625d17cc08461b67622bcfed69", + "path": "research/rank7-joint-endframes/tools/root.py", + "sha256": "55f5aca39b5ee2fe4687ac8863e6c24569010f27a332883c069b8e14b8fe09e3", + "usage": "input" + }, + { + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "path": "research/t74-native-fast/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "usage": "input" + }, + { + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740", + "path": "research/t74-native-fast/NATIVE-LINEAGE-NOTICE", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "usage": "input" + }, + { + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/NOTICE-PR2226.md", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "usage": "input" + }, + { + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/bw_adapters.py", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "usage": "input" + }, + { + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/bw_audit_local.py", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "usage": "input" + }, + { + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/bw_check_recipes.py", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "usage": "input" + }, + { + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/bw_emit.py", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "usage": "input" + }, + { + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/bw_gauss.py", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "usage": "input" + }, + { + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/bw_phases.py", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "usage": "input" + }, + { + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/bw_tamper.py", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "usage": "input" + }, + { + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/bw_transport.py", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "usage": "input" + }, + { + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "usage": "input" + }, + { + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "usage": "input" + }, + { + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/pr2226_operators.py", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "usage": "input" + }, + { + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/pr2226_replay.py", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "usage": "input" + }, + { + "git_blob": "02e61035e91cb547c6006b384178c181b09ab572", + "path": "research/tensor-block-kappa/PROOF.md", + "sha256": "3fa62afc4cee9315f236e8cae94484b40d2dedc271d654b08eb5eaf86a96a425", + "usage": "input" + }, + { + "git_blob": "0d96586a00f03058d6dc1d7882ec8fbe6661ed00", + "path": "research/two-sided-helper-extraction/tools/audit_moment.py", + "sha256": "e7147ccb8c57aa32a2cb227234a6a200a0b9e735eb1a655fd79ab29a4d7c0a00", + "usage": "input" + } + ], + "schema_version": 1 +} diff --git a/research/staged-644-660-owner-successor/STAGE-SCOPE.json b/research/staged-644-660-owner-successor/STAGE-SCOPE.json new file mode 100644 index 0000000000..a110b5b294 --- /dev/null +++ b/research/staged-644-660-owner-successor/STAGE-SCOPE.json @@ -0,0 +1,22 @@ +{ + "actual_chart_count": 8758, + "actual_controller_controls": 25, + "actual_full_release": "PASS original complete release with authenticated source/native reuse; fresh owner/global/controller/idle/physical/prefix/invoice/outer checks. A pre-check output-directory collision was preserved and retried with identical original release argv, no weakened gate.", + "formal_kernel": false, + "fresh_bounded": [ + "exact integer primal and controls", + "all predecessor rows", + "sparse journal with complete payload checks", + "both native frame tables only", + "independent all-row candidate windows families prefixes and H", + "three exact moments and modern/bootstrap outer inequalities", + "all2551 fixed-inventory pattern dual" + ], + "portable_cold_wrapper": "Provided but complete tail unexecuted; historical Git objects and original dependencies required.", + "recorded_evidence_binding": "Archive byte authentication and semantic comparison with fresh full literal, H and arithmetic; not a rerun of long admission.", + "retained": [ + "PR3605 arbitrary-input local operators and native six-stage checks", + "exact source history and source-specific proof premises" + ], + "status": "CONDITIONAL_RELEASE_BOUND" +} diff --git a/research/staged-644-660-owner-successor/TASK.json b/research/staged-644-660-owner-successor/TASK.json new file mode 100644 index 0000000000..dc7deb4eaa --- /dev/null +++ b/research/staged-644-660-owner-successor/TASK.json @@ -0,0 +1,85 @@ +{ + "actual_scope": "Independent all2551-pattern dual ceiling for every positive integer T in the staged-width fixed-inventory model, supported by a complete released five-owner T740 witness; PR3624 concurrently reports a higher T450 witness.", + "ai_assistance": "Substantial OpenAI Codex assistance, including separate mathematical AI reviews; no independent human or formal-kernel review.", + "author": "Ross Richardson, with substantial OpenAI Codex assistance", + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "bottleneck_link": "Concentrate complete idle costs without changing paid local words, then bound the remaining scope of fixed-inventory packing.", + "budget_minutes": 240, + "concurrent_work": [ + { + "head": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "scope": "Read-only exact source/certificate/invoice premise comparison. No fresh all-row or full admission of PR3624. Its higher candidate is acknowledged from its source and reported release/CI; this package does not adopt its full verification.", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3624" + } + ], + "evidence": "Fresh all2,717,280-row independent replay and exact arithmetic passed; exhaustive dual passed. Full original strict release and independent final source/literal/invoice/outer binding passed; local native checks are authenticated reuse.", + "open_questions": [ + { + "blocked_by": "Long original dependencies and execution budget; full portable cold tail not yet executed.", + "first_step": "Fetch the exact historical objects in the archived FETCH.txt, then run reproduce.py in a fresh directory without --retained.", + "question": "Can a separate environment reproduce the complete cold source/native/release recipe?", + "why_it_matters": "The actual completed release used explicitly authenticated native/cache evidence; bounded replay is Git-free but full historical reproduction is separate." + }, + { + "blocked_by": "A validated construction outside the fixed-inventory premises.", + "first_step": "Choose one concrete changed construction and prove complete local, idle, source, restoration and physical costs before optimizing owners.", + "question": "Which changed paid word, capacity, source geometry or inventory can substantially exceed the fixed-inventory ceiling?", + "why_it_matters": "The scoped dual leaves less than8.9674e-8 above this candidate endpoint." + } + ], + "original_card": { + "acceptance_gate": "Check live PR overlap first, price both suppliers and distinguish a search best from an optimum. Report the word's packing cap from ceiling.ceiling() and the fraction of it realized; label packing gains as such.", + "allowed_variations": [ + "One bounded residual packing instance or exact relaxation.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "bottleneck_link": "An actual paid-profile gain can improve the frontier up to the other supplier cap.", + "existing_checks": [ + { + "evidence": "docs/research/community-efficient1000-review.md", + "remaining": "A changed word or model requires new pricing; a local packing search must name uncovered scope.", + "scope": "Packing-independent ceiling for the selected paid profile under the one-unpaid-coordinate coverage and halving guard.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "status": "reviewed" + } + ], + "first_experiment": "Define an unclaimed canonical domain and a favorable bound before starting a new search.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Locate the selected packing source in the review and check live PRs for the same residual problem.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "id": "selected-packing", + "methods": [ + "Search a named unclaimed canonical candidate domain with a reproducible partition.", + "Prove a stronger scoped relaxation or exact optimum for one named residual subproblem." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing" + ], + "question": "Is there a genuinely unsearched, explicitly bounded improvement to the selected packing?", + "scope_change_triggers": [ + "Rerunning an existing search with only a different seed as a separate mathematical contribution." + ], + "starting_points": [ + "certificates/selected-result.json", + "research/heterogeneous-owner-assembly/README.md", + "research/complex-local-word-ceiling/README.md" + ] + }, + "outcome": "completed", + "priority_revision": 6, + "schema_version": 1, + "scope_change_reason": "Explicit user assignment targets the exact pending PR3605 T740 construction, not the selected T16 model. Its changed local inventory requires a new applicable ceiling; the selected ceiling.ceiling() premise does not apply. At final overlap, PR3624 superseded the five-move endpoint. The primary contribution is therefore the independently certified all-T ceiling; no current-best claim is made.", + "scope_status": "changed", + "stop_rule": "Do not claim successor kappa without full strict release and independent final binding. Do not claim packing optimality or change selected record.", + "task_id": "selected-packing" +} diff --git a/research/staged-644-660-owner-successor/VALIDATION.json b/research/staged-644-660-owner-successor/VALIDATION.json new file mode 100644 index 0000000000..5fb3ccf531 --- /dev/null +++ b/research/staged-644-660-owner-successor/VALIDATION.json @@ -0,0 +1,100 @@ +{ + "actual_full_release": { + "native_scope": "authenticated unchanged reuse", + "receipt_sha256": "ee5e3f2d4d75fd7596f736e03c680b65441f032d1346dccbec4678b6975e40d7", + "recovery": "pre-check harness collision preserved; identical original full release succeeded", + "review_sha256": "b462df012121d234437541e0873d32fb9c5f881374438a61899a32b6cd009cda", + "seconds": 1352.7851100419994, + "status": "PASS_RELEASE" + }, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "bootstrap_constraints": 47, + "bootstrap_controls": 4, + "dual": { + "coefficient_sha256": "11c3cadeeda1d3db40eb479af6835131f5e61bf26f63f2a62ec54de41a9f5c3a", + "patterns": 2551, + "strict": 2539, + "symbolically_zero": 12 + }, + "limits": [ + "The registered verifier was invoked directly from an optimized parent after metadata/pin validation.", + "Recorded release binding is separately checked against the fresh result; complete cold wrapper tail remains unexecuted.", + "Committed export and hosted CI remain publication gates." + ], + "nomination_only_kappa": "17300066903113488723259999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "predecessor": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "profile": { + "1": 16417892, + "2": 4835160, + "3": 1540174, + "4": 679320, + "48": 283185, + "5": 143993, + "7": 3, + "8": 53280 + }, + "receipt_sha256": { + "DUAL.json": "496c92102faeefa2faab0d9c0d9b6770572f5ad5a8ab6c01b624eb8a28704816", + "INDEPENDENT-OWNERS.json": "8fd9b5d0fb24a1a99de31e184a7903a58501fd9c34604e4a0b274a3aaaa11db7", + "RESULT.json": "6845f8af6cb71c088608587fb94b63bf0d2cb3a1b1df0daf029a18fed7b257cb", + "arithmetic/RESULT.json": "36c2dba182cba90f7d779e36f53124c4999331963f3c310f4b7c3336cc0e5dd1" + }, + "roles": 2717280, + "root_interval": [ + "865003345155674436163/500000000000000000000000", + "1730006690311348872327/1000000000000000000000000" + ], + "seconds": 85.52046625000003, + "stage_receipts": [ + { + "exit_code": 0, + "log_sha256": "2667d118dead0d249faa683f7c1d938f8ab0956f253843070eca2b60896e5c3a", + "script_sha256": "c10a0eb62799f73dd577a5bec86e91b0124ec8b2cdf95bd68807299cf1521866", + "seconds": 4.840574916999685, + "stage": "predecessor-integer-primal-and-controls" + }, + { + "exit_code": 0, + "log_sha256": "ff90a0bdce6aec3c99fead1f520eeea4917c39adf3fb11804af483c98fcc26a0", + "script_sha256": "76fa44cf996b97d7e7a89fb0a93e734b41efc7c0e07cbbc14bfac635e174600c", + "seconds": 67.10596499999883, + "stage": "fresh-predecessor-literal" + }, + { + "exit_code": 0, + "log_sha256": "7f7ad9805722307d511505b0e4957b7c73d2443a25f897bacb0c27241d26eafa", + "script_sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "seconds": 0.766406791000918, + "stage": "fresh-frame-table-base" + }, + { + "exit_code": 0, + "log_sha256": "58b839636c69c5df186130f2f64c13232580d6a3d3f7a8ff0c7be78ef4336889", + "script_sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "seconds": 0.8863956670011248, + "stage": "fresh-frame-table-extra" + }, + { + "exit_code": 0, + "log_sha256": "e129832758622bfdd60a0d21ef0adce3827d51dbe13809a9992fe1a359310ab2", + "script_sha256": "8d02dff267938cdb373aa617a411d8e67700e130609d2714e98ccf814e32eaef", + "seconds": 8.46801858300023, + "stage": "independent-complete-successor" + }, + { + "exit_code": 0, + "log_sha256": "2ce7c4f9e501a00fc74721fd1f2faaa4e7751c660c40bb3f5a35e7bbdeca55a1", + "script_sha256": "ee4a9cd92267b70a0d482377331bbb4ae9555cf68cf3f7467e46f9923567c91b", + "seconds": 1.3497215830011555, + "stage": "full-moment-and-outer" + }, + { + "exit_code": 0, + "log_sha256": "db19ad983ca49bb60e8ec2e451ccf1b6e967cf413a8f35931d80de2c25cabf36", + "script_sha256": "639820c9ccf72b88ae16768055ec5500a66004784f57a2fa5f218bf4d2e4ee05", + "seconds": 0.6696664169994619, + "stage": "all-pattern-fixed-inventory-dual" + } + ], + "status": "PASS_METADATA_PINS_AND_OPTIMIZED_PARENT_BOUNDED_REPLAY" +} diff --git a/research/staged-644-660-owner-successor/VALIDATION.md b/research/staged-644-660-owner-successor/VALIDATION.md new file mode 100644 index 0000000000..ec22611d6a --- /dev/null +++ b/research/staged-644-660-owner-successor/VALIDATION.md @@ -0,0 +1,23 @@ +# Validation + +Metadata and every declared source pin passed with `GIT_NO_REPLACE_OBJECTS=1`. +The registered verifier was then invoked directly from an optimized parent: + +```sh +python3.12 -O -B research/staged-644-660-owner-successor/verify.py --repo . --out /tmp/fresh-owner-successor +``` + +The fresh bounded replay passed in 85.5205 seconds on the author's Mac: all +2,717,280 roles, three exact moment methods, 63 modern strict inequalities and 17 +controls, 47 bootstrap inequalities and 4 controls, the original integer-primal +and scoped owner/journal controls, and all 2,551 dual patterns (2,539 strict, +12 symbolically zero). All seven child stages exited 0. The unoptimized children +retain inherited assertion checks. Machine-readable scope and exact source/log +hashes are in [VALIDATION.json](VALIDATION.json). + +The first complete owner/arithmetic replay before adding the dual also passed +in 76.6346 seconds. The original complete strict release subsequently passed in 1352.8 seconds, +with a separate final independent binding. See RELEASE.md for authenticated +native reuse and the preserved pre-check harness failure. Committed export, +hosted CI and the complete portable cold-wrapper tail remain separate gates. +Stored PASS strings never replace fresh owner, moment or dual computations. diff --git a/research/staged-644-660-owner-successor/VENDOR.json b/research/staged-644-660-owner-successor/VENDOR.json new file mode 100644 index 0000000000..15af374bce --- /dev/null +++ b/research/staged-644-660-owner-successor/VENDOR.json @@ -0,0 +1,8 @@ +{ + "archive": "vendor/PR3605-SOURCES.tar.gz", + "changes": "None within archive; adapted new checker sources are separately listed in ADAPTATIONS.json.", + "description": "36 exact original Git blobs, selected minimal source closure; source SHA256 and original blob identity checked before extraction. No replacement refs used in export. Existing LICENSE and source-specific notices retained unchanged.", + "head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "manifest": "vendor/PR3605-MANIFEST.json", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/3605" +} diff --git a/research/staged-644-660-owner-successor/VERIFY.json b/research/staged-644-660-owner-successor/VERIFY.json new file mode 100644 index 0000000000..b36775470e --- /dev/null +++ b/research/staged-644-660-owner-successor/VERIFY.json @@ -0,0 +1,121 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "checks": "Fresh compact predecessor primal and complete literal, sparse owner journal, independent all-row windows/families/prefix/full-H audit, rigorous moment and joint outer checks, and all2551 fixed-inventory dual patterns. Full original admission is separate.", + "timeout_seconds": 600 + } + ], + "inputs": [ + "LICENSE", + "research/adaptive-kernel-demotion/vendor/engines/outer.py", + "research/coupled-carrier-cap740/.gitattributes", + "research/coupled-carrier-cap740/BASELINE-PR3143.json", + "research/coupled-carrier-cap740/CLAIM.json", + "research/coupled-carrier-cap740/EXCHANGE.json", + "research/coupled-carrier-cap740/FETCH.txt", + "research/coupled-carrier-cap740/MANIFEST.json", + "research/coupled-carrier-cap740/NOTICE", + "research/coupled-carrier-cap740/README.md", + "research/coupled-carrier-cap740/SOURCE-PINS.json", + "research/coupled-carrier-cap740/SOURCES.json", + "research/coupled-carrier-cap740/TASK.json", + "research/coupled-carrier-cap740/VENDOR.json", + "research/coupled-carrier-cap740/VERIFY.json", + "research/coupled-carrier-cap740/cap_check.py", + "research/coupled-carrier-cap740/common.py", + "research/coupled-carrier-cap740/construct.py", + "research/coupled-carrier-cap740/evidence/ADMISSION-RESULT.json", + "research/coupled-carrier-cap740/evidence/COMPOSITION-RESULT.json", + "research/coupled-carrier-cap740/evidence/ENVIRONMENT.json", + "research/coupled-carrier-cap740/evidence/FINITE.json", + "research/coupled-carrier-cap740/evidence/INVOICE-PAYLOAD.json", + "research/coupled-carrier-cap740/evidence/MATERIALIZED.json", + "research/coupled-carrier-cap740/evidence/NATIVE-RECEIPT.json", + "research/coupled-carrier-cap740/evidence/NATIVE-base-STEPS.json", + "research/coupled-carrier-cap740/evidence/NATIVE-extra-STEPS.json", + "research/coupled-carrier-cap740/evidence/OUTER-CLAIM.json", + "research/coupled-carrier-cap740/evidence/OVERLAP.json", + "research/coupled-carrier-cap740/evidence/PREFIX-AND-INVOICE.json.gz", + "research/coupled-carrier-cap740/evidence/RECIPE.json", + "research/coupled-carrier-cap740/evidence/RELEASE-RECEIPT.json", + "research/coupled-carrier-cap740/evidence/RETAINED-REUSE-RECEIPT.json", + "research/coupled-carrier-cap740/evidence/RUN.json", + "research/coupled-carrier-cap740/evidence/logs/complete-admission.log.txt", + "research/coupled-carrier-cap740/evidence/logs/declared-edit-stage.log.txt", + "research/coupled-carrier-cap740/evidence/logs/derive-closed-adapters.log.txt", + "research/coupled-carrier-cap740/evidence/logs/export-pr2833.log.txt", + "research/coupled-carrier-cap740/evidence/logs/export-pr2894.log.txt", + "research/coupled-carrier-cap740/evidence/logs/final-outer.log.txt", + "research/coupled-carrier-cap740/evidence/logs/final-source.log.txt", + "research/coupled-carrier-cap740/evidence/logs/four-kernel-stage.log.txt", + "research/coupled-carrier-cap740/evidence/logs/fresh-current-native.log.txt", + "research/coupled-carrier-cap740/evidence/logs/paired-extension-stage.log.txt", + "research/coupled-carrier-cap740/evidence/logs/parent-paired-stage.log.txt", + "research/coupled-carrier-cap740/evidence/logs/pr3136-local-audit.log.txt", + "research/coupled-carrier-cap740/evidence/logs/preload-stage.log.txt", + "research/coupled-carrier-cap740/evidence/logs/public-fresh-preflight.log.txt", + "research/coupled-carrier-cap740/evidence/logs/public-preflight.log.txt", + "research/coupled-carrier-cap740/evidence/logs/rank7-overlay-stage.log.txt", + "research/coupled-carrier-cap740/materialize.py", + "research/coupled-carrier-cap740/reproduce.py", + "research/coupled-carrier-cap740/requirements-full.txt", + "research/coupled-carrier-cap740/run_release.py", + "research/coupled-carrier-cap740/test_allocation.py", + "research/coupled-carrier-cap740/test_bindings.py", + "research/coupled-carrier-cap740/vendor/PR3133-CAP.json", + "research/coupled-carrier-cap740/vendor/PR3133-CLAIM.json", + "research/coupled-carrier-cap740/vendor/PR3133-CREDITS.md", + "research/coupled-carrier-cap740/vendor/PR3133-FILL.json.gz", + "research/coupled-carrier-cap740/vendor/PR3133-MANIFEST.json", + "research/coupled-carrier-cap740/vendor/PR3133-NOTICE", + "research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json", + "research/coupled-carrier-cap740/vendor/lift.py", + "research/coupled-carrier-cap740/verify.py", + "research/coupled-carrier-cap740/verify_release.py", + "research/coupled-carrier-cap740/words/base.json.gz", + "research/coupled-carrier-cap740/words/extra.json.gz", + "research/gmx-t74-borrow43-handoff/CLAIM.json", + "research/gmx-t74-borrow43-handoff/code/assemble.py", + "research/gmx-t74-borrow43-handoff/outer/check_ledger.py", + "research/gmx-t74-borrow43-handoff/outer/independent_check.py", + "research/rank7-coupled-586-588-carrier-fold/CREDITS.md", + "research/rank7-coupled-586-588-carrier-fold/NOTICE", + "research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-base.json.gz", + "research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-extra.json.gz", + "research/rank7-coupled-586-588-carrier-fold/vendor/audit_local.py", + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "research/rank7-joint-endframes/allocation/vendor/independent_owners.py", + "research/rank7-joint-endframes/tools/root.py", + "research/t74-native-fast/LICENSE", + "research/t74-native-fast/NATIVE-LINEAGE-NOTICE", + "research/t74-native-fast/vendor/native/new/code/borrow/NOTICE-PR2226.md", + "research/t74-native-fast/vendor/native/new/code/borrow/bw_adapters.py", + "research/t74-native-fast/vendor/native/new/code/borrow/bw_audit_local.py", + "research/t74-native-fast/vendor/native/new/code/borrow/bw_check_recipes.py", + "research/t74-native-fast/vendor/native/new/code/borrow/bw_emit.py", + "research/t74-native-fast/vendor/native/new/code/borrow/bw_gauss.py", + "research/t74-native-fast/vendor/native/new/code/borrow/bw_phases.py", + "research/t74-native-fast/vendor/native/new/code/borrow/bw_tamper.py", + "research/t74-native-fast/vendor/native/new/code/borrow/bw_transport.py", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/pr2226_operators.py", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/pr2226_replay.py", + "research/tensor-block-kappa/PROOF.md", + "research/two-sided-helper-extraction/tools/audit_moment.py" + ], + "python": "3.12", + "requirements": [ + "numpy==2.5.4" + ], + "schema_version": 1, + "status": "ready" +} diff --git a/research/staged-644-660-owner-successor/apply_journal.py b/research/staged-644-660-owner-successor/apply_journal.py new file mode 100644 index 0000000000..c87419b7b2 --- /dev/null +++ b/research/staged-644-660-owner-successor/apply_journal.py @@ -0,0 +1,77 @@ +"""Apply the complete five-owner, 24-row journal to regenerated PR3605 owners. + +Every proof-relevant payload byte is checked. Gzip headers and deflate streams +are permitted to vary. Source: this run's replay_A.py, with container equality +removed from admission, explicit journal predicates and targeted controls added. +""" +from pathlib import Path +import argparse,gzip,hashlib,json,re +ROWS=2717280 +OLD_PAYLOAD='653085641ff2e9470e25aedfc92861ec34e5cf594d52123e8b28b6f0ec20b9f8' +NEW_PAYLOAD='d1ab78aaf268303bab0baca9a0aa3b607fbc9d49cba3e45d0634eca734ddd57c' +DELTA={'1':-4,'4':-1,'5':1,'6':-3,'7':3} +PROFILE={'1':16417892,'2':4835160,'3':1540174,'4':679320,'5':143993,'7':3,'8':53280,'48':283185} +MOVES={16544:[22,6,111],16545:[25,6,111],16546:[135,6,26],130613:[703,12,0],1355192:[18,15,111]} +def need(v,message): + if not v:raise ValueError(message) +def sha(b):return hashlib.sha256(b).hexdigest() +def encode(row):return json.dumps(row,separators=(',',':')).encode('ascii') +def validate(j): + entries=j['all_changed_rows'];need(len(entries)==24,'all24 changed rows required') + edits={} + for e in entries: + i=e['index'];need(type(i)is int and 0<=i=0 for v in e[k]) for k in ('old','new')),'six nonnegative integer columns') + need(e['old'][:2]==e['new'][:2]==[i//408,i%408],'call/helper identities unchanged') + need(e['old']!=e['new'],'only actual changes journaled');edits[i]=e + changed={i:e['new'][2:5] for i,e in edits.items() if e['old'][2:5]!=e['new'][2:5]} + need(changed==MOVES,'exact five whole-owner destinations') + need(sum(e['old'][5]!=e['new'][5] for e in entries)==21,'all21 offset changes') + need(len(j['moves'])==5 and {e['index'] for e in j['moves']}==set(MOVES),'complete five-move explanation') + for e in j['moves']: + need(e['old']==edits[e['index']]['old'] and e['new'][:5]==edits[e['index']]['new'][:5],'move and full journal agree') + need(j['delta']==DELTA and j['profile']==PROFILE,'complete declared delta and profile') + need(sum(int(r)*n for r,n in DELTA.items())==0,'rank mass preserved') + return edits + +def apply_payload(payload,j): + need(sha(payload)==OLD_PAYLOAD,'complete predecessor literal payload') + edits=validate(j);prefix,body=payload.split(b',"rows":[',1) + need(json.loads(prefix+b'}')==dict(columns=['time','helper','owner_replica','child','port','offset'],dispatch_overrides=[]),'literal predecessor schema') + start=len(prefix)+len(b',"rows":[');parts=[];previous=0;found=set();count=0 + for i,match in enumerate(re.finditer(rb'\[\d+,\d+,\d+,\d+,\d+,\d+\]',body)): + count+=1 + if i in edits: + e=edits[i];need(match.group()==encode(e['old']),'exact changed-row preimage') + absolute=start+match.start();parts.extend((payload[previous:absolute],encode(e['new'])));previous=start+match.end();found.add(i) + need(count==ROWS and found==set(edits),'complete literal row and patch coverage');parts.append(payload[previous:]);result=b''.join(parts) + need(sha(result)==NEW_PAYLOAD,'complete successor literal payload') + return result + +def controls(j): + results=[] + def reject(name,mutate,reason): + changed=json.loads(json.dumps(j));mutate(changed) + try:validate(changed) + except ValueError as e:need(str(e)==reason,'wrong rejection '+name);results.append(name) + else:raise ValueError('accepted defect '+name) + reject('omitted offset edit',lambda x:x['all_changed_rows'].pop(),'all24 changed rows required') + reject('duplicate edited identity',lambda x:x['all_changed_rows'].__setitem__(1,x['all_changed_rows'][0]),'duplicate literal row edit') + reject('changed helper identity',lambda x:x['all_changed_rows'][0]['new'].__setitem__(1,407),'call/helper identities unchanged') + reject('changed owner destination',lambda x:x['all_changed_rows'][0]['new'].__setitem__(2,739),'exact five whole-owner destinations') + reject('omitted relay explanation',lambda x:x['moves'].pop(),'complete five-move explanation') + reject('unpaid rank-one child',lambda x:x['profile'].__setitem__('1',x['profile']['1']+1),'complete declared delta and profile') + return results + +def replay(source,journal,out): + need(not out.exists(),'fresh output required');j=json.loads(journal.read_bytes());payload=gzip.decompress(source.read_bytes());result=apply_payload(payload,j);checks=controls(j) + # Equivalent container representation is a positive semantic control. + alternate=gzip.compress(payload,compresslevel=1,mtime=12345) + need(alternate!=source.read_bytes() and gzip.decompress(alternate)==payload,'alternate gzip has identical complete payload') + out.parent.mkdir(parents=True,exist_ok=True) + with out.open('xb') as f,gzip.GzipFile(filename='',fileobj=f,mode='wb',compresslevel=1,mtime=0) as z:z.write(result) + need(gzip.decompress(out.read_bytes())==result,'written complete successor payload') + return dict(status='PASS_COMPLETE_SEMANTIC_SUCCESSOR_JOURNAL',rows=ROWS,changed_rows=24,moves=5,payload_sha256=sha(result),container_sha256=sha(out.read_bytes()),source_payload_sha256=sha(payload),controls=checks,equivalent_gzip_positive_control=True,scope='Exact complete literal transformation only; independent chronology/family/prefix/full invoice and complete release are separate obligations.') +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path,required=True);ap.add_argument('--journal',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args();print(json.dumps(replay(a.source,a.journal,a.out),sort_keys=True,indent=2)) +if __name__=='__main__':main() diff --git a/research/staged-644-660-owner-successor/check.py b/research/staged-644-660-owner-successor/check.py new file mode 100644 index 0000000000..f63786c04d --- /dev/null +++ b/research/staged-644-660-owner-successor/check.py @@ -0,0 +1,55 @@ +"""Fresh complete predecessor generation, sparse successor and exact transfer. + +No optimizer or stored success receipt certifies the new owners. Full unchanged +native operators are a pinned predecessor premise; only their frame tables are +regenerated here. Complete strict supplier release is a separate long gate. +""" +from pathlib import Path +import argparse,hashlib,json,os,shutil,subprocess,sys,time,types +from fractions import Fraction as Q +P=Path(__file__).resolve().parent +def load(name): + path=P/(name+'.py');m=types.ModuleType(name);m.__file__=str(path) + exec(compile(path.read_bytes(),str(path),'exec'),m.__dict__);return m +extract=load('predecessor').extract +J=load('apply_journal');replay,PROFILE=J.replay,J.PROFILE +OLD_K=Q('0.001730006549538841847005')-Q(1,10**46)-Q(1,10**70) +def need(v,s): + if not v:raise ValueError(s) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(p.read_bytes()) +def save(p,x):p.write_text(json.dumps(x,sort_keys=True,indent=2)+'\n') +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--repo',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args();repo=a.repo.resolve();out=a.out.resolve() + need(not out.exists() and not out.is_relative_to(P) and not P.is_relative_to(out),'fresh disjoint output');out.mkdir(parents=True) + pred,word=extract(out/'predecessor');pins={} + for rel,digest in read(pred/'owners/SOURCE-PINS.json')['repo_files'].items():pins[rel]=digest + pins.update(read(pred/'ARITHMETIC-PINS.json')['repo']) + for item in read(word/'SOURCES.json')['files']: + if item['usage']=='input':pins[item['path']]=item['sha256'] + for rel,digest in pins.items():need((repo/rel).is_file() and not (repo/rel).is_symlink() and sha(repo/rel)==digest,'live source '+rel) + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONPYCACHEPREFIX=str(out/'pycache'),PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1',OWNER_SOURCE_REPO=str(repo)) + for k in ('PYTHONPATH','PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_RECORD','WITNESS_DISCOVER'):env.pop(k,None) + stages=[];started=time.monotonic() + def run(name,script,*args): + log=out/(name+'.log');t=time.monotonic() + with log.open('wb') as f:r=subprocess.run([sys.executable,'-B',str(script),*map(str,args)],env=env,stdout=f,stderr=subprocess.STDOUT,timeout=300) + stages.append(dict(stage=name,seconds=time.monotonic()-t,exit_code=r.returncode,script_sha256=sha(script),log_sha256=sha(log)));save(out/'STAGES.json',stages);need(r.returncode==0,'failed '+name+'; '+str(log)) + run('predecessor-integer-primal-and-controls',pred/'owners/verify_aggregate.py') + run('fresh-predecessor-literal',pred/'owners/portable_expand.py','--out',out/'before') + candidate=out/'candidate';candidate.mkdir() + for name in ('ORDER.json','DISPATCH.json','PROVIDERS.json'):shutil.copyfile(out/'before'/name,candidate/name) + save(candidate/'PROFILE.json',PROFILE) + change=replay(out/'before/COMPOSED-FILL.json.gz',P/'JOURNAL.json',candidate/'COMPOSED-FILL.json.gz');save(out/'JOURNAL-REPLAY.json',change) + for tag in ('base','extra'):run('fresh-frame-table-'+tag,repo/'research/t74-native-fast/vendor/native/new/code/borrow/bw_transport.py',word/f'STAGED644-660-{tag}.json.gz',out/f'native/checked-{tag}') + env.update(OWNER_LITERAL_DIR=str(candidate),OWNER_NATIVE_DIR=str(out/'native'),OWNER_PREDECESSOR_DIR=str(out/'before'),OWNER_AUDIT_OUTPUT=str(out/'INDEPENDENT-OWNERS.json')) + run('independent-complete-successor',P/'independent_owners.py') + run('full-moment-and-outer',pred/'check_arithmetic.py','--repo',repo,'--profile',candidate/'PROFILE.json','--owner-result',out/'INDEPENDENT-OWNERS.json','--out',out/'arithmetic') + run('all-pattern-fixed-inventory-dual',P/'check_budget.py','--predecessor',pred,'--out',out/'DUAL.json') + owner=read(out/'INDEPENDENT-OWNERS.json');arith=read(out/'arithmetic/RESULT.json') + need(owner['roles']==2717280 and owner['profile']==PROFILE,'complete candidate histogram') + need(Q(arith['kappa'])>OLD_K and Q(arith['root_interval'][0])==Q('0.001730006690311348872326'),'strict improvement at exact nominated endpoint') + need(all(sha(repo/rel)==digest for rel,digest in pins.items()),'live input drift') + result=dict(status='PASS_FRESH_FIVE_OWNER_SUCCESSOR_AND_EXACT_ARITHMETIC',roles=owner['roles'],profile=owner['profile'],idle=owner['idle'],kappa=arith['kappa'],kappa_decimal=arith['kappa_decimal'],root_interval=arith['root_interval'],gain=str(Q(arith['kappa'])-OLD_K),journal=change,stages=stages,seconds=time.monotonic()-started,source_sha256=pins,scope='Fresh finite literal and exact arithmetic. Unchanged native/source proofs are pinned predecessor evidence; full strict release and inherited all-size hypotheses are separate.') + save(out/'RESULT.json',result);print(json.dumps({k:result[k] for k in ('status','roles','kappa_decimal','seconds')},sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/staged-644-660-owner-successor/check_budget.py b/research/staged-644-660-owner-successor/check_budget.py new file mode 100644 index 0000000000..a1de88c5f7 --- /dev/null +++ b/research/staged-644-660-owner-successor/check_budget.py @@ -0,0 +1,121 @@ +"""Re-enumerate every pattern and certify the fixed-inventory dual. + +Derived from the separate review_budget.py by Ross Richardson with substantial +OpenAI Codex assistance; see ADAPTATIONS.json. No optimizer or cached PASS input. +The source-bound positive-binomial engine is credited to PR3531. +""" +from collections import Counter +from fractions import Fraction as Q +from itertools import product +from pathlib import Path +import argparse, hashlib, json, types +ap = argparse.ArgumentParser(description=__doc__) +ap.add_argument('--predecessor', type=Path, required=True) +ap.add_argument('--out', type=Path, required=True) +a = ap.parse_args() +binomial_source = (a.predecessor / 'vendor/pr3531/binomial.py').read_bytes() +if hashlib.sha256(binomial_source).hexdigest() != '03eebf2be23cab07e5f9e978980fee7b17e10847da5720c3e4e0adb243e8e4fa': + raise ValueError('source-bound binomial engine') +B = types.ModuleType('positive_binomial_dual') +exec(compile(binomial_source, 'PR3531/binomial.py', 'exec'), B.__dict__) +M, T, W = (73, 740, 663040) +CAPS = (8, 16, 32, 48) +WIDTHS = (4, 5, 6, 7, 8, 9) +CAP_TOTAL = (672, 448, 448, 448) +INVENTORY = (26, 2, 18, 52, 97, 213) +H0 = {1: 16417896, 2: 4835160, 3: 1540174, 4: 679321, 5: 143992, 6: 3, 8: 53280, 48: 283185} +HA = {1: 16417892, 2: 4835160, 3: 1540174, 4: 679320, 5: 143993, 7: 3, 8: 53280, 48: 283185} +DELTA = {1: -4, 4: -1, 5: 1, 6: -3, 7: 3} +L = {1: 2439, 2: 726, 3: 224, 4: 102, 5: 20, 8: 8} +C0 = Q('0.001730006549538841847005') +CA = Q('0.001730006690311348872326') +LO = Q('0.001730096363528623534230') +HI = LO + Q(1, 10 ** 24) + +def solve(a, b): + n = len(a) + z = [[Q(v) for v in row] + [Q(b[i])] for i, row in enumerate(a)] + for j in range(n): + k = next((k for k in range(j, n) if z[k][j])) + z[j], z[k] = (z[k], z[j]) + q = z[j][j] + z[j] = [x / q for x in z[j]] + for k in range(n): + if k != j: + q = z[k][j] + z[k] = [x - q * y for x, y in zip(z[k], z[j])] + return [row[-1] for row in z] +patterns = [] +for capacity in CAPS: + for counts in product(*(range(capacity // width + 1) for width in WIDTHS)): + used = sum((n * w for n, w in zip(counts, WIDTHS))) + if used <= capacity: + patterns.append((capacity, counts, capacity - used)) +if not len(patterns) == len(set(patterns)) == 2551: + raise ValueError('dual condition: len(patterns) == len(set(patterns)) == 2551') +column = lambda p: [Q(p[0] == capacity) for capacity in CAPS] + list(map(Q, p[1])) +specs = [(8, (8,), Q(672)), (16, (7, 9), Q(448)), (32, (9, 9, 9), Q(57, 4)), (32, (7, 8, 8, 9), Q(39, 2)), (32, (7, 7, 9, 9), Q(1, 4)), (32, (6, 8, 9, 9), Q(162)), (32, (5, 9, 9, 9), Q(18)), (32, (4, 9, 9, 9), Q(234)), (48, (), Q(1531, 4)), (48, (9, 9, 9, 9, 9), Q(261, 4))] +basis = [(cap, tuple((ws.count(w) for w in WIDTHS)), cap - sum(ws)) for cap, ws, n in specs] +amount = [n for cap, ws, n in specs] +if not all((p in patterns for p in basis)): + raise ValueError('dual condition: all((p in patterns for p in basis))') +columns = [column(p) for p in basis] +A = list(map(list, zip(*columns))) +rhs = list(map(Q, CAP_TOTAL)) + [Q(9 * n) for n in INVENTORY] +if not [sum((a * n for a, n in zip(row, amount))) for row in A] == rhs: + raise ValueError('dual condition: [sum((a * n for a, n in zip(row, amount))) for row in A] == rhs') +if not (solve(A, rhs) == amount and all((n > 0 for n in amount))): + raise ValueError('dual condition: solve(A, rhs) == amount and all((n > 0 for n in amount))') +ideal_idle = Counter() +for p, n in zip(basis, amount): + if p[2]: + ideal_idle[p[2]] += n * T +ideal = Counter({r: 9 * T * n for r, n in L.items()}) +ideal.update(ideal_idle) +if not all((Q(n).denominator == 1 for n in ideal.values())): + raise ValueError('dual condition: all((Q(n).denominator == 1 for n in ideal.values()))') +ideal = {r: int(n) for r, n in ideal.items()} +if not sum((r * n for r, n in ideal.items())) == sum((r * n for r, n in HA.items())) == 65088 * T: + raise ValueError('dual condition: sum((r * n for r, n in ideal.items())) == sum((r * n for r, n in HA.items())) == 65088 * T') +root_enclosures = {} +for name, profile, lo, hi in [('predecessor', H0, C0, C0 + Q(1, 10 ** 24)), ('candidate_A', HA, CA, CA + Q(1, 10 ** 24)), ('relaxed_ceiling', dict(ideal), LO, HI)]: + below = B.moment(profile, lo, W) + above = B.moment(profile, hi, W) + if not below[1] < 1 < above[0]: + raise ValueError('dual condition: below[1] < 1 < above[0]') + root_enclosures[name] = {'lower': str(lo), 'upper': str(hi), 'moment_at_lower': list(map(str, below)), 'moment_at_upper': list(map(str, above))} +cache = {} + +def f(rank, b): + if rank == 0: + return (Q(0), Q(0)) + if (rank, b) not in cache: + cache[rank, b] = tuple((73 * x for x in B.moment({rank: 1}, b, 1))) + return cache[rank, b] +dual_symbolic = [solve(list(map(list, zip(*A))), [int(i == j) for i in range(10)]) for j in range(10)] + +def coefficients(p): + a = column(p) + out = Counter({p[2]: Q(1)}) if p[2] else Counter() + for j, bp in enumerate(basis): + if bp[2]: + out[bp[2]] -= sum((x * y for x, y in zip(a, dual_symbolic[j]))) + return {r: n for r, n in out.items() if n} +tight = [] +strict = [] +coefficient_hash = hashlib.sha256() +for p in patterns: + coeff = coefficients(p) + coefficient_hash.update(json.dumps([p, sorted(((r, str(n)) for r, n in coeff.items()))], separators=(',', ':')).encode()) + if not coeff: + tight.append(p) + continue + lower = sum((n * f(r, LO if n > 0 else HI)[0 if n > 0 else 1] for r, n in coeff.items())) + if not lower > 0: + raise ValueError('dual condition: lower > 0') + strict.append((lower, p)) +if not (len(tight), len(strict)) == (12, 2539): + raise ValueError('dual condition: (len(tight), len(strict)) == (12, 2539)') +result = dict(status='PASS_ALL_2551_FIXED_INVENTORY_PATTERNS', patterns=len(patterns), strict=len(strict), symbolically_zero=len(tight), coefficient_sha256=coefficient_hash.hexdigest(), root_enclosures=root_enclosures, ideal_profile=ideal, min_reduced_cost_lower=str(min(strict)[0]), scope='Finite exhaustive dual plus written scaling proof for every positive integer T with the same capacities, width inventory, local bill and live stock896T; no chronological attainment or global optimum.') +a.out.write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') +print(result['status']) diff --git a/research/staged-644-660-owner-successor/check_release_binding.py b/research/staged-644-660-owner-successor/check_release_binding.py new file mode 100644 index 0000000000..abbcb96540 --- /dev/null +++ b/research/staged-644-660-owner-successor/check_release_binding.py @@ -0,0 +1,42 @@ +"""Bind exact historical release evidence to newly recomputed owners/arithmetic. + +This authenticates the recorded complete release. It does not substitute receipt +strings for fresh bounded owner/moment/dual computation or rerun the long release. +""" +from pathlib import Path +from fractions import Fraction as Q +import argparse,gzip,hashlib,io,json,tarfile +P=Path(__file__).resolve().parent +def need(v,s): + if not v:raise ValueError(s) +def sha(b):return hashlib.sha256(b).hexdigest() +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--fresh',type=Path,required=True);a=ap.parse_args() + m=json.loads((P/'evidence/MANIFEST.json').read_bytes());z=(P/'evidence/ACTUAL-RELEASE.tar.gz').read_bytes();need(sha(z)==m['archive_sha256'],'immutable historical evidence archive') + raw=gzip.decompress(z);need(sha(raw)==m['payload_sha256'],'historical evidence payload');docs={};blobs={} + with tarfile.open(fileobj=io.BytesIO(raw),mode='r:') as t: + members=t.getmembers();need(len(members)==len(m['files']) and {x.name for x in members}==set(m['files']),'complete evidence inventory') + for x in members: + need(x.isfile() and not x.name.startswith('/') and '..' not in Path(x.name).parts,'safe evidence path') + b=t.extractfile(x).read();need(len(b)==m['files'][x.name]['bytes'] and sha(b)==m['files'][x.name]['sha256'],'exact raw evidence '+x.name);blobs[x.name]=b;docs[x.name]=json.loads(b) + c=json.loads((P/'CLAIM.json').read_bytes());fresh=json.loads((a.fresh/'RESULT.json').read_bytes());owner=json.loads((a.fresh/'INDEPENDENT-OWNERS.json').read_bytes()) + get=lambda n:docs['full-release/candidate/'+n] + review=docs['conditional-review/FINAL-RELEASE-REVIEW.json'];release=get('release/RELEASE-RECEIPT.json');summary=get('release/verify/RESULT.json');audit=get('release/verify/strict/global/audit/ASYNC-AUDIT.json');invoice=get('release/verify/strict/global/audit/PREFIX-AND-INVOICE.json');idle=get('release/verify/strict/global/audit/IDLE-REMAINDER-FRAMES.json');ledger=get('package/outer/LEDGER.json');recovery=docs['full-release/RECOVERY-RELEASE.json'] + for name,digest in review['input_sha256'].items(): + if name in blobs:need(sha(blobs[name])==digest,'independent review exact binding '+name) + need(sha(blobs['conditional-review/FINAL-RELEASE-REVIEW.json'])==c['final_review_sha256'] and sha(blobs['full-release/candidate/release/RELEASE-RECEIPT.json'])==c['release_receipt_sha256'],'authoritative final hashes') + need(release['status']=='PASS_RELEASE' and release['manifest_sha256']==c['generated_package_manifest_sha256'],'complete recorded release') + need(recovery['execution']['exit_code']==0 and recovery['release_receipt_sha256']==c['release_receipt_sha256'],'distinct successful unchanged release retry') + need(Q(c['kappa'])==Q(release['kappa_decimal'])==Q(fresh['kappa'])==Q(review['kappa']),'same fresh and released exact K') + need(Q(c['kappa'])==Q(c['complex_lower'])-Q(1,10**46)-Q(1,10**70),'declared modern outer map') + need(Q(c['exact_gain_over_PR3605'])==Q(c['kappa'])-(Q('.001730006549538841847005')-Q(1,10**46)-Q(1,10**70))>0,'strict exact predecessor comparison') + need(c['histogram']==fresh['profile']==owner['profile']==review['histogram']==audit['complex_profile'],'complete fresh and released profile') + need(c['idle']==fresh['idle']==idle['rank_profile'],'actual three rank-seven idle children') + need(audit['physical']==c['physical']==663549 and audit['complex_live']==c['live']==663040 and audit['complex_hosted_residuals']==owner['roles']==2717280,'whole physical/live invoice') + need(audit['actual_orthogonal_73column_maps']==8758 and len(audit['mutations_rejected'])==25,'all actual charts and controller controls') + need(invoice['global_prefix_bits']==summary['prefix_bits']==c['prefix_bits']==1479 and invoice['charged_prefix_bits']==c['charged_prefix_bits']==2048,'actual paid prefix') + row=ledger['rows']['struct_boundary_radix_union'];controls=ledger['rejecting_controls']['struct_boundary_radix_union'] + need(Q(row['kappa']['rational'])==Q(c['kappa']) and len(row['strict_checks'])==63 and all(Q(v['rational'])>0 for v in row['strict_checks'].values()),'released modern outer rows') + need(len(controls)==17 and all(v and all(Q(z['rational'])<=0 for z in v.values()) for v in controls.values()),'released rejecting controls') + print('PASS_RECORDED_FULL_RELEASE_BOUND_TO_FRESH_LITERAL_AND_ARITHMETIC') +if __name__=='__main__':main() diff --git a/research/staged-644-660-owner-successor/evidence/ACTUAL-RELEASE.tar.gz b/research/staged-644-660-owner-successor/evidence/ACTUAL-RELEASE.tar.gz new file mode 100644 index 0000000000..a19aa6e8b3 Binary files /dev/null and b/research/staged-644-660-owner-successor/evidence/ACTUAL-RELEASE.tar.gz differ diff --git a/research/staged-644-660-owner-successor/evidence/MANIFEST.json b/research/staged-644-660-owner-successor/evidence/MANIFEST.json new file mode 100644 index 0000000000..9db4109428 --- /dev/null +++ b/research/staged-644-660-owner-successor/evidence/MANIFEST.json @@ -0,0 +1,71 @@ +{ + "archive_sha256": "46f61dfd4f38d184bddc7aa1737eadfc834f30199edf5ae8761516fd10f0a17b", + "files": { + "conditional-review/FINAL-RELEASE-REVIEW.json": { + "bytes": 7327, + "sha256": "b462df012121d234437541e0873d32fb9c5f881374438a61899a32b6cd009cda" + }, + "full-release/FINAL-ADMISSION.json": { + "bytes": 24580, + "sha256": "57c11db6cdc725a78a716f36114497aaeec20001b78bbc4eaf99146a4eebefe0" + }, + "full-release/RECOVERY-RELEASE.json": { + "bytes": 2148, + "sha256": "ca67c84704aa57623b7362554a64cf140425b16d252e1cc86ac64ac10542d357" + }, + "full-release/candidate/package/MANIFEST.json": { + "bytes": 79940, + "sha256": "d6aa8f2c029beb040f3c65df5906cf2c748b881245cb2d50ef0435321dc787de" + }, + "full-release/candidate/package/new/SPEC.json": { + "bytes": 553784, + "sha256": "b21cced12fb3d342b6481e89074983802e80fccf61cd5e48e76d9569d9f2860d" + }, + "full-release/candidate/package/outer/LEDGER.json": { + "bytes": 49501, + "sha256": "ab9c17ad443ba8d565c1c2f5a13172eca09204ea288bfef02da666de063c78b7" + }, + "full-release/candidate/package/outer/OUTER-CLAIM.json": { + "bytes": 2141, + "sha256": "ed85baa0ff7d3094c734b28254aa4fc91c10518932418e4f6074e1972004edf2" + }, + "full-release/candidate/release/RELEASE-RECEIPT.json": { + "bytes": 2242, + "sha256": "ee5e3f2d4d75fd7596f736e03c680b65441f032d1346dccbec4678b6975e40d7" + }, + "full-release/candidate/release/verify/RESULT.json": { + "bytes": 4553, + "sha256": "8e2809404a82934d1aab9f9ba01786fc5ed49349f93e4404f5c80e251ba475da" + }, + "full-release/candidate/release/verify/strict/ASSEMBLY.json": { + "bytes": 36471, + "sha256": "6fdbcff7e1584e8945e7ca6520bbf20626bdfaa08ae5f4ac7277d0e43ee8e2b7" + }, + "full-release/candidate/release/verify/strict/INDEPENDENT.json": { + "bytes": 6925, + "sha256": "bd80cb0194f64e93db830376b87f5edd507f4f72ce607be227f8625c8a7b9c10" + }, + "full-release/candidate/release/verify/strict/global/audit/ASYNC-AUDIT.json": { + "bytes": 4487, + "sha256": "317e504aab76288c6f3ba65fed8ca15e96530cc77304735a4221760d36e29ace" + }, + "full-release/candidate/release/verify/strict/global/audit/IDLE-REMAINDER-FRAMES.json": { + "bytes": 586, + "sha256": "8550a1abcff2d2e2d01f63978128d91052adea57c8d08da3c4749a0a4420e18b" + }, + "full-release/candidate/release/verify/strict/global/audit/OWNERS-AND-PROFILE.json": { + "bytes": 4269, + "sha256": "21e464e73ceb06e180cb83a8bd288356c14ed176304f61cd0f9f95a1e8de7ec2" + }, + "full-release/candidate/release/verify/strict/global/audit/PREFIX-AND-INVOICE.json": { + "bytes": 3081057, + "sha256": "3749227f49987132b89ee2ff46f00affdac0dc4ae91c2dee300b4ad3fa5c5ba9" + }, + "full-release/recovery-1/DIAGNOSIS.json": { + "bytes": 5276, + "sha256": "a9ee5d8e1cab3f0960cdec5a0c68f1a66c2359e21cb2dddbdefc175987ce6c63" + } + }, + "payload_sha256": "1f52b7dbba55fe2038d1bab8242c76a0f50d5a2cdd9f51ed5f1cdf3c1256654c", + "scope": "Exact historical scientific execution receipts; original local run paths are provenance, never runtime inputs. Personal runner code/configuration remains outside Git. The source-specific complete release can be regenerated by reproduce.py; receipt authentication does not rerun it." +} diff --git a/research/staged-644-660-owner-successor/independent_owners.py b/research/staged-644-660-owner-successor/independent_owners.py new file mode 100644 index 0000000000..f116cc0142 --- /dev/null +++ b/research/staged-644-660-owner-successor/independent_owners.py @@ -0,0 +1,128 @@ +"""Independent vectorized audit of the literal staged-pair owner journal. + +No optimizer, producer, inherited owner checker or reconstructor is imported. +Uses the source execution template and the actual checked native frame tables. +""" +from pathlib import Path +from collections import Counter +import gzip,hashlib,json,os +import numpy as np +for key in ('OWNER_SOURCE_REPO','OWNER_LITERAL_DIR','OWNER_NATIVE_DIR','OWNER_PREDECESSOR_DIR','OWNER_AUDIT_OUTPUT'): + if not os.environ.get(key):raise ValueError('missing '+key) +A=Path(os.environ['OWNER_LITERAL_DIR']).resolve() +NATIVE=Path(os.environ['OWNER_NATIVE_DIR']).resolve() +PARENT=Path(os.environ['OWNER_PREDECESSOR_DIR']).resolve() +S=Path(os.environ['OWNER_SOURCE_REPO']).resolve()/'research/rank7-joint-endframes/allocation/vendor' +def need(v,m): + if not v:raise ValueError(m) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def rank(v): + piv={} + for q in v: + while q: + h=q.bit_length() + if h in piv:q^=piv[h] + else:piv[h]=q;break + return len(piv) +paths=[A/n for n in ('COMPOSED-FILL.json.gz','ORDER.json','DISPATCH.json','PROFILE.json')]+[S/'PLAN.json.gz',S/'TEMPLATE.json.gz'] +paths += [NATIVE/f'checked-{p}/CANONICAL-WORD.json.gz' for p in ('base','extra')] +pins={str(p):sha(p) for p in paths} +order=read(paths[1]);dispatch=read(paths[2]);profile={int(k):v for k,v in read(paths[3]).items()};plan=read(paths[4]);template=read(paths[5]) +T=740;N=9*T +need(len(order)==N and len(set(map(tuple,order)))==N,'call coverage') +clock={tuple(call):t for t,call in enumerate(order)} +need(set(clock)=={(s,r) for s in range(9) for r in range(T)},'exact source calls') +need(all([clock[s,r] for s in range(9)]==sorted(clock[s,r] for s in range(9)) for r in range(T)),'per-replica order') +D={(s,r):p for s,r,p in dispatch};need(len(dispatch)==N and set(D)==set(clock),'dispatch coverage') +need(Counter(D.values())=={'gauge44':2500,'extra':4160},'provider count') +# Reconstruct source windows per replica from the actual source event sequence. +children={x['child']:x['rank'] for x in template['idle_children']};K=max(children)+1 +cap=np.zeros((T,K),dtype=np.int64);lo=np.full((T,K),N,dtype=np.int64);hi=np.full((T,K),-2,dtype=np.int64) +local_pair={x['stage']:x['pair'] for x in template['recipe'] if x['kind']=='local'} +for r in range(T): + touched={};t=None + for ev in template['execution_schedule']: + kind=ev['kind'] + if kind in ('bank_padding_cover_sweep','translate_every_live_family'):continue + if kind=='local_cover_sweep': + t=clock[ev['stage'],r];touched[local_pair[ev['stage']]]=t + elif kind=='bridge': + need(t is not None,'bridge source');touched[ev['src']]=t;touched[ev['dst']]=t + elif kind=='idle_cover_sweep': + need(t is not None,'idle source') + for c in ev['child_indices']: + if c in children: + need(cap[r,c]==0,'unique source child');cap[r,c]=children[c];lo[r,c]=touched.get(ev['pair'],-1);hi[r,c]=t + else:need(kind in ('terminal_Y_translations','terminal'),'known source event') +need(np.all(cap[:,list(children)]>0),'all source windows') +fam=np.full(K,-1,np.int64) +for c in children:fam[c]=2*plan['pairs'][str(c)]+plan['sides'][str(c)] +widths={};L=None +for tag,pid in [('base','gauge44'),('extra','extra')]: + w=read(NATIVE/f'checked-{tag}/CANONICAL-WORD.json.gz') + need(w['R']==408 and len(w['zero_buffers'])==91,'native helper stock') + widths[pid]=np.array([rank(w['frames'][w['final'][224+h]])-rank(w['frames'][w['start'][224+h]]) for h in range(408)],dtype=np.int64) + need(Counter(widths[pid])=={4:26,5:2,6:18,7:52,8:97,9:213},'actual native widths') + loc={int(k):v for k,v in w['local_profile'].items()} + need(L is None or L==loc,'common actual native bill');L=loc +need(L=={1:2439,2:726,3:224,4:102,5:20,8:8},'new local bill') +bycall=np.stack([widths[D[tuple(call)]] for call in order]) +j=read(A/'COMPOSED-FILL.json.gz');need(j['columns']==['time','helper','owner_replica','child','port','offset'] and j['dispatch_overrides']==[],'journal schema') +need(all(len(row)==6 and all(type(v) is int for v in row) for row in j['rows']),'literal integer roles') +rows=np.array(j['rows'],dtype=np.int64);del j +need(rows.shape==(N*408,6),'literal role shape') +need(np.array_equal(rows[:,0],np.repeat(np.arange(N),408)) and np.array_equal(rows[:,1],np.tile(np.arange(408),N)),'complete literal ordered helper identities') +t,h,o,c,p,z=rows.T +need(np.all((o>=0)&(o=0)&(c=0)&(p<112)),'owner bounds') +need(np.all(cap[o,c]>0),'declared source child') +need(np.all((lo[o,c]=0)&(z+w<=cap[o,c])),'actual widths and capacity') +binid=(o*K+c)*112+p +idx=np.lexsort((t,binid));bins=binid[idx];ws=w[idx];starts=np.r_[True,bins[1:]!=bins[:-1]] +cs=np.cumsum(ws,dtype=np.int64)-ws;baseline=np.maximum.accumulate(np.where(starts,cs,0));expected=cs-baseline +need(np.array_equal(z[idx],expected),'every chronological pending mask is a compact prefix') +used=np.zeros(T*K*112,np.int64);np.add.at(used,binid,w) +allcap=np.repeat(cap.reshape(-1),112);valid=allcap>0 +need(np.all(used[~valid]==0) and np.all(used<=allcap),'full used-bin mass') +idle=Counter(map(int,(allcap-used)[valid]));idle.pop(0,None) +H=Counter({r:n*N for r,n in L.items()});H.update(idle) +need(dict(H)==profile and sum(r*n for r,n in H.items())==65088*T,'independent complete histogram') +# Small semantic predicates test each independent gate on actual changed inputs. +controls=[] +def reject(name,test): + need(not test(), 'control accepted '+name);controls.append(name) +reject('duplicate helper',lambda: np.array_equal(np.r_[rows[0,1],rows[:-1,1]],np.tile(np.arange(408),N))) +reject('strict lower endpoint used as available',lambda: bool(lo[o[0],c[0]]Q(old['kappa']),'same fresh strict successor K') + (work/'RESULT.json').write_text(json.dumps(dict(status='PASS_FULL_OWNER_SUCCESSOR_RELEASE',kappa=fresh['kappa'],retained_bootstrap_reused=bool(a.retained),scope='Conditional finite release; all inherited all-size hypotheses remain.'),indent=2)+'\n') +if __name__=='__main__':main() diff --git a/research/staged-644-660-owner-successor/vendor/PR3605-MANIFEST.json b/research/staged-644-660-owner-successor/vendor/PR3605-MANIFEST.json new file mode 100644 index 0000000000..cebbe9bd45 --- /dev/null +++ b/research/staged-644-660-owner-successor/vendor/PR3605-MANIFEST.json @@ -0,0 +1,260 @@ +{ + "archive_sha256": "c00e3d494295e2d069c7abb210676ca0ff0ff95f68d467c8552960fe78a4fed6", + "files": { + "LICENSE": { + "bytes": 11357, + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "LICENSE" + }, + "research/staged-644-660-conditional-release/ARITHMETIC-PINS.json": { + "bytes": 10054, + "git_blob": "a3d78535278e00609f97ca4c380dcf37d604c3ab", + "sha256": "b1092c4a5aa06b34ea59d07287ba571838de8ed6d3515e4da0219c6c6c776395", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/ARITHMETIC-PINS.json" + }, + "research/staged-644-660-conditional-release/CLAIM.json": { + "bytes": 1598, + "git_blob": "445e6a83a4cdc6e8630e86f20990b50d1311f81d", + "sha256": "2e721209f626d5111142951b1f26383d6746b4f230a4625244b5e5c84d6079d5", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/CLAIM.json" + }, + "research/staged-644-660-conditional-release/DERIVATION.md": { + "bytes": 7830, + "git_blob": "30710a70b9d9e2b8625ba69fcfbf4c2ba736a8e9", + "sha256": "0570b25a98261ed62c9c5709e14a8f6f6c5a921a73286739212c3954c3e7de27", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/DERIVATION.md" + }, + "research/staged-644-660-conditional-release/FETCH.txt": { + "bytes": 1259, + "git_blob": "d311cb51d76ec5a88762de0e148d0feb295b9fdc", + "sha256": "df2e78dc2e66d67930bd3506f150dd83e06274f8282714ffd4f6fe164523dca4", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/FETCH.txt" + }, + "research/staged-644-660-conditional-release/README.md": { + "bytes": 6651, + "git_blob": "e6408f66e7a5db0ec680eead0e1710b219598616", + "sha256": "41ae8d2e718677a679909a29bd60aec97cd9ccb1dd3255e36f08d670fecb876b", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/README.md" + }, + "research/staged-644-660-conditional-release/STAGE-SCOPE.json": { + "bytes": 3804, + "git_blob": "3e3de091d2c8ea40707858bedaa51dfa4265a46f", + "sha256": "686bc141663bae0354afbcc9ea8ff81cdffcdfc10e6699357c4bf393a430e979", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/STAGE-SCOPE.json" + }, + "research/staged-644-660-conditional-release/check_arithmetic.py": { + "bytes": 6646, + "git_blob": "49062ba526c90670c2efa9cccedc4f69e2f74f5b", + "sha256": "ee4a9cd92267b70a0d482377331bbb4ae9555cf68cf3f7467e46f9923567c91b", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/check_arithmetic.py" + }, + "research/staged-644-660-conditional-release/owners/AGGREGATE-INTEGER-FLOW.json.gz": { + "bytes": 21785, + "git_blob": "104962d079d315f3caf5269ff0e8ff0fbae7fee8", + "sha256": "392d9ff80e641a79c9375e71df7f745e9d48f6e0914851a4ed4ecd079e0df2e9", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/AGGREGATE-INTEGER-FLOW.json.gz" + }, + "research/staged-644-660-conditional-release/owners/PROOF.md": { + "bytes": 9439, + "git_blob": "2a64b0bc3ec945982c68f7609b9afea9ed24f162", + "sha256": "11113405347bb8a85a85c6d5b516ff3dcdb15e01d4b16f825ba4eb314a1be5cd", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/PROOF.md" + }, + "research/staged-644-660-conditional-release/owners/SOURCE-CREDITS.md": { + "bytes": 5030, + "git_blob": "24f00912d4ec829c3c8d2a8d086aa135664a124c", + "sha256": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/SOURCE-CREDITS.md" + }, + "research/staged-644-660-conditional-release/owners/SOURCE-NOTICE": { + "bytes": 3234, + "git_blob": "89c20926ea7f803718f751d95989d5a269908efd", + "sha256": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/SOURCE-NOTICE" + }, + "research/staged-644-660-conditional-release/owners/SOURCE-PINS.json": { + "bytes": 4238, + "git_blob": "5ddf1574c7bdf7ebcf9d6b7e50bad8aa339a1a8c", + "sha256": "6c334914c592b26eeeadd9fbe3a0aa2a52f22fc66df7704fc80b5f45874d9916", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/SOURCE-PINS.json" + }, + "research/staged-644-660-conditional-release/owners/actual-t740-prefix/OWNER-CHECK.json": { + "bytes": 500, + "git_blob": "315a64f61af2895852d20f09aabe270f60508206", + "sha256": "25b46766913b05439c324e7b805e36981ea775d9caa099bdadc8f2745ffa8008", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/actual-t740-prefix/OWNER-CHECK.json" + }, + "research/staged-644-660-conditional-release/owners/actual-t740-prefix/PREFIX-REPACK.json": { + "bytes": 502, + "git_blob": "d201183c2b2e6536e8006085bbb8ace2b1b05f6d", + "sha256": "91b2515b6f28f7a77f82ef4601dbadb16a85afe4c10ce9313a9f2f08158fb8cd", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/actual-t740-prefix/PREFIX-REPACK.json" + }, + "research/staged-644-660-conditional-release/owners/actual-t740-prefix/PROFILE.json": { + "bytes": 122, + "git_blob": "c07729b45be9ae1852fee92afc294639e7c66a36", + "sha256": "779e8775d398e81a2315695573ab779e5039e45e7497f9eb6c8125097b51cc14", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/actual-t740-prefix/PROFILE.json" + }, + "research/staged-644-660-conditional-release/owners/actual-t740-prefix/PROVIDERS.json": { + "bytes": 1818, + "git_blob": "f321d4185339244b8b004326af70e653e611d84a", + "sha256": "d96f2798024ab83edbb8848b62c425992aec182f1f24ef46bb8286dd390618c2", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/actual-t740-prefix/PROVIDERS.json" + }, + "research/staged-644-660-conditional-release/owners/integral_network.py": { + "bytes": 3525, + "git_blob": "36c664e6d5ed44a621fe9ffeb2fe54cb99210d33", + "sha256": "d9d20262cd509e2b3ed5ce12036cb8abb90c52f1d84531317b88e2bbb0426745", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/integral_network.py" + }, + "research/staged-644-660-conditional-release/owners/portable_expand.py": { + "bytes": 8250, + "git_blob": "f510d1911126e46399f93c2d16d0bccd216c4e97", + "sha256": "76fa44cf996b97d7e7a89fb0a93e734b41efc7c0e07cbbc14bfac635e174600c", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/portable_expand.py" + }, + "research/staged-644-660-conditional-release/owners/verify_aggregate.py": { + "bytes": 5301, + "git_blob": "a5e828b6de7eb691e94eec1ee52ea47fd9a2971f", + "sha256": "c10a0eb62799f73dd577a5bec86e91b0124ec8b2cdf95bd68807299cf1521866", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/owners/verify_aggregate.py" + }, + "research/staged-644-660-conditional-release/portable_source_overlay.py": { + "bytes": 6210, + "git_blob": "9965bd5b34d0cb09308e071faa083ae4157dbd1f", + "sha256": "7e29707ad0785466abb623a4c2ad3675641f8fb6dc74d3de7561951c67e303e8", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/portable_source_overlay.py" + }, + "research/staged-644-660-conditional-release/reproduce.py": { + "bytes": 8191, + "git_blob": "4e9b86a02f72a7c1ecbaea73a9666d694ec4b8c1", + "sha256": "3c19c5a8f7f833af42c41e58d60deaeb0424bd33759ff28122eb0f7da0ff2a44", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/reproduce.py" + }, + "research/staged-644-660-conditional-release/staged_pair_review.py": { + "bytes": 3404, + "git_blob": "7a0b49985fb76ee858af7beccd3a25f613e63c30", + "sha256": "b33b4e4e85035086c60c252cb2026b6035453879d8ce57302a76c45374830bf3", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/staged_pair_review.py" + }, + "research/staged-644-660-conditional-release/vendor/pr3531/SOURCES.json": { + "bytes": 19753, + "git_blob": "28057768c10b2126fb61cb97546e259e001d9875", + "sha256": "30fc7635c08820a54f4b34485cbbfc154cacd97c6a484b52f182c77a9bc45189", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/vendor/pr3531/SOURCES.json" + }, + "research/staged-644-660-conditional-release/vendor/pr3531/binomial.py": { + "bytes": 1416, + "git_blob": "53158ee2e371558bbc08638ce583d860e13c0e45", + "sha256": "03eebf2be23cab07e5f9e978980fee7b17e10847da5720c3e4e0adb243e8e4fa", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/vendor/pr3531/binomial.py" + }, + "research/staged-644-660-conditional-release/vendor/pr3531/support.py": { + "bytes": 2688, + "git_blob": "5421902f0c5912c8c284614650d8d72af394c17e", + "sha256": "a3fe5057bf4a8706289b49c772676a57df8f8f7481c1d6dbb637e76361fae067", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/vendor/pr3531/support.py" + }, + "research/staged-644-660-conditional-release/vendor/pr3531/vendor/PR3361-CLAIM.json": { + "bytes": 1199, + "git_blob": "87cacd0dd167954f70f6a2404604b12d126a447b", + "sha256": "43aadbe1181516c97ea7f12c65e65ee757df08ead084a9cbbd48a46ed6c59089", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/vendor/pr3531/vendor/PR3361-CLAIM.json" + }, + "research/staged-644-660-conditional-release/vendor/pr3531/vendor/PR3361-NOTICE": { + "bytes": 960, + "git_blob": "9c53f25cdf54b20ea66f0eeda2054f9cb0d3ead7", + "sha256": "d065f2ddf9931a63c44bd5d2eef1164c8cafa57710cbf279feadf249867c802d", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-conditional-release/vendor/pr3531/vendor/PR3361-NOTICE" + }, + "research/staged-644-660-width-reduction/PROOF.md": { + "bytes": 10937, + "git_blob": "020ab84ae73b04a94d5f49dae77c37d766ceb532", + "sha256": "525b010f3a895bdb11313f9938ad1b742df64bcee0b5671399230b1ded541baf", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-width-reduction/PROOF.md" + }, + "research/staged-644-660-width-reduction/README.md": { + "bytes": 3909, + "git_blob": "003a156197e32a437949c4a02b352ab8698f4eee", + "sha256": "c1956badbcd92f2f88dcea833facc39eefb7eef8f220fb7b1941b4c552109d89", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-width-reduction/README.md" + }, + "research/staged-644-660-width-reduction/SOURCES.json": { + "bytes": 6131, + "git_blob": "cea7a3cf7560ad38594449410b0da417936db2d5", + "sha256": "005bf38ae679a9fb3ad1ee94b8c35bdfec58451ef58e0a87b0c7b68ef4fc51d5", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-width-reduction/SOURCES.json" + }, + "research/staged-644-660-width-reduction/STAGED-PAIR-RECORD-base.json.gz": { + "bytes": 660, + "git_blob": "042dbc69aee653e0a3c66a5910f14c741e5b39a7", + "sha256": "a6ae4188be998990ecb176fef5929e8e1dfce3726e372c0da2a290fe8ea73532", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-width-reduction/STAGED-PAIR-RECORD-base.json.gz" + }, + "research/staged-644-660-width-reduction/STAGED-PAIR-RECORD-extra.json.gz": { + "bytes": 661, + "git_blob": "67f04ae395ec5f05586af438eeb2ad2db23c9c82", + "sha256": "33a39d46d4d19bdeb6f0b6abb38cc80c68219e1ae10dd7e1acaccedc14b47236", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-width-reduction/STAGED-PAIR-RECORD-extra.json.gz" + }, + "research/staged-644-660-width-reduction/STAGED644-660-base.json.gz": { + "bytes": 72570, + "git_blob": "dc6d321b1e8e2a837a1ff7bb60e8f8f78d043db5", + "sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-width-reduction/STAGED644-660-base.json.gz" + }, + "research/staged-644-660-width-reduction/STAGED644-660-extra.json.gz": { + "bytes": 72568, + "git_blob": "78e7b2bb0653c8dcc0133980a19dd9d97ebdb67e", + "sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-width-reduction/STAGED644-660-extra.json.gz" + }, + "research/staged-644-660-width-reduction/staged_pair.py": { + "bytes": 4564, + "git_blob": "ca3e3effb97f46485ab7ac8c15ce4a92e1f93fbe", + "sha256": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747", + "source_head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "source_path": "research/staged-644-660-width-reduction/staged_pair.py" + } + }, + "head": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "scope": "Exact selected PR3605 Git blobs. Unchanged predecessor producer/source/proof and arithmetic closure; no generated full literal or648-file source tree included.", + "tar_payload_sha256": "876960ea2d21df4bb6ffe313e3725eee90173c4f5310fb68726b62d048460337" +} diff --git a/research/staged-644-660-owner-successor/vendor/PR3605-SOURCES.tar.gz b/research/staged-644-660-owner-successor/vendor/PR3605-SOURCES.tar.gz new file mode 100644 index 0000000000..7db4b91db5 Binary files /dev/null and b/research/staged-644-660-owner-successor/vendor/PR3605-SOURCES.tar.gz differ diff --git a/research/staged-644-660-owner-successor/verify.py b/research/staged-644-660-owner-successor/verify.py new file mode 100644 index 0000000000..9d41036096 --- /dev/null +++ b/research/staged-644-660-owner-successor/verify.py @@ -0,0 +1,22 @@ +"""Bounded registered replay; safe when the parent interpreter is optimized.""" +from pathlib import Path +import argparse,hashlib,json,os,subprocess,sys,tempfile +P=Path(__file__).resolve().parent +def need(v,s): + if not v:raise ValueError(s) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--repo',type=Path,default=P.parents[1]);ap.add_argument('--out',type=Path);a=ap.parse_args() + manifest=json.loads((P/'ARTIFACTS.json').read_bytes()) + for name,digest in manifest.items():need((P/name).is_file() and not (P/name).is_symlink() and sha(P/name)==digest,'package artifact '+name) + out=a.out.resolve() if a.out else Path(tempfile.mkdtemp(prefix='owner-successor-'))/'replay' + need(not out.exists(),'fresh output required') + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONPYCACHEPREFIX=str(out.parent/(out.name+'-pycache')),GIT_NO_REPLACE_OBJECTS='1') + for k in ('PYTHONOPTIMIZE','PYTHONPATH'):env.pop(k,None) + r=subprocess.run([sys.executable,'-B',str(P/'check.py'),'--repo',str(a.repo.resolve()),'--out',str(out)],env=env,timeout=570) + need(r.returncode==0,'fresh complete replay failed') + r=subprocess.run([sys.executable,'-B',str(P/'check_release_binding.py'),'--fresh',str(out)],env=env,timeout=20) + need(r.returncode==0,'recorded release binding failed') + need(all(sha(P/name)==digest for name,digest in manifest.items()),'package changed during replay') + print('PASS_REGISTERED_OWNER_SUCCESSOR',out/'RESULT.json') +if __name__=='__main__':main()